void
glAccum(op, value)
  GLenum op;
  GLfloat value;
CODE:
  OGLM_GLEWINIT
  OGLM_CHECK_ERR(glAccum, )
  glAccum(op, value);
  OGLM_CHECK_ERR(glAccum, )

GLboolean
glAcquireKeyedMutexWin32EXT(memory, key, timeout)
  GLuint memory;
  GLuint64 key;
  GLuint timeout;
CODE:
  OGLM_GLEWINIT
  OGLM_CHECK_ERR(glAcquireKeyedMutexWin32EXT, )
  OGLM_AVAIL_CHECK(__glewAcquireKeyedMutexWin32EXT, glAcquireKeyedMutexWin32EXT)
  RETVAL = glAcquireKeyedMutexWin32EXT(memory, key, timeout);
  OGLM_CHECK_ERR(glAcquireKeyedMutexWin32EXT, )
OUTPUT:
  RETVAL

void
glActiveProgramEXT(program)
  GLuint program;
CODE:
  OGLM_GLEWINIT
  OGLM_CHECK_ERR(glActiveProgramEXT, )
  OGLM_AVAIL_CHECK(__glewActiveProgramEXT, glActiveProgramEXT)
  glActiveProgramEXT(program);
  OGLM_CHECK_ERR(glActiveProgramEXT, )

void
glActiveShaderProgram(pipeline, program)
  GLuint pipeline;
  GLuint program;
CODE:
  OGLM_GLEWINIT
  OGLM_CHECK_ERR(glActiveShaderProgram, )
  OGLM_AVAIL_CHECK(__glewActiveShaderProgram, glActiveShaderProgram)
  glActiveShaderProgram(pipeline, program);
  OGLM_CHECK_ERR(glActiveShaderProgram, )

void
glActiveStencilFaceEXT(face)
  GLenum face;
CODE:
  OGLM_GLEWINIT
  OGLM_CHECK_ERR(glActiveStencilFaceEXT, )
  OGLM_AVAIL_CHECK(__glewActiveStencilFaceEXT, glActiveStencilFaceEXT)
  glActiveStencilFaceEXT(face);
  OGLM_CHECK_ERR(glActiveStencilFaceEXT, )

void
glActiveTexture(texture)
  GLenum texture;
ALIAS:
  glActiveTextureARB = 1
CODE:
  OGLM_GLEWINIT
  OGLM_CHECK_ERR(glActiveTexture, )
  OGLM_AVAIL_CHECK(__glewActiveTexture, glActiveTexture)
  glActiveTexture(texture);
  OGLM_CHECK_ERR(glActiveTexture, )

void
glActiveVaryingNV(program, name)
  GLuint program;
  const GLchar *name;
CODE:
  OGLM_GLEWINIT
  OGLM_CHECK_ERR(glActiveVaryingNV, )
  OGLM_AVAIL_CHECK(__glewActiveVaryingNV, glActiveVaryingNV)
  glActiveVaryingNV(program, name);
  OGLM_CHECK_ERR(glActiveVaryingNV, )

void
glAddSwapHintRectWIN(x, y, width, height)
  GLint x;
  GLint y;
  GLsizei width;
  GLsizei height;
CODE:
  OGLM_GLEWINIT
  OGLM_CHECK_ERR(glAddSwapHintRectWIN, )
  OGLM_AVAIL_CHECK(__glewAddSwapHintRectWIN, glAddSwapHintRectWIN)
  glAddSwapHintRectWIN(x, y, width, height);
  OGLM_CHECK_ERR(glAddSwapHintRectWIN, )

void
glAddressSpace(space, mask)
  GLenum space;
  GLbitfield mask;
CODE:
  OGLM_GLEWINIT
  OGLM_CHECK_ERR(glAddressSpace, )
  OGLM_AVAIL_CHECK(__glewAddressSpace, glAddressSpace)
  glAddressSpace(space, mask);
  OGLM_CHECK_ERR(glAddressSpace, )

void
glAllocMPEGPredictorsSGIX_c(width, height, n, predictors)
  GLsizei width;
  GLsizei height;
  GLsizei n;
  GLuint* predictors;
CODE:
  OGLM_GLEWINIT
  OGLM_CHECK_ERR(glAllocMPEGPredictorsSGIX, )
  OGLM_AVAIL_CHECK(__glewAllocMPEGPredictorsSGIX, glAllocMPEGPredictorsSGIX)
  glAllocMPEGPredictorsSGIX(width, height, n, predictors);
  OGLM_CHECK_ERR(glAllocMPEGPredictorsSGIX, )

void
glAlphaFragmentOp1ATI(op, dst, dstMod, arg1, arg1Rep, arg1Mod)
  GLenum op;
  GLuint dst;
  GLuint dstMod;
  GLuint arg1;
  GLuint arg1Rep;
  GLuint arg1Mod;
CODE:
  OGLM_GLEWINIT
  OGLM_CHECK_ERR(glAlphaFragmentOp1ATI, )
  OGLM_AVAIL_CHECK(__glewAlphaFragmentOp1ATI, glAlphaFragmentOp1ATI)
  glAlphaFragmentOp1ATI(op, dst, dstMod, arg1, arg1Rep, arg1Mod);
  OGLM_CHECK_ERR(glAlphaFragmentOp1ATI, )

void
glAlphaFragmentOp2ATI(op, dst, dstMod, arg1, arg1Rep, arg1Mod, arg2, arg2Rep, arg2Mod)
  GLenum op;
  GLuint dst;
  GLuint dstMod;
  GLuint arg1;
  GLuint arg1Rep;
  GLuint arg1Mod;
  GLuint arg2;
  GLuint arg2Rep;
  GLuint arg2Mod;
CODE:
  OGLM_GLEWINIT
  OGLM_CHECK_ERR(glAlphaFragmentOp2ATI, )
  OGLM_AVAIL_CHECK(__glewAlphaFragmentOp2ATI, glAlphaFragmentOp2ATI)
  glAlphaFragmentOp2ATI(op, dst, dstMod, arg1, arg1Rep, arg1Mod, arg2, arg2Rep, arg2Mod);
  OGLM_CHECK_ERR(glAlphaFragmentOp2ATI, )

void
glAlphaFragmentOp3ATI(op, dst, dstMod, arg1, arg1Rep, arg1Mod, arg2, arg2Rep, arg2Mod, arg3, arg3Rep, arg3Mod)
  GLenum op;
  GLuint dst;
  GLuint dstMod;
  GLuint arg1;
  GLuint arg1Rep;
  GLuint arg1Mod;
  GLuint arg2;
  GLuint arg2Rep;
  GLuint arg2Mod;
  GLuint arg3;
  GLuint arg3Rep;
  GLuint arg3Mod;
CODE:
  OGLM_GLEWINIT
  OGLM_CHECK_ERR(glAlphaFragmentOp3ATI, )
  OGLM_AVAIL_CHECK(__glewAlphaFragmentOp3ATI, glAlphaFragmentOp3ATI)
  glAlphaFragmentOp3ATI(op, dst, dstMod, arg1, arg1Rep, arg1Mod, arg2, arg2Rep, arg2Mod, arg3, arg3Rep, arg3Mod);
  OGLM_CHECK_ERR(glAlphaFragmentOp3ATI, )

void
glAlphaFunc(func, ref)
  GLenum func;
  GLclampf ref;
CODE:
  OGLM_GLEWINIT
  OGLM_CHECK_ERR(glAlphaFunc, )
  glAlphaFunc(func, ref);
  OGLM_CHECK_ERR(glAlphaFunc, )

void
glAlphaFuncQCOM(func, ref)
  GLenum func;
  GLclampf ref;
CODE:
  OGLM_GLEWINIT
  OGLM_CHECK_ERR(glAlphaFuncQCOM, )
  OGLM_AVAIL_CHECK(__glewAlphaFuncQCOM, glAlphaFuncQCOM)
  glAlphaFuncQCOM(func, ref);
  OGLM_CHECK_ERR(glAlphaFuncQCOM, )

void
glAlphaFuncx(func, ref)
  GLenum func;
  GLclampx ref;
CODE:
  OGLM_GLEWINIT
  OGLM_CHECK_ERR(glAlphaFuncx, )
  OGLM_AVAIL_CHECK(__glewAlphaFuncx, glAlphaFuncx)
  glAlphaFuncx(func, ref);
  OGLM_CHECK_ERR(glAlphaFuncx, )

void
glAlphaToCoverageDitherControlNV(mode)
  GLenum mode;
CODE:
  OGLM_GLEWINIT
  OGLM_CHECK_ERR(glAlphaToCoverageDitherControlNV, )
  OGLM_AVAIL_CHECK(__glewAlphaToCoverageDitherControlNV, glAlphaToCoverageDitherControlNV)
  glAlphaToCoverageDitherControlNV(mode);
  OGLM_CHECK_ERR(glAlphaToCoverageDitherControlNV, )

void
glApplyFramebufferAttachmentCMAAINTEL()
CODE:
  OGLM_GLEWINIT
  OGLM_CHECK_ERR(glApplyFramebufferAttachmentCMAAINTEL, )
  OGLM_AVAIL_CHECK(__glewApplyFramebufferAttachmentCMAAINTEL, glApplyFramebufferAttachmentCMAAINTEL)
  glApplyFramebufferAttachmentCMAAINTEL();
  OGLM_CHECK_ERR(glApplyFramebufferAttachmentCMAAINTEL, )

void
glApplyTextureEXT(mode)
  GLenum mode;
CODE:
  OGLM_GLEWINIT
  OGLM_CHECK_ERR(glApplyTextureEXT, )
  OGLM_AVAIL_CHECK(__glewApplyTextureEXT, glApplyTextureEXT)
  glApplyTextureEXT(mode);
  OGLM_CHECK_ERR(glApplyTextureEXT, )

GLboolean
glAreProgramsResidentNV_c(n, programs, residences)
  GLsizei n;
  const GLuint* programs;
  GLboolean *residences;
CODE:
  OGLM_GLEWINIT
  OGLM_CHECK_ERR(glAreProgramsResidentNV, )
  OGLM_AVAIL_CHECK(__glewAreProgramsResidentNV, glAreProgramsResidentNV)
  RETVAL = glAreProgramsResidentNV(n, programs, residences);
  OGLM_CHECK_ERR(glAreProgramsResidentNV, )
OUTPUT:
  RETVAL

GLboolean
glAreProgramsResidentNV_p(...)
PPCODE:
  OGLM_GLEWINIT
  OGLM_CHECK_ERR(glAreProgramsResidentNV, )
  OGLM_AVAIL_CHECK(__glewAreProgramsResidentNV, glAreProgramsResidentNV)
  GLsizei n = items;
  GLuint* programs = OGLM_GET_VARARGS(programs,0,GLuint,UV,n);
  GLboolean *residences = OGLM_ALLOC(n,GLboolean,residences);
  RETVAL = glAreProgramsResidentNV((GLsizei )n, (const GLuint* )programs, (GLboolean *)residences);
  OGLM_CHECK_ERR(glAreProgramsResidentNV, free(residences);free(programs);)
  EXTEND(sp, 2);
  mPUSHs(newSViv(RETVAL));
  OGLM_PUSH_ARRAY(glAreProgramsResidentNV, newSViv, residences, n)
  free(residences);free(programs);

GLboolean
glAreTexturesResident_c(n, textures, residences)
  GLsizei n;
  const GLuint *textures;
  GLboolean *residences;
CODE:
  OGLM_GLEWINIT
  OGLM_CHECK_ERR(glAreTexturesResident, )
  RETVAL = glAreTexturesResident(n, textures, residences);
  OGLM_CHECK_ERR(glAreTexturesResident, )
OUTPUT:
  RETVAL

GLboolean
glAreTexturesResident_p(...)
PPCODE:
  OGLM_GLEWINIT
  OGLM_CHECK_ERR(glAreTexturesResident, )
  GLsizei n = items;
  GLboolean *residences = OGLM_ALLOC(n,GLboolean,residences);
  GLuint *textures = OGLM_GET_VARARGS(textures,0,GLuint,UV,n);
  RETVAL = glAreTexturesResident((GLsizei )n, (const GLuint *)textures, (GLboolean *)residences);
  OGLM_CHECK_ERR(glAreTexturesResident, free(residences);free(textures);)
  EXTEND(sp, 2);
  mPUSHs(newSViv(RETVAL));
  OGLM_PUSH_ARRAY(glAreTexturesResident, newSViv, residences, n)
  free(residences);free(textures);

GLboolean
glAreTexturesResidentEXT_c(n, textures, residences)
  GLsizei n;
  const GLuint* textures;
  GLboolean* residences;
CODE:
  OGLM_GLEWINIT
  OGLM_CHECK_ERR(glAreTexturesResidentEXT, )
  OGLM_AVAIL_CHECK(__glewAreTexturesResidentEXT, glAreTexturesResidentEXT)
  RETVAL = glAreTexturesResidentEXT(n, textures, residences);
  OGLM_CHECK_ERR(glAreTexturesResidentEXT, )
OUTPUT:
  RETVAL

GLboolean
glAreTexturesResidentEXT_p(...)
PPCODE:
  OGLM_GLEWINIT
  OGLM_CHECK_ERR(glAreTexturesResidentEXT, )
  OGLM_AVAIL_CHECK(__glewAreTexturesResidentEXT, glAreTexturesResidentEXT)
  GLsizei n = items;
  GLboolean* residences = OGLM_ALLOC(n,GLboolean,residences);
  GLuint* textures = OGLM_GET_VARARGS(textures,0,GLuint,UV,n);
  RETVAL = glAreTexturesResidentEXT((GLsizei )n, (const GLuint* )textures, (GLboolean* )residences);
  OGLM_CHECK_ERR(glAreTexturesResidentEXT, free(residences);free(textures);)
  EXTEND(sp, 2);
  mPUSHs(newSViv(RETVAL));
  OGLM_PUSH_ARRAY(glAreTexturesResidentEXT, newSViv, residences, n)
  free(residences);free(textures);

GLboolean
glAreVertexArraysResidentSGIX_c(n, arrays, residences)
  GLsizei n;
  const GLuint* arrays;
  GLboolean* residences;
CODE:
  OGLM_GLEWINIT
  OGLM_CHECK_ERR(glAreVertexArraysResidentSGIX, )
  OGLM_AVAIL_CHECK(__glewAreVertexArraysResidentSGIX, glAreVertexArraysResidentSGIX)
  RETVAL = glAreVertexArraysResidentSGIX(n, arrays, residences);
  OGLM_CHECK_ERR(glAreVertexArraysResidentSGIX, )
OUTPUT:
  RETVAL

void
glArrayElement(i)
  GLint i;
ALIAS:
  glArrayElementEXT = 1
CODE:
  OGLM_GLEWINIT
  OGLM_CHECK_ERR(glArrayElement, )
  glArrayElement(i);
  OGLM_CHECK_ERR(glArrayElement, )

void
glArrayObjectATI(array, size, type, stride, buffer, offset)
  GLenum array;
  GLint size;
  GLenum type;
  GLsizei stride;
  GLuint buffer;
  GLuint offset;
CODE:
  OGLM_GLEWINIT
  OGLM_CHECK_ERR(glArrayObjectATI, )
  OGLM_AVAIL_CHECK(__glewArrayObjectATI, glArrayObjectATI)
  glArrayObjectATI(array, size, type, stride, buffer, offset);
  OGLM_CHECK_ERR(glArrayObjectATI, )

GLsync
glAsyncCopyBufferSubDataNVX_c(waitSemaphoreCount, waitSemaphoreArray, fenceValueArray, readGpu, writeGpuMask, readBuffer, writeBuffer, readOffset, writeOffset, size, signalSemaphoreCount, signalSemaphoreArray, signalValueArray)
  GLsizei waitSemaphoreCount;
  const GLuint* waitSemaphoreArray;
  const GLuint64 *fenceValueArray;
  GLuint readGpu;
  GLbitfield writeGpuMask;
  GLuint readBuffer;
  GLuint writeBuffer;
  GLintptr readOffset;
  GLintptr writeOffset;
  GLsizeiptr size;
  GLsizei signalSemaphoreCount;
  const GLuint *signalSemaphoreArray;
  const GLuint64 *signalValueArray;
CODE:
  OGLM_GLEWINIT
  OGLM_CHECK_ERR(glAsyncCopyBufferSubDataNVX, )
  OGLM_AVAIL_CHECK(__glewAsyncCopyBufferSubDataNVX, glAsyncCopyBufferSubDataNVX)
  RETVAL = glAsyncCopyBufferSubDataNVX(waitSemaphoreCount, waitSemaphoreArray, fenceValueArray, readGpu, writeGpuMask, readBuffer, writeBuffer, readOffset, writeOffset, size, signalSemaphoreCount, signalSemaphoreArray, signalValueArray);
  OGLM_CHECK_ERR(glAsyncCopyBufferSubDataNVX, )
OUTPUT:
  RETVAL

GLsync
glAsyncCopyBufferSubDataNVX_p(waitSemaphoreArraySV, fenceValueArraySV, readGpu, writeGpuMask, readBuffer, writeBuffer, readOffset, writeOffset, size, signalSemaphoreArraySV, signalValueArraySV)
  SV *waitSemaphoreArraySV;
  SV *fenceValueArraySV;
  GLuint readGpu;
  GLbitfield writeGpuMask;
  GLuint readBuffer;
  GLuint writeBuffer;
  GLintptr readOffset;
  GLintptr writeOffset;
  GLsizeiptr size;
  SV *signalSemaphoreArraySV;
  SV *signalValueArraySV;
CODE:
  OGLM_GLEWINIT
  OGLM_CHECK_ERR(glAsyncCopyBufferSubDataNVX, )
  OGLM_AVAIL_CHECK(__glewAsyncCopyBufferSubDataNVX, glAsyncCopyBufferSubDataNVX)
  GLsizei signalSemaphoreCount = OGLM_LEN_ARRAY(signalSemaphoreCount, signalSemaphoreArray);
  GLsizei waitSemaphoreCount = OGLM_LEN_ARRAY(waitSemaphoreCount, waitSemaphoreArray);
  GLuint64 *fenceValueArray = OGLM_GET_ARRAY(fenceValueArray, GLuint64, UV, waitSemaphoreCount);
  GLuint *signalSemaphoreArray = OGLM_GET_ARRAY(signalSemaphoreArray, GLuint, UV, signalSemaphoreCount);
  GLuint64 *signalValueArray = OGLM_GET_ARRAY(signalValueArray, GLuint64, UV, signalSemaphoreCount);
  GLuint* waitSemaphoreArray = OGLM_GET_ARRAY(waitSemaphoreArray, GLuint, UV, waitSemaphoreCount);
  RETVAL = glAsyncCopyBufferSubDataNVX((GLsizei )waitSemaphoreCount, (const GLuint* )waitSemaphoreArray, (const GLuint64 *)fenceValueArray, (GLuint )readGpu, (GLbitfield )writeGpuMask, (GLuint )readBuffer, (GLuint )writeBuffer, (GLintptr )readOffset, (GLintptr )writeOffset, (GLsizeiptr )size, (GLsizei )signalSemaphoreCount, (const GLuint *)signalSemaphoreArray, (const GLuint64 *)signalValueArray);
  OGLM_CHECK_ERR(glAsyncCopyBufferSubDataNVX, free(fenceValueArray);free(signalSemaphoreArray);free(signalValueArray);free(waitSemaphoreArray);)
  free(fenceValueArray);free(signalSemaphoreArray);free(signalValueArray);free(waitSemaphoreArray);
OUTPUT:
  RETVAL

GLuint
glAsyncCopyImageSubDataNVX_c(waitSemaphoreCount, waitSemaphoreArray, waitValueArray, srcGpu, dstGpuMask, srcName, srcTarget, srcLevel, srcX, srcY, srcZ, dstName, dstTarget, dstLevel, dstX, dstY, dstZ, srcWidth, srcHeight, srcDepth, signalSemaphoreCount, signalSemaphoreArray, signalValueArray)
  GLsizei waitSemaphoreCount;
  const GLuint* waitSemaphoreArray;
  const GLuint64 *waitValueArray;
  GLuint srcGpu;
  GLbitfield dstGpuMask;
  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;
  GLsizei signalSemaphoreCount;
  const GLuint *signalSemaphoreArray;
  const GLuint64 *signalValueArray;
CODE:
  OGLM_GLEWINIT
  OGLM_CHECK_ERR(glAsyncCopyImageSubDataNVX, )
  OGLM_AVAIL_CHECK(__glewAsyncCopyImageSubDataNVX, glAsyncCopyImageSubDataNVX)
  RETVAL = glAsyncCopyImageSubDataNVX(waitSemaphoreCount, waitSemaphoreArray, waitValueArray, srcGpu, dstGpuMask, srcName, srcTarget, srcLevel, srcX, srcY, srcZ, dstName, dstTarget, dstLevel, dstX, dstY, dstZ, srcWidth, srcHeight, srcDepth, signalSemaphoreCount, signalSemaphoreArray, signalValueArray);
  OGLM_CHECK_ERR(glAsyncCopyImageSubDataNVX, )
OUTPUT:
  RETVAL

GLuint
glAsyncCopyImageSubDataNVX_p(waitSemaphoreArraySV, waitValueArraySV, srcGpu, dstGpuMask, srcName, srcTarget, srcLevel, srcX, srcY, srcZ, dstName, dstTarget, dstLevel, dstX, dstY, dstZ, srcWidth, srcHeight, srcDepth, signalSemaphoreArraySV, signalValueArraySV)
  SV *waitSemaphoreArraySV;
  SV *waitValueArraySV;
  GLuint srcGpu;
  GLbitfield dstGpuMask;
  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;
  SV *signalSemaphoreArraySV;
  SV *signalValueArraySV;
CODE:
  OGLM_GLEWINIT
  OGLM_CHECK_ERR(glAsyncCopyImageSubDataNVX, )
  OGLM_AVAIL_CHECK(__glewAsyncCopyImageSubDataNVX, glAsyncCopyImageSubDataNVX)
  GLsizei signalSemaphoreCount = OGLM_LEN_ARRAY(signalSemaphoreCount, signalSemaphoreArray);
  GLsizei waitSemaphoreCount = OGLM_LEN_ARRAY(waitSemaphoreCount, waitSemaphoreArray);
  GLuint *signalSemaphoreArray = OGLM_GET_ARRAY(signalSemaphoreArray, GLuint, UV, signalSemaphoreCount);
  GLuint64 *signalValueArray = OGLM_GET_ARRAY(signalValueArray, GLuint64, UV, signalSemaphoreCount);
  GLuint* waitSemaphoreArray = OGLM_GET_ARRAY(waitSemaphoreArray, GLuint, UV, waitSemaphoreCount);
  GLuint64 *waitValueArray = OGLM_GET_ARRAY(waitValueArray, GLuint64, UV, waitSemaphoreCount);
  RETVAL = glAsyncCopyImageSubDataNVX((GLsizei )waitSemaphoreCount, (const GLuint* )waitSemaphoreArray, (const GLuint64 *)waitValueArray, (GLuint )srcGpu, (GLbitfield )dstGpuMask, (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, (GLsizei )signalSemaphoreCount, (const GLuint *)signalSemaphoreArray, (const GLuint64 *)signalValueArray);
  OGLM_CHECK_ERR(glAsyncCopyImageSubDataNVX, free(signalSemaphoreArray);free(signalValueArray);free(waitSemaphoreArray);free(waitValueArray);)
  free(signalSemaphoreArray);free(signalValueArray);free(waitSemaphoreArray);free(waitValueArray);
OUTPUT:
  RETVAL

void
glAsyncMarkerSGIX(marker)
  GLuint marker;
CODE:
  OGLM_GLEWINIT
  OGLM_CHECK_ERR(glAsyncMarkerSGIX, )
  OGLM_AVAIL_CHECK(__glewAsyncMarkerSGIX, glAsyncMarkerSGIX)
  glAsyncMarkerSGIX(marker);
  OGLM_CHECK_ERR(glAsyncMarkerSGIX, )

void
glAttachObjectARB(containerObj, obj)
  GLhandleARB containerObj;
  GLhandleARB obj;
CODE:
  OGLM_GLEWINIT
  OGLM_CHECK_ERR(glAttachObjectARB, )
  OGLM_AVAIL_CHECK(__glewAttachObjectARB, glAttachObjectARB)
  glAttachObjectARB(containerObj, obj);
  OGLM_CHECK_ERR(glAttachObjectARB, )

void
glAttachShader(program, shader)
  GLuint program;
  GLuint shader;
CODE:
  OGLM_GLEWINIT
  OGLM_CHECK_ERR(glAttachShader, )
  OGLM_AVAIL_CHECK(__glewAttachShader, glAttachShader)
  glAttachShader(program, shader);
  OGLM_CHECK_ERR(glAttachShader, )

void
glBegin(mode)
  GLenum mode;
CODE:
  OGLM_GLEWINIT
  OGLM_CHECK_ERR(glBegin, )
  glBegin(mode);
  OGLM_CHECK_ERR(glBegin, )

void
glBeginConditionalRender(id, mode)
  GLuint id;
  GLenum mode;
ALIAS:
  glBeginConditionalRenderNV = 1
CODE:
  OGLM_GLEWINIT
  OGLM_CHECK_ERR(glBeginConditionalRender, )
  OGLM_AVAIL_CHECK(__glewBeginConditionalRender, glBeginConditionalRender)
  glBeginConditionalRender(id, mode);
  OGLM_CHECK_ERR(glBeginConditionalRender, )

void
glBeginConditionalRenderNVX(id)
  GLuint id;
CODE:
  OGLM_GLEWINIT
  OGLM_CHECK_ERR(glBeginConditionalRenderNVX, )
  OGLM_AVAIL_CHECK(__glewBeginConditionalRenderNVX, glBeginConditionalRenderNVX)
  glBeginConditionalRenderNVX(id);
  OGLM_CHECK_ERR(glBeginConditionalRenderNVX, )

void
glBeginFragmentShaderATI()
CODE:
  OGLM_GLEWINIT
  OGLM_CHECK_ERR(glBeginFragmentShaderATI, )
  OGLM_AVAIL_CHECK(__glewBeginFragmentShaderATI, glBeginFragmentShaderATI)
  glBeginFragmentShaderATI();
  OGLM_CHECK_ERR(glBeginFragmentShaderATI, )

void
glBeginOcclusionQueryNV(id)
  GLuint id;
CODE:
  OGLM_GLEWINIT
  OGLM_CHECK_ERR(glBeginOcclusionQueryNV, )
  OGLM_AVAIL_CHECK(__glewBeginOcclusionQueryNV, glBeginOcclusionQueryNV)
  glBeginOcclusionQueryNV(id);
  OGLM_CHECK_ERR(glBeginOcclusionQueryNV, )

void
glBeginPerfMonitorAMD(monitor)
  GLuint monitor;
CODE:
  OGLM_GLEWINIT
  OGLM_CHECK_ERR(glBeginPerfMonitorAMD, )
  OGLM_AVAIL_CHECK(__glewBeginPerfMonitorAMD, glBeginPerfMonitorAMD)
  glBeginPerfMonitorAMD(monitor);
  OGLM_CHECK_ERR(glBeginPerfMonitorAMD, )

void
glBeginPerfQueryINTEL(queryHandle)
  GLuint queryHandle;
CODE:
  OGLM_GLEWINIT
  OGLM_CHECK_ERR(glBeginPerfQueryINTEL, )
  OGLM_AVAIL_CHECK(__glewBeginPerfQueryINTEL, glBeginPerfQueryINTEL)
  glBeginPerfQueryINTEL(queryHandle);
  OGLM_CHECK_ERR(glBeginPerfQueryINTEL, )

void
glBeginQuery(target, id)
  GLenum target;
  GLuint id;
ALIAS:
  glBeginQueryARB = 1
CODE:
  OGLM_GLEWINIT
  OGLM_CHECK_ERR(glBeginQuery, )
  OGLM_AVAIL_CHECK(__glewBeginQuery, glBeginQuery)
  glBeginQuery(target, id);
  OGLM_CHECK_ERR(glBeginQuery, )

void
glBeginQueryANGLE(target, id)
  GLenum target;
  GLuint id;
CODE:
  OGLM_GLEWINIT
  OGLM_CHECK_ERR(glBeginQueryANGLE, )
  OGLM_AVAIL_CHECK(__glewBeginQueryANGLE, glBeginQueryANGLE)
  glBeginQueryANGLE(target, id);
  OGLM_CHECK_ERR(glBeginQueryANGLE, )

void
glBeginQueryEXT(target, id)
  GLenum target;
  GLuint id;
CODE:
  OGLM_GLEWINIT
  OGLM_CHECK_ERR(glBeginQueryEXT, )
  OGLM_AVAIL_CHECK(__glewBeginQueryEXT, glBeginQueryEXT)
  glBeginQueryEXT(target, id);
  OGLM_CHECK_ERR(glBeginQueryEXT, )

void
glBeginQueryIndexed(target, index, id)
  GLenum target;
  GLuint index;
  GLuint id;
CODE:
  OGLM_GLEWINIT
  OGLM_CHECK_ERR(glBeginQueryIndexed, )
  OGLM_AVAIL_CHECK(__glewBeginQueryIndexed, glBeginQueryIndexed)
  glBeginQueryIndexed(target, index, id);
  OGLM_CHECK_ERR(glBeginQueryIndexed, )

void
glBeginSceneEXT()
CODE:
  OGLM_GLEWINIT
  OGLM_CHECK_ERR(glBeginSceneEXT, )
  OGLM_AVAIL_CHECK(__glewBeginSceneEXT, glBeginSceneEXT)
  glBeginSceneEXT();
  OGLM_CHECK_ERR(glBeginSceneEXT, )

void
glBeginTransformFeedback(primitiveMode)
  GLenum primitiveMode;
ALIAS:
  glBeginTransformFeedbackEXT = 1
  glBeginTransformFeedbackNV = 2
CODE:
  OGLM_GLEWINIT
  OGLM_CHECK_ERR(glBeginTransformFeedback, )
  OGLM_AVAIL_CHECK(__glewBeginTransformFeedback, glBeginTransformFeedback)
  glBeginTransformFeedback(primitiveMode);
  OGLM_CHECK_ERR(glBeginTransformFeedback, )

void
glBeginVertexShaderEXT()
CODE:
  OGLM_GLEWINIT
  OGLM_CHECK_ERR(glBeginVertexShaderEXT, )
  OGLM_AVAIL_CHECK(__glewBeginVertexShaderEXT, glBeginVertexShaderEXT)
  glBeginVertexShaderEXT();
  OGLM_CHECK_ERR(glBeginVertexShaderEXT, )

void
glBeginVideoCaptureNV(video_capture_slot)
  GLuint video_capture_slot;
CODE:
  OGLM_GLEWINIT
  OGLM_CHECK_ERR(glBeginVideoCaptureNV, )
  OGLM_AVAIL_CHECK(__glewBeginVideoCaptureNV, glBeginVideoCaptureNV)
  glBeginVideoCaptureNV(video_capture_slot);
  OGLM_CHECK_ERR(glBeginVideoCaptureNV, )

void
glBindArraySetEXT_c(arrayset)
  const void *arrayset;
CODE:
  OGLM_GLEWINIT
  OGLM_CHECK_ERR(glBindArraySetEXT, )
  OGLM_AVAIL_CHECK(__glewBindArraySetEXT, glBindArraySetEXT)
  glBindArraySetEXT(arrayset);
  OGLM_CHECK_ERR(glBindArraySetEXT, )

void
glBindAttribLocation(program, index, name)
  GLuint program;
  GLuint index;
  const GLchar* name;
CODE:
  OGLM_GLEWINIT
  OGLM_CHECK_ERR(glBindAttribLocation, )
  OGLM_AVAIL_CHECK(__glewBindAttribLocation, glBindAttribLocation)
  glBindAttribLocation(program, index, name);
  OGLM_CHECK_ERR(glBindAttribLocation, )

void
glBindAttribLocationARB(programObj, index, name)
  GLhandleARB programObj;
  GLuint index;
  const GLcharARB* name;
CODE:
  OGLM_GLEWINIT
  OGLM_CHECK_ERR(glBindAttribLocationARB, )
  OGLM_AVAIL_CHECK(__glewBindAttribLocationARB, glBindAttribLocationARB)
  glBindAttribLocationARB(programObj, index, name);
  OGLM_CHECK_ERR(glBindAttribLocationARB, )

void
glBindBuffer(target, buffer)
  GLenum target;
  GLuint buffer;
ALIAS:
  glBindBufferARB = 1
CODE:
  OGLM_GLEWINIT
  OGLM_CHECK_ERR(glBindBuffer, )
  OGLM_AVAIL_CHECK(__glewBindBuffer, glBindBuffer)
  glBindBuffer(target, buffer);
  OGLM_CHECK_ERR(glBindBuffer, )

void
glBindBufferBase(target, index, buffer)
  GLenum target;
  GLuint index;
  GLuint buffer;
ALIAS:
  glBindBufferBaseEXT = 1
  glBindBufferBaseNV = 2
CODE:
  OGLM_GLEWINIT
  OGLM_CHECK_ERR(glBindBufferBase, )
  OGLM_AVAIL_CHECK(__glewBindBufferBase, glBindBufferBase)
  glBindBufferBase(target, index, buffer);
  OGLM_CHECK_ERR(glBindBufferBase, )

void
glBindBufferOffsetEXT(target, index, buffer, offset)
  GLenum target;
  GLuint index;
  GLuint buffer;
  GLintptr offset;
ALIAS:
  glBindBufferOffsetNV = 1
CODE:
  OGLM_GLEWINIT
  OGLM_CHECK_ERR(glBindBufferOffsetEXT, )
  OGLM_AVAIL_CHECK(__glewBindBufferOffsetEXT, glBindBufferOffsetEXT)
  glBindBufferOffsetEXT(target, index, buffer, offset);
  OGLM_CHECK_ERR(glBindBufferOffsetEXT, )

void
glBindBufferRange(target, index, buffer, offset, size)
  GLenum target;
  GLuint index;
  GLuint buffer;
  GLintptr offset;
  GLsizeiptr size;
ALIAS:
  glBindBufferRangeEXT = 1
  glBindBufferRangeNV = 2
CODE:
  OGLM_GLEWINIT
  OGLM_CHECK_ERR(glBindBufferRange, )
  OGLM_AVAIL_CHECK(__glewBindBufferRange, glBindBufferRange)
  glBindBufferRange(target, index, buffer, offset, size);
  OGLM_CHECK_ERR(glBindBufferRange, )

void
glBindBuffersBase_c(target, first, count, buffers)
  GLenum target;
  GLuint first;
  GLsizei count;
  const GLuint* buffers;
CODE:
  OGLM_GLEWINIT
  OGLM_CHECK_ERR(glBindBuffersBase, )
  OGLM_AVAIL_CHECK(__glewBindBuffersBase, glBindBuffersBase)
  glBindBuffersBase(target, first, count, buffers);
  OGLM_CHECK_ERR(glBindBuffersBase, )

void
glBindBuffersBase_p(target, first, ...)
  GLenum target;
  GLuint first;
CODE:
  OGLM_GLEWINIT
  OGLM_CHECK_ERR(glBindBuffersBase, )
  OGLM_AVAIL_CHECK(__glewBindBuffersBase, glBindBuffersBase)
  GLsizei count = items-2;
  GLuint* buffers = OGLM_GET_VARARGS(buffers,2,GLuint,UV,count);
  glBindBuffersBase((GLenum )target, (GLuint )first, (GLsizei )count, (const GLuint* )buffers);
  OGLM_CHECK_ERR(glBindBuffersBase, free(buffers);)
  free(buffers);

void
glBindBuffersRange_c(target, first, count, buffers, offsets, sizes)
  GLenum target;
  GLuint first;
  GLsizei count;
  const GLuint* buffers;
  const GLintptr *offsets;
  const GLsizeiptr *sizes;
CODE:
  OGLM_GLEWINIT
  OGLM_CHECK_ERR(glBindBuffersRange, )
  OGLM_AVAIL_CHECK(__glewBindBuffersRange, glBindBuffersRange)
  glBindBuffersRange(target, first, count, buffers, offsets, sizes);
  OGLM_CHECK_ERR(glBindBuffersRange, )

void
glBindFragDataLocation(program, color, name)
  GLuint program;
  GLuint color;
  const GLchar* name;
ALIAS:
  glBindFragDataLocationEXT = 1
CODE:
  OGLM_GLEWINIT
  OGLM_CHECK_ERR(glBindFragDataLocation, )
  OGLM_AVAIL_CHECK(__glewBindFragDataLocation, glBindFragDataLocation)
  glBindFragDataLocation(program, color, name);
  OGLM_CHECK_ERR(glBindFragDataLocation, )

void
glBindFragDataLocationIndexed(program, colorNumber, index, name)
  GLuint program;
  GLuint colorNumber;
  GLuint index;
  const GLchar * name;
ALIAS:
  glBindFragDataLocationIndexedEXT = 1
CODE:
  OGLM_GLEWINIT
  OGLM_CHECK_ERR(glBindFragDataLocationIndexed, )
  OGLM_AVAIL_CHECK(__glewBindFragDataLocationIndexed, glBindFragDataLocationIndexed)
  glBindFragDataLocationIndexed(program, colorNumber, index, name);
  OGLM_CHECK_ERR(glBindFragDataLocationIndexed, )

void
glBindFragmentShaderATI(id)
  GLuint id;
CODE:
  OGLM_GLEWINIT
  OGLM_CHECK_ERR(glBindFragmentShaderATI, )
  OGLM_AVAIL_CHECK(__glewBindFragmentShaderATI, glBindFragmentShaderATI)
  glBindFragmentShaderATI(id);
  OGLM_CHECK_ERR(glBindFragmentShaderATI, )

void
glBindFramebuffer(target, framebuffer)
  GLenum target;
  GLuint framebuffer;
CODE:
  OGLM_GLEWINIT
  OGLM_CHECK_ERR(glBindFramebuffer, )
  OGLM_AVAIL_CHECK(__glewBindFramebuffer, glBindFramebuffer)
  glBindFramebuffer(target, framebuffer);
  OGLM_CHECK_ERR(glBindFramebuffer, )

void
glBindFramebufferEXT(target, framebuffer)
  GLenum target;
  GLuint framebuffer;
CODE:
  OGLM_GLEWINIT
  OGLM_CHECK_ERR(glBindFramebufferEXT, )
  OGLM_AVAIL_CHECK(__glewBindFramebufferEXT, glBindFramebufferEXT)
  glBindFramebufferEXT(target, framebuffer);
  OGLM_CHECK_ERR(glBindFramebufferEXT, )

void
glBindFramebufferOES(target, framebuffer)
  GLenum target;
  GLuint framebuffer;
CODE:
  OGLM_GLEWINIT
  OGLM_CHECK_ERR(glBindFramebufferOES, )
  OGLM_AVAIL_CHECK(__glewBindFramebufferOES, glBindFramebufferOES)
  glBindFramebufferOES(target, framebuffer);
  OGLM_CHECK_ERR(glBindFramebufferOES, )

void
glBindImageTexture(unit, texture, level, layered, layer, access, format)
  GLuint unit;
  GLuint texture;
  GLint level;
  GLboolean layered;
  GLint layer;
  GLenum access;
  GLenum format;
CODE:
  OGLM_GLEWINIT
  OGLM_CHECK_ERR(glBindImageTexture, )
  OGLM_AVAIL_CHECK(__glewBindImageTexture, glBindImageTexture)
  glBindImageTexture(unit, texture, level, layered, layer, access, format);
  OGLM_CHECK_ERR(glBindImageTexture, )

void
glBindImageTextureEXT(index, texture, level, layered, layer, access, format)
  GLuint index;
  GLuint texture;
  GLint level;
  GLboolean layered;
  GLint layer;
  GLenum access;
  GLint format;
CODE:
  OGLM_GLEWINIT
  OGLM_CHECK_ERR(glBindImageTextureEXT, )
  OGLM_AVAIL_CHECK(__glewBindImageTextureEXT, glBindImageTextureEXT)
  glBindImageTextureEXT(index, texture, level, layered, layer, access, format);
  OGLM_CHECK_ERR(glBindImageTextureEXT, )

void
glBindImageTextures_c(first, count, textures)
  GLuint first;
  GLsizei count;
  const GLuint* textures;
CODE:
  OGLM_GLEWINIT
  OGLM_CHECK_ERR(glBindImageTextures, )
  OGLM_AVAIL_CHECK(__glewBindImageTextures, glBindImageTextures)
  glBindImageTextures(first, count, textures);
  OGLM_CHECK_ERR(glBindImageTextures, )

void
glBindImageTextures_p(first, ...)
  GLuint first;
CODE:
  OGLM_GLEWINIT
  OGLM_CHECK_ERR(glBindImageTextures, )
  OGLM_AVAIL_CHECK(__glewBindImageTextures, glBindImageTextures)
  GLsizei count = items-1;
  GLuint* textures = OGLM_GET_VARARGS(textures,1,GLuint,UV,count);
  glBindImageTextures((GLuint )first, (GLsizei )count, (const GLuint* )textures);
  OGLM_CHECK_ERR(glBindImageTextures, free(textures);)
  free(textures);

GLuint
glBindLightParameterEXT(light, value)
  GLenum light;
  GLenum value;
CODE:
  OGLM_GLEWINIT
  OGLM_CHECK_ERR(glBindLightParameterEXT, )
  OGLM_AVAIL_CHECK(__glewBindLightParameterEXT, glBindLightParameterEXT)
  RETVAL = glBindLightParameterEXT(light, value);
  OGLM_CHECK_ERR(glBindLightParameterEXT, )
OUTPUT:
  RETVAL

GLuint
glBindMaterialParameterEXT(face, value)
  GLenum face;
  GLenum value;
CODE:
  OGLM_GLEWINIT
  OGLM_CHECK_ERR(glBindMaterialParameterEXT, )
  OGLM_AVAIL_CHECK(__glewBindMaterialParameterEXT, glBindMaterialParameterEXT)
  RETVAL = glBindMaterialParameterEXT(face, value);
  OGLM_CHECK_ERR(glBindMaterialParameterEXT, )
OUTPUT:
  RETVAL

void
glBindMultiTextureEXT(texunit, target, texture)
  GLenum texunit;
  GLenum target;
  GLuint texture;
CODE:
  OGLM_GLEWINIT
  OGLM_CHECK_ERR(glBindMultiTextureEXT, )
  OGLM_AVAIL_CHECK(__glewBindMultiTextureEXT, glBindMultiTextureEXT)
  glBindMultiTextureEXT(texunit, target, texture);
  OGLM_CHECK_ERR(glBindMultiTextureEXT, )

GLuint
glBindParameterEXT(value)
  GLenum value;
CODE:
  OGLM_GLEWINIT
  OGLM_CHECK_ERR(glBindParameterEXT, )
  OGLM_AVAIL_CHECK(__glewBindParameterEXT, glBindParameterEXT)
  RETVAL = glBindParameterEXT(value);
  OGLM_CHECK_ERR(glBindParameterEXT, )
OUTPUT:
  RETVAL

void
glBindProgramARB(target, program)
  GLenum target;
  GLuint program;
ALIAS:
  glBindProgramNV = 1
CODE:
  OGLM_GLEWINIT
  OGLM_CHECK_ERR(glBindProgramARB, )
  OGLM_AVAIL_CHECK(__glewBindProgramARB, glBindProgramARB)
  glBindProgramARB(target, program);
  OGLM_CHECK_ERR(glBindProgramARB, )

void
glBindProgramPipeline(pipeline)
  GLuint pipeline;
CODE:
  OGLM_GLEWINIT
  OGLM_CHECK_ERR(glBindProgramPipeline, )
  OGLM_AVAIL_CHECK(__glewBindProgramPipeline, glBindProgramPipeline)
  glBindProgramPipeline(pipeline);
  OGLM_CHECK_ERR(glBindProgramPipeline, )

void
glBindRenderbuffer(target, renderbuffer)
  GLenum target;
  GLuint renderbuffer;
CODE:
  OGLM_GLEWINIT
  OGLM_CHECK_ERR(glBindRenderbuffer, )
  OGLM_AVAIL_CHECK(__glewBindRenderbuffer, glBindRenderbuffer)
  glBindRenderbuffer(target, renderbuffer);
  OGLM_CHECK_ERR(glBindRenderbuffer, )

void
glBindRenderbufferEXT(target, renderbuffer)
  GLenum target;
  GLuint renderbuffer;
CODE:
  OGLM_GLEWINIT
  OGLM_CHECK_ERR(glBindRenderbufferEXT, )
  OGLM_AVAIL_CHECK(__glewBindRenderbufferEXT, glBindRenderbufferEXT)
  glBindRenderbufferEXT(target, renderbuffer);
  OGLM_CHECK_ERR(glBindRenderbufferEXT, )

void
glBindRenderbufferOES(target, renderbuffer)
  GLenum target;
  GLuint renderbuffer;
CODE:
  OGLM_GLEWINIT
  OGLM_CHECK_ERR(glBindRenderbufferOES, )
  OGLM_AVAIL_CHECK(__glewBindRenderbufferOES, glBindRenderbufferOES)
  glBindRenderbufferOES(target, renderbuffer);
  OGLM_CHECK_ERR(glBindRenderbufferOES, )

void
glBindSampler(unit, sampler)
  GLuint unit;
  GLuint sampler;
CODE:
  OGLM_GLEWINIT
  OGLM_CHECK_ERR(glBindSampler, )
  OGLM_AVAIL_CHECK(__glewBindSampler, glBindSampler)
  glBindSampler(unit, sampler);
  OGLM_CHECK_ERR(glBindSampler, )

void
glBindSamplers_c(first, count, samplers)
  GLuint first;
  GLsizei count;
  const GLuint* samplers;
CODE:
  OGLM_GLEWINIT
  OGLM_CHECK_ERR(glBindSamplers, )
  OGLM_AVAIL_CHECK(__glewBindSamplers, glBindSamplers)
  glBindSamplers(first, count, samplers);
  OGLM_CHECK_ERR(glBindSamplers, )

void
glBindSamplers_p(first, ...)
  GLuint first;
CODE:
  OGLM_GLEWINIT
  OGLM_CHECK_ERR(glBindSamplers, )
  OGLM_AVAIL_CHECK(__glewBindSamplers, glBindSamplers)
  GLsizei count = items-1;
  GLuint* samplers = OGLM_GET_VARARGS(samplers,1,GLuint,UV,count);
  glBindSamplers((GLuint )first, (GLsizei )count, (const GLuint* )samplers);
  OGLM_CHECK_ERR(glBindSamplers, free(samplers);)
  free(samplers);

void
glBindShadingRateImageNV(texture)
  GLuint texture;
CODE:
  OGLM_GLEWINIT
  OGLM_CHECK_ERR(glBindShadingRateImageNV, )
  OGLM_AVAIL_CHECK(__glewBindShadingRateImageNV, glBindShadingRateImageNV)
  glBindShadingRateImageNV(texture);
  OGLM_CHECK_ERR(glBindShadingRateImageNV, )

GLuint
glBindTexGenParameterEXT(unit, coord, value)
  GLenum unit;
  GLenum coord;
  GLenum value;
CODE:
  OGLM_GLEWINIT
  OGLM_CHECK_ERR(glBindTexGenParameterEXT, )
  OGLM_AVAIL_CHECK(__glewBindTexGenParameterEXT, glBindTexGenParameterEXT)
  RETVAL = glBindTexGenParameterEXT(unit, coord, value);
  OGLM_CHECK_ERR(glBindTexGenParameterEXT, )
OUTPUT:
  RETVAL

void
glBindTexture(target, texture)
  GLenum target;
  GLuint texture;
ALIAS:
  glBindTextureEXT = 1
CODE:
  OGLM_GLEWINIT
  OGLM_CHECK_ERR(glBindTexture, )
  glBindTexture(target, texture);
  OGLM_CHECK_ERR(glBindTexture, )

void
glBindTextureUnit(unit, texture)
  GLuint unit;
  GLuint texture;
CODE:
  OGLM_GLEWINIT
  OGLM_CHECK_ERR(glBindTextureUnit, )
  OGLM_AVAIL_CHECK(__glewBindTextureUnit, glBindTextureUnit)
  glBindTextureUnit(unit, texture);
  OGLM_CHECK_ERR(glBindTextureUnit, )

GLuint
glBindTextureUnitParameterEXT(unit, value)
  GLenum unit;
  GLenum value;
CODE:
  OGLM_GLEWINIT
  OGLM_CHECK_ERR(glBindTextureUnitParameterEXT, )
  OGLM_AVAIL_CHECK(__glewBindTextureUnitParameterEXT, glBindTextureUnitParameterEXT)
  RETVAL = glBindTextureUnitParameterEXT(unit, value);
  OGLM_CHECK_ERR(glBindTextureUnitParameterEXT, )
OUTPUT:
  RETVAL

void
glBindTextures_c(first, count, textures)
  GLuint first;
  GLsizei count;
  const GLuint* textures;
CODE:
  OGLM_GLEWINIT
  OGLM_CHECK_ERR(glBindTextures, )
  OGLM_AVAIL_CHECK(__glewBindTextures, glBindTextures)
  glBindTextures(first, count, textures);
  OGLM_CHECK_ERR(glBindTextures, )

void
glBindTextures_p(first, ...)
  GLuint first;
CODE:
  OGLM_GLEWINIT
  OGLM_CHECK_ERR(glBindTextures, )
  OGLM_AVAIL_CHECK(__glewBindTextures, glBindTextures)
  GLsizei count = items-1;
  GLuint* textures = OGLM_GET_VARARGS(textures,1,GLuint,UV,count);
  glBindTextures((GLuint )first, (GLsizei )count, (const GLuint* )textures);
  OGLM_CHECK_ERR(glBindTextures, free(textures);)
  free(textures);

void
glBindTransformFeedback(target, id)
  GLenum target;
  GLuint id;
CODE:
  OGLM_GLEWINIT
  OGLM_CHECK_ERR(glBindTransformFeedback, )
  OGLM_AVAIL_CHECK(__glewBindTransformFeedback, glBindTransformFeedback)
  glBindTransformFeedback(target, id);
  OGLM_CHECK_ERR(glBindTransformFeedback, )

void
glBindTransformFeedbackNV(target, id)
  GLenum target;
  GLuint id;
CODE:
  OGLM_GLEWINIT
  OGLM_CHECK_ERR(glBindTransformFeedbackNV, )
  OGLM_AVAIL_CHECK(__glewBindTransformFeedbackNV, glBindTransformFeedbackNV)
  glBindTransformFeedbackNV(target, id);
  OGLM_CHECK_ERR(glBindTransformFeedbackNV, )

void
glBindVertexArray(array)
  GLuint array;
CODE:
  OGLM_GLEWINIT
  OGLM_CHECK_ERR(glBindVertexArray, )
  OGLM_AVAIL_CHECK(__glewBindVertexArray, glBindVertexArray)
  glBindVertexArray(array);
  OGLM_CHECK_ERR(glBindVertexArray, )

void
glBindVertexArrayAPPLE(array)
  GLuint array;
CODE:
  OGLM_GLEWINIT
  OGLM_CHECK_ERR(glBindVertexArrayAPPLE, )
  OGLM_AVAIL_CHECK(__glewBindVertexArrayAPPLE, glBindVertexArrayAPPLE)
  glBindVertexArrayAPPLE(array);
  OGLM_CHECK_ERR(glBindVertexArrayAPPLE, )

void
glBindVertexArrayOES(array)
  GLuint array;
CODE:
  OGLM_GLEWINIT
  OGLM_CHECK_ERR(glBindVertexArrayOES, )
  OGLM_AVAIL_CHECK(__glewBindVertexArrayOES, glBindVertexArrayOES)
  glBindVertexArrayOES(array);
  OGLM_CHECK_ERR(glBindVertexArrayOES, )

void
glBindVertexArraySGIX(array)
  GLuint array;
CODE:
  OGLM_GLEWINIT
  OGLM_CHECK_ERR(glBindVertexArraySGIX, )
  OGLM_AVAIL_CHECK(__glewBindVertexArraySGIX, glBindVertexArraySGIX)
  glBindVertexArraySGIX(array);
  OGLM_CHECK_ERR(glBindVertexArraySGIX, )

void
glBindVertexBuffer(bindingindex, buffer, offset, stride)
  GLuint bindingindex;
  GLuint buffer;
  GLintptr offset;
  GLsizei stride;
CODE:
  OGLM_GLEWINIT
  OGLM_CHECK_ERR(glBindVertexBuffer, )
  OGLM_AVAIL_CHECK(__glewBindVertexBuffer, glBindVertexBuffer)
  glBindVertexBuffer(bindingindex, buffer, offset, stride);
  OGLM_CHECK_ERR(glBindVertexBuffer, )

void
glBindVertexBuffers_c(first, count, buffers, offsets, strides)
  GLuint first;
  GLsizei count;
  const GLuint* buffers;
  const GLintptr *offsets;
  const GLsizei *strides;
CODE:
  OGLM_GLEWINIT
  OGLM_CHECK_ERR(glBindVertexBuffers, )
  OGLM_AVAIL_CHECK(__glewBindVertexBuffers, glBindVertexBuffers)
  glBindVertexBuffers(first, count, buffers, offsets, strides);
  OGLM_CHECK_ERR(glBindVertexBuffers, )

void
glBindVertexShaderEXT(id)
  GLuint id;
CODE:
  OGLM_GLEWINIT
  OGLM_CHECK_ERR(glBindVertexShaderEXT, )
  OGLM_AVAIL_CHECK(__glewBindVertexShaderEXT, glBindVertexShaderEXT)
  glBindVertexShaderEXT(id);
  OGLM_CHECK_ERR(glBindVertexShaderEXT, )

void
glBindVideoCaptureStreamBufferNV(video_capture_slot, stream, frame_region, offset)
  GLuint video_capture_slot;
  GLuint stream;
  GLenum frame_region;
  GLintptrARB offset;
CODE:
  OGLM_GLEWINIT
  OGLM_CHECK_ERR(glBindVideoCaptureStreamBufferNV, )
  OGLM_AVAIL_CHECK(__glewBindVideoCaptureStreamBufferNV, glBindVideoCaptureStreamBufferNV)
  glBindVideoCaptureStreamBufferNV(video_capture_slot, stream, frame_region, offset);
  OGLM_CHECK_ERR(glBindVideoCaptureStreamBufferNV, )

void
glBindVideoCaptureStreamTextureNV(video_capture_slot, stream, frame_region, target, texture)
  GLuint video_capture_slot;
  GLuint stream;
  GLenum frame_region;
  GLenum target;
  GLuint texture;
CODE:
  OGLM_GLEWINIT
  OGLM_CHECK_ERR(glBindVideoCaptureStreamTextureNV, )
  OGLM_AVAIL_CHECK(__glewBindVideoCaptureStreamTextureNV, glBindVideoCaptureStreamTextureNV)
  glBindVideoCaptureStreamTextureNV(video_capture_slot, stream, frame_region, target, texture);
  OGLM_CHECK_ERR(glBindVideoCaptureStreamTextureNV, )

void
glBinormalPointerEXT_c(type, stride, pointer)
  GLenum type;
  GLsizei stride;
  void *pointer;
CODE:
  OGLM_GLEWINIT
  OGLM_CHECK_ERR(glBinormalPointerEXT, )
  OGLM_AVAIL_CHECK(__glewBinormalPointerEXT, glBinormalPointerEXT)
  glBinormalPointerEXT(type, stride, pointer);
  OGLM_CHECK_ERR(glBinormalPointerEXT, )

void
glBitmap(width, height, xorig, yorig, xmove, ymove, bitmap)
  GLsizei width;
  GLsizei height;
  GLfloat xorig;
  GLfloat yorig;
  GLfloat xmove;
  GLfloat ymove;
  const GLubyte *bitmap;
CODE:
  OGLM_GLEWINIT
  OGLM_CHECK_ERR(glBitmap, )
  glBitmap(width, height, xorig, yorig, xmove, ymove, bitmap);
  OGLM_CHECK_ERR(glBitmap, )

void
glBlendBarrierKHR()
ALIAS:
  glBlendBarrier = 1
  glBlendBarrierNV = 2
CODE:
  OGLM_GLEWINIT
  OGLM_CHECK_ERR(glBlendBarrierKHR, )
  OGLM_AVAIL_CHECK(__glewBlendBarrierKHR, glBlendBarrierKHR)
  glBlendBarrierKHR();
  OGLM_CHECK_ERR(glBlendBarrierKHR, )

void
glBlendColor(red, green, blue, alpha)
  GLclampf red;
  GLclampf green;
  GLclampf blue;
  GLclampf alpha;
ALIAS:
  glBlendColorEXT = 1
CODE:
  OGLM_GLEWINIT
  OGLM_CHECK_ERR(glBlendColor, )
  OGLM_AVAIL_CHECK(__glewBlendColor, glBlendColor)
  glBlendColor(red, green, blue, alpha);
  OGLM_CHECK_ERR(glBlendColor, )

void
glBlendEquation(mode)
  GLenum mode;
ALIAS:
  glBlendEquationEXT = 1
CODE:
  OGLM_GLEWINIT
  OGLM_CHECK_ERR(glBlendEquation, )
  OGLM_AVAIL_CHECK(__glewBlendEquation, glBlendEquation)
  glBlendEquation(mode);
  OGLM_CHECK_ERR(glBlendEquation, )

void
glBlendEquationOES(mode)
  GLenum mode;
CODE:
  OGLM_GLEWINIT
  OGLM_CHECK_ERR(glBlendEquationOES, )
  OGLM_AVAIL_CHECK(__glewBlendEquationOES, glBlendEquationOES)
  glBlendEquationOES(mode);
  OGLM_CHECK_ERR(glBlendEquationOES, )

void
glBlendEquationSeparate(modeRGB, modeAlpha)
  GLenum modeRGB;
  GLenum modeAlpha;
ALIAS:
  glBlendEquationSeparateEXT = 1
CODE:
  OGLM_GLEWINIT
  OGLM_CHECK_ERR(glBlendEquationSeparate, )
  OGLM_AVAIL_CHECK(__glewBlendEquationSeparate, glBlendEquationSeparate)
  glBlendEquationSeparate(modeRGB, modeAlpha);
  OGLM_CHECK_ERR(glBlendEquationSeparate, )

void
glBlendEquationSeparateOES(modeRGB, modeAlpha)
  GLenum modeRGB;
  GLenum modeAlpha;
CODE:
  OGLM_GLEWINIT
  OGLM_CHECK_ERR(glBlendEquationSeparateOES, )
  OGLM_AVAIL_CHECK(__glewBlendEquationSeparateOES, glBlendEquationSeparateOES)
  glBlendEquationSeparateOES(modeRGB, modeAlpha);
  OGLM_CHECK_ERR(glBlendEquationSeparateOES, )

void
glBlendEquationSeparatei(buf, modeRGB, modeAlpha)
  GLuint buf;
  GLenum modeRGB;
  GLenum modeAlpha;
ALIAS:
  glBlendEquationSeparateIndexedAMD = 1
  glBlendEquationSeparateiARB = 2
  glBlendEquationSeparateiEXT = 3
CODE:
  OGLM_GLEWINIT
  OGLM_CHECK_ERR(glBlendEquationSeparatei, )
  OGLM_AVAIL_CHECK(__glewBlendEquationSeparatei, glBlendEquationSeparatei)
  glBlendEquationSeparatei(buf, modeRGB, modeAlpha);
  OGLM_CHECK_ERR(glBlendEquationSeparatei, )

void
glBlendEquationSeparateiOES(buf, modeRGB, modeAlpha)
  GLuint buf;
  GLenum modeRGB;
  GLenum modeAlpha;
CODE:
  OGLM_GLEWINIT
  OGLM_CHECK_ERR(glBlendEquationSeparateiOES, )
  OGLM_AVAIL_CHECK(__glewBlendEquationSeparateiOES, glBlendEquationSeparateiOES)
  glBlendEquationSeparateiOES(buf, modeRGB, modeAlpha);
  OGLM_CHECK_ERR(glBlendEquationSeparateiOES, )

void
glBlendEquationi(buf, mode)
  GLuint buf;
  GLenum mode;
ALIAS:
  glBlendEquationIndexedAMD = 1
  glBlendEquationiARB = 2
  glBlendEquationiEXT = 3
CODE:
  OGLM_GLEWINIT
  OGLM_CHECK_ERR(glBlendEquationi, )
  OGLM_AVAIL_CHECK(__glewBlendEquationi, glBlendEquationi)
  glBlendEquationi(buf, mode);
  OGLM_CHECK_ERR(glBlendEquationi, )

void
glBlendEquationiOES(buf, mode)
  GLuint buf;
  GLenum mode;
CODE:
  OGLM_GLEWINIT
  OGLM_CHECK_ERR(glBlendEquationiOES, )
  OGLM_AVAIL_CHECK(__glewBlendEquationiOES, glBlendEquationiOES)
  glBlendEquationiOES(buf, mode);
  OGLM_CHECK_ERR(glBlendEquationiOES, )

void
glBlendFunc(sfactor, dfactor)
  GLenum sfactor;
  GLenum dfactor;
CODE:
  OGLM_GLEWINIT
  OGLM_CHECK_ERR(glBlendFunc, )
  glBlendFunc(sfactor, dfactor);
  OGLM_CHECK_ERR(glBlendFunc, )

void
glBlendFuncSeparate(sfactorRGB, dfactorRGB, sfactorAlpha, dfactorAlpha)
  GLenum sfactorRGB;
  GLenum dfactorRGB;
  GLenum sfactorAlpha;
  GLenum dfactorAlpha;
ALIAS:
  glBlendFuncSeparateEXT = 1
  glBlendFuncSeparateINGR = 2
CODE:
  OGLM_GLEWINIT
  OGLM_CHECK_ERR(glBlendFuncSeparate, )
  OGLM_AVAIL_CHECK(__glewBlendFuncSeparate, glBlendFuncSeparate)
  glBlendFuncSeparate(sfactorRGB, dfactorRGB, sfactorAlpha, dfactorAlpha);
  OGLM_CHECK_ERR(glBlendFuncSeparate, )

void
glBlendFuncSeparateOES(sfactorRGB, dfactorRGB, sfactorAlpha, dfactorAlpha)
  GLenum sfactorRGB;
  GLenum dfactorRGB;
  GLenum sfactorAlpha;
  GLenum dfactorAlpha;
CODE:
  OGLM_GLEWINIT
  OGLM_CHECK_ERR(glBlendFuncSeparateOES, )
  OGLM_AVAIL_CHECK(__glewBlendFuncSeparateOES, glBlendFuncSeparateOES)
  glBlendFuncSeparateOES(sfactorRGB, dfactorRGB, sfactorAlpha, dfactorAlpha);
  OGLM_CHECK_ERR(glBlendFuncSeparateOES, )

void
glBlendFuncSeparatei(buf, srcRGB, dstRGB, srcAlpha, dstAlpha)
  GLuint buf;
  GLenum srcRGB;
  GLenum dstRGB;
  GLenum srcAlpha;
  GLenum dstAlpha;
ALIAS:
  glBlendFuncSeparateIndexedAMD = 1
  glBlendFuncSeparateiARB = 2
  glBlendFuncSeparateiEXT = 3
CODE:
  OGLM_GLEWINIT
  OGLM_CHECK_ERR(glBlendFuncSeparatei, )
  OGLM_AVAIL_CHECK(__glewBlendFuncSeparatei, glBlendFuncSeparatei)
  glBlendFuncSeparatei(buf, srcRGB, dstRGB, srcAlpha, dstAlpha);
  OGLM_CHECK_ERR(glBlendFuncSeparatei, )

void
glBlendFuncSeparateiOES(buf, srcRGB, dstRGB, srcAlpha, dstAlpha)
  GLuint buf;
  GLenum srcRGB;
  GLenum dstRGB;
  GLenum srcAlpha;
  GLenum dstAlpha;
CODE:
  OGLM_GLEWINIT
  OGLM_CHECK_ERR(glBlendFuncSeparateiOES, )
  OGLM_AVAIL_CHECK(__glewBlendFuncSeparateiOES, glBlendFuncSeparateiOES)
  glBlendFuncSeparateiOES(buf, srcRGB, dstRGB, srcAlpha, dstAlpha);
  OGLM_CHECK_ERR(glBlendFuncSeparateiOES, )

void
glBlendFunci(buf, src, dst)
  GLuint buf;
  GLenum src;
  GLenum dst;
ALIAS:
  glBlendFuncIndexedAMD = 1
  glBlendFunciARB = 2
  glBlendFunciEXT = 3
CODE:
  OGLM_GLEWINIT
  OGLM_CHECK_ERR(glBlendFunci, )
  OGLM_AVAIL_CHECK(__glewBlendFunci, glBlendFunci)
  glBlendFunci(buf, src, dst);
  OGLM_CHECK_ERR(glBlendFunci, )

void
glBlendFunciOES(buf, src, dst)
  GLuint buf;
  GLenum src;
  GLenum dst;
CODE:
  OGLM_GLEWINIT
  OGLM_CHECK_ERR(glBlendFunciOES, )
  OGLM_AVAIL_CHECK(__glewBlendFunciOES, glBlendFunciOES)
  glBlendFunciOES(buf, src, dst);
  OGLM_CHECK_ERR(glBlendFunciOES, )

void
glBlendParameteriNV(pname, value)
  GLenum pname;
  GLint value;
CODE:
  OGLM_GLEWINIT
  OGLM_CHECK_ERR(glBlendParameteriNV, )
  OGLM_AVAIL_CHECK(__glewBlendParameteriNV, glBlendParameteriNV)
  glBlendParameteriNV(pname, value);
  OGLM_CHECK_ERR(glBlendParameteriNV, )

void
glBlitFramebuffer(srcX0, srcY0, srcX1, srcY1, dstX0, dstY0, dstX1, dstY1, mask, filter)
  GLint srcX0;
  GLint srcY0;
  GLint srcX1;
  GLint srcY1;
  GLint dstX0;
  GLint dstY0;
  GLint dstX1;
  GLint dstY1;
  GLbitfield mask;
  GLenum filter;
ALIAS:
  glBlitFramebufferEXT = 1
  glBlitFramebufferNV = 2
CODE:
  OGLM_GLEWINIT
  OGLM_CHECK_ERR(glBlitFramebuffer, )
  OGLM_AVAIL_CHECK(__glewBlitFramebuffer, glBlitFramebuffer)
  glBlitFramebuffer(srcX0, srcY0, srcX1, srcY1, dstX0, dstY0, dstX1, dstY1, mask, filter);
  OGLM_CHECK_ERR(glBlitFramebuffer, )

void
glBlitFramebufferANGLE(srcX0, srcY0, srcX1, srcY1, dstX0, dstY0, dstX1, dstY1, mask, filter)
  GLint srcX0;
  GLint srcY0;
  GLint srcX1;
  GLint srcY1;
  GLint dstX0;
  GLint dstY0;
  GLint dstX1;
  GLint dstY1;
  GLbitfield mask;
  GLenum filter;
CODE:
  OGLM_GLEWINIT
  OGLM_CHECK_ERR(glBlitFramebufferANGLE, )
  OGLM_AVAIL_CHECK(__glewBlitFramebufferANGLE, glBlitFramebufferANGLE)
  glBlitFramebufferANGLE(srcX0, srcY0, srcX1, srcY1, dstX0, dstY0, dstX1, dstY1, mask, filter);
  OGLM_CHECK_ERR(glBlitFramebufferANGLE, )

void
glBlitFramebufferLayerEXT(srcX0, srcY0, srcX1, srcY1, srcLayer, dstX0, dstY0, dstX1, dstY1, dstLayer, mask, filter)
  GLint srcX0;
  GLint srcY0;
  GLint srcX1;
  GLint srcY1;
  GLint srcLayer;
  GLint dstX0;
  GLint dstY0;
  GLint dstX1;
  GLint dstY1;
  GLint dstLayer;
  GLbitfield mask;
  GLenum filter;
CODE:
  OGLM_GLEWINIT
  OGLM_CHECK_ERR(glBlitFramebufferLayerEXT, )
  OGLM_AVAIL_CHECK(__glewBlitFramebufferLayerEXT, glBlitFramebufferLayerEXT)
  glBlitFramebufferLayerEXT(srcX0, srcY0, srcX1, srcY1, srcLayer, dstX0, dstY0, dstX1, dstY1, dstLayer, mask, filter);
  OGLM_CHECK_ERR(glBlitFramebufferLayerEXT, )

void
glBlitFramebufferLayersEXT(srcX0, srcY0, srcX1, srcY1, dstX0, dstY0, dstX1, dstY1, mask, filter)
  GLint srcX0;
  GLint srcY0;
  GLint srcX1;
  GLint srcY1;
  GLint dstX0;
  GLint dstY0;
  GLint dstX1;
  GLint dstY1;
  GLbitfield mask;
  GLenum filter;
CODE:
  OGLM_GLEWINIT
  OGLM_CHECK_ERR(glBlitFramebufferLayersEXT, )
  OGLM_AVAIL_CHECK(__glewBlitFramebufferLayersEXT, glBlitFramebufferLayersEXT)
  glBlitFramebufferLayersEXT(srcX0, srcY0, srcX1, srcY1, dstX0, dstY0, dstX1, dstY1, mask, filter);
  OGLM_CHECK_ERR(glBlitFramebufferLayersEXT, )

void
glBlitNamedFramebuffer(readFramebuffer, drawFramebuffer, srcX0, srcY0, srcX1, srcY1, dstX0, dstY0, dstX1, dstY1, mask, filter)
  GLuint readFramebuffer;
  GLuint drawFramebuffer;
  GLint srcX0;
  GLint srcY0;
  GLint srcX1;
  GLint srcY1;
  GLint dstX0;
  GLint dstY0;
  GLint dstX1;
  GLint dstY1;
  GLbitfield mask;
  GLenum filter;
CODE:
  OGLM_GLEWINIT
  OGLM_CHECK_ERR(glBlitNamedFramebuffer, )
  OGLM_AVAIL_CHECK(__glewBlitNamedFramebuffer, glBlitNamedFramebuffer)
  glBlitNamedFramebuffer(readFramebuffer, drawFramebuffer, srcX0, srcY0, srcX1, srcY1, dstX0, dstY0, dstX1, dstY1, mask, filter);
  OGLM_CHECK_ERR(glBlitNamedFramebuffer, )

void
glBufferAddressRangeNV(pname, index, address, length)
  GLenum pname;
  GLuint index;
  GLuint64EXT address;
  GLsizeiptr length;
CODE:
  OGLM_GLEWINIT
  OGLM_CHECK_ERR(glBufferAddressRangeNV, )
  OGLM_AVAIL_CHECK(__glewBufferAddressRangeNV, glBufferAddressRangeNV)
  glBufferAddressRangeNV(pname, index, address, length);
  OGLM_CHECK_ERR(glBufferAddressRangeNV, )

void
glBufferAttachMemoryNV(target, memory, offset)
  GLenum target;
  GLuint memory;
  GLuint64 offset;
CODE:
  OGLM_GLEWINIT
  OGLM_CHECK_ERR(glBufferAttachMemoryNV, )
  OGLM_AVAIL_CHECK(__glewBufferAttachMemoryNV, glBufferAttachMemoryNV)
  glBufferAttachMemoryNV(target, memory, offset);
  OGLM_CHECK_ERR(glBufferAttachMemoryNV, )

void
glBufferData_c(target, size, data, usage)
  GLenum target;
  GLsizeiptr size;
  const void* data;
  GLenum usage;
ALIAS:
  glBufferDataARB_c = 1
CODE:
  OGLM_GLEWINIT
  OGLM_CHECK_ERR(glBufferData, )
  OGLM_AVAIL_CHECK(__glewBufferData, glBufferData)
  glBufferData(target, size, data, usage);
  OGLM_CHECK_ERR(glBufferData, )

void
glBufferPageCommitmentARB(target, offset, size, commit)
  GLenum target;
  GLintptr offset;
  GLsizeiptr size;
  GLboolean commit;
CODE:
  OGLM_GLEWINIT
  OGLM_CHECK_ERR(glBufferPageCommitmentARB, )
  OGLM_AVAIL_CHECK(__glewBufferPageCommitmentARB, glBufferPageCommitmentARB)
  glBufferPageCommitmentARB(target, offset, size, commit);
  OGLM_CHECK_ERR(glBufferPageCommitmentARB, )

void
glBufferPageCommitmentMemNV(target, offset, size, memory, memOffset, commit)
  GLenum target;
  GLintptr offset;
  GLsizeiptr size;
  GLuint memory;
  GLuint64 memOffset;
  GLboolean commit;
CODE:
  OGLM_GLEWINIT
  OGLM_CHECK_ERR(glBufferPageCommitmentMemNV, )
  OGLM_AVAIL_CHECK(__glewBufferPageCommitmentMemNV, glBufferPageCommitmentMemNV)
  glBufferPageCommitmentMemNV(target, offset, size, memory, memOffset, commit);
  OGLM_CHECK_ERR(glBufferPageCommitmentMemNV, )

void
glBufferParameteriAPPLE(target, pname, param)
  GLenum target;
  GLenum pname;
  GLint param;
CODE:
  OGLM_GLEWINIT
  OGLM_CHECK_ERR(glBufferParameteriAPPLE, )
  OGLM_AVAIL_CHECK(__glewBufferParameteriAPPLE, glBufferParameteriAPPLE)
  glBufferParameteriAPPLE(target, pname, param);
  OGLM_CHECK_ERR(glBufferParameteriAPPLE, )

GLuint
glBufferRegionEnabled()
CODE:
  OGLM_GLEWINIT
  OGLM_CHECK_ERR(glBufferRegionEnabled, )
  OGLM_AVAIL_CHECK(__glewBufferRegionEnabled, glBufferRegionEnabled)
  RETVAL = glBufferRegionEnabled();
  OGLM_CHECK_ERR(glBufferRegionEnabled, )
OUTPUT:
  RETVAL

void
glBufferStorage_c(target, size, data, flags)
  GLenum target;
  GLsizeiptr size;
  const void *data;
  GLbitfield flags;
ALIAS:
  glBufferStorageEXT_c = 1
CODE:
  OGLM_GLEWINIT
  OGLM_CHECK_ERR(glBufferStorage, )
  OGLM_AVAIL_CHECK(__glewBufferStorage, glBufferStorage)
  glBufferStorage(target, size, data, flags);
  OGLM_CHECK_ERR(glBufferStorage, )

void
glBufferStorageExternalEXT(target, offset, size, clientBuffer, flags)
  GLenum target;
  GLintptr offset;
  GLsizeiptr size;
  GLeglClientBufferEXT clientBuffer;
  GLbitfield flags;
CODE:
  OGLM_GLEWINIT
  OGLM_CHECK_ERR(glBufferStorageExternalEXT, )
  OGLM_AVAIL_CHECK(__glewBufferStorageExternalEXT, glBufferStorageExternalEXT)
  glBufferStorageExternalEXT(target, offset, size, clientBuffer, flags);
  OGLM_CHECK_ERR(glBufferStorageExternalEXT, )

void
glBufferStorageMemEXT(target, size, memory, offset)
  GLenum target;
  GLsizeiptr size;
  GLuint memory;
  GLuint64 offset;
CODE:
  OGLM_GLEWINIT
  OGLM_CHECK_ERR(glBufferStorageMemEXT, )
  OGLM_AVAIL_CHECK(__glewBufferStorageMemEXT, glBufferStorageMemEXT)
  glBufferStorageMemEXT(target, size, memory, offset);
  OGLM_CHECK_ERR(glBufferStorageMemEXT, )

void
glBufferSubData_c(target, offset, size, data)
  GLenum target;
  GLintptr offset;
  GLsizeiptr size;
  const void* data;
ALIAS:
  glBufferSubDataARB_c = 1
CODE:
  OGLM_GLEWINIT
  OGLM_CHECK_ERR(glBufferSubData, )
  OGLM_AVAIL_CHECK(__glewBufferSubData, glBufferSubData)
  glBufferSubData(target, offset, size, data);
  OGLM_CHECK_ERR(glBufferSubData, )

void
glCallCommandListNV(list)
  GLuint list;
CODE:
  OGLM_GLEWINIT
  OGLM_CHECK_ERR(glCallCommandListNV, )
  OGLM_AVAIL_CHECK(__glewCallCommandListNV, glCallCommandListNV)
  glCallCommandListNV(list);
  OGLM_CHECK_ERR(glCallCommandListNV, )

void
glCallList(list)
  GLuint list;
CODE:
  OGLM_GLEWINIT
  OGLM_CHECK_ERR(glCallList, )
  glCallList(list);
  OGLM_CHECK_ERR(glCallList, )

void
glCallLists_c(n, type, lists)
  GLsizei n;
  GLenum type;
  const void *lists;
CODE:
  OGLM_GLEWINIT
  OGLM_CHECK_ERR(glCallLists, )
  glCallLists(n, type, lists);
  OGLM_CHECK_ERR(glCallLists, )

GLenum
glCheckFramebufferStatus(target)
  GLenum target;
ALIAS:
  glCheckFramebufferStatusEXT = 1
CODE:
  OGLM_GLEWINIT
  OGLM_CHECK_ERR(glCheckFramebufferStatus, )
  OGLM_AVAIL_CHECK(__glewCheckFramebufferStatus, glCheckFramebufferStatus)
  RETVAL = glCheckFramebufferStatus(target);
  OGLM_CHECK_ERR(glCheckFramebufferStatus, )
OUTPUT:
  RETVAL

GLenum
glCheckFramebufferStatusOES(target)
  GLenum target;
CODE:
  OGLM_GLEWINIT
  OGLM_CHECK_ERR(glCheckFramebufferStatusOES, )
  OGLM_AVAIL_CHECK(__glewCheckFramebufferStatusOES, glCheckFramebufferStatusOES)
  RETVAL = glCheckFramebufferStatusOES(target);
  OGLM_CHECK_ERR(glCheckFramebufferStatusOES, )
OUTPUT:
  RETVAL

GLenum
glCheckNamedFramebufferStatus(framebuffer, target)
  GLuint framebuffer;
  GLenum target;
CODE:
  OGLM_GLEWINIT
  OGLM_CHECK_ERR(glCheckNamedFramebufferStatus, )
  OGLM_AVAIL_CHECK(__glewCheckNamedFramebufferStatus, glCheckNamedFramebufferStatus)
  RETVAL = glCheckNamedFramebufferStatus(framebuffer, target);
  OGLM_CHECK_ERR(glCheckNamedFramebufferStatus, )
OUTPUT:
  RETVAL

GLenum
glCheckNamedFramebufferStatusEXT(framebuffer, target)
  GLuint framebuffer;
  GLenum target;
CODE:
  OGLM_GLEWINIT
  OGLM_CHECK_ERR(glCheckNamedFramebufferStatusEXT, )
  OGLM_AVAIL_CHECK(__glewCheckNamedFramebufferStatusEXT, glCheckNamedFramebufferStatusEXT)
  RETVAL = glCheckNamedFramebufferStatusEXT(framebuffer, target);
  OGLM_CHECK_ERR(glCheckNamedFramebufferStatusEXT, )
OUTPUT:
  RETVAL

void
glClampColor(target, clamp)
  GLenum target;
  GLenum clamp;
ALIAS:
  glClampColorARB = 1
CODE:
  OGLM_GLEWINIT
  OGLM_CHECK_ERR(glClampColor, )
  OGLM_AVAIL_CHECK(__glewClampColor, glClampColor)
  glClampColor(target, clamp);
  OGLM_CHECK_ERR(glClampColor, )

void
glClear(mask)
  GLbitfield mask;
CODE:
  OGLM_GLEWINIT
  OGLM_CHECK_ERR(glClear, )
  glClear(mask);
  OGLM_CHECK_ERR(glClear, )

void
glClearAccum(red, green, blue, alpha)
  GLfloat red;
  GLfloat green;
  GLfloat blue;
  GLfloat alpha;
CODE:
  OGLM_GLEWINIT
  OGLM_CHECK_ERR(glClearAccum, )
  glClearAccum(red, green, blue, alpha);
  OGLM_CHECK_ERR(glClearAccum, )

void
glClearBufferData_c(target, internalformat, format, type, data)
  GLenum target;
  GLenum internalformat;
  GLenum format;
  GLenum type;
  const void *data;
CODE:
  OGLM_GLEWINIT
  OGLM_CHECK_ERR(glClearBufferData, )
  OGLM_AVAIL_CHECK(__glewClearBufferData, glClearBufferData)
  glClearBufferData(target, internalformat, format, type, data);
  OGLM_CHECK_ERR(glClearBufferData, )

void
glClearBufferSubData_c(target, internalformat, offset, size, format, type, data)
  GLenum target;
  GLenum internalformat;
  GLintptr offset;
  GLsizeiptr size;
  GLenum format;
  GLenum type;
  const void *data;
CODE:
  OGLM_GLEWINIT
  OGLM_CHECK_ERR(glClearBufferSubData, )
  OGLM_AVAIL_CHECK(__glewClearBufferSubData, glClearBufferSubData)
  glClearBufferSubData(target, internalformat, offset, size, format, type, data);
  OGLM_CHECK_ERR(glClearBufferSubData, )

void
glClearBufferfi(buffer, drawbuffer, depth, stencil)
  GLenum buffer;
  GLint drawbuffer;
  GLfloat depth;
  GLint stencil;
CODE:
  OGLM_GLEWINIT
  OGLM_CHECK_ERR(glClearBufferfi, )
  OGLM_AVAIL_CHECK(__glewClearBufferfi, glClearBufferfi)
  glClearBufferfi(buffer, drawbuffer, depth, stencil);
  OGLM_CHECK_ERR(glClearBufferfi, )

void
glClearBufferfv_c(buffer, drawbuffer, value)
  GLenum buffer;
  GLint drawbuffer;
  const GLfloat* value;
CODE:
  OGLM_GLEWINIT
  OGLM_CHECK_ERR(glClearBufferfv, )
  OGLM_AVAIL_CHECK(__glewClearBufferfv, glClearBufferfv)
  glClearBufferfv(buffer, drawbuffer, value);
  OGLM_CHECK_ERR(glClearBufferfv, )

void
glClearBufferfv_p(buffer, drawbuffer, ...)
  GLenum buffer;
  GLint drawbuffer;
CODE:
  OGLM_GLEWINIT
  OGLM_CHECK_ERR(glClearBufferfv, )
  OGLM_AVAIL_CHECK(__glewClearBufferfv, glClearBufferfv)
  OGLM_SIZE_ENUM(Buffer,buffer,1)
  GLfloat* value = OGLM_GET_VARARGS(value,2,GLfloat,NV,buffer_count);
  glClearBufferfv((GLenum )buffer, (GLint )drawbuffer, (const GLfloat* )value);
  OGLM_CHECK_ERR(glClearBufferfv, free(value);)
  free(value);

void
glClearBufferiv_c(buffer, drawbuffer, value)
  GLenum buffer;
  GLint drawbuffer;
  const GLint* value;
CODE:
  OGLM_GLEWINIT
  OGLM_CHECK_ERR(glClearBufferiv, )
  OGLM_AVAIL_CHECK(__glewClearBufferiv, glClearBufferiv)
  glClearBufferiv(buffer, drawbuffer, value);
  OGLM_CHECK_ERR(glClearBufferiv, )

void
glClearBufferiv_p(buffer, drawbuffer, ...)
  GLenum buffer;
  GLint drawbuffer;
CODE:
  OGLM_GLEWINIT
  OGLM_CHECK_ERR(glClearBufferiv, )
  OGLM_AVAIL_CHECK(__glewClearBufferiv, glClearBufferiv)
  OGLM_SIZE_ENUM(Buffer,buffer,1)
  GLint* value = OGLM_GET_VARARGS(value,2,GLint,IV,buffer_count);
  glClearBufferiv((GLenum )buffer, (GLint )drawbuffer, (const GLint* )value);
  OGLM_CHECK_ERR(glClearBufferiv, free(value);)
  free(value);

void
glClearBufferuiv_c(buffer, drawbuffer, value)
  GLenum buffer;
  GLint drawbuffer;
  const GLuint* value;
CODE:
  OGLM_GLEWINIT
  OGLM_CHECK_ERR(glClearBufferuiv, )
  OGLM_AVAIL_CHECK(__glewClearBufferuiv, glClearBufferuiv)
  glClearBufferuiv(buffer, drawbuffer, value);
  OGLM_CHECK_ERR(glClearBufferuiv, )

void
glClearBufferuiv_p(buffer, drawbuffer, ...)
  GLenum buffer;
  GLint drawbuffer;
CODE:
  OGLM_GLEWINIT
  OGLM_CHECK_ERR(glClearBufferuiv, )
  OGLM_AVAIL_CHECK(__glewClearBufferuiv, glClearBufferuiv)
  OGLM_SIZE_ENUM(Buffer,buffer,1)
  GLuint* value = OGLM_GET_VARARGS(value,2,GLuint,UV,buffer_count);
  glClearBufferuiv((GLenum )buffer, (GLint )drawbuffer, (const GLuint* )value);
  OGLM_CHECK_ERR(glClearBufferuiv, free(value);)
  free(value);

void
glClearColor(red, green, blue, alpha)
  GLclampf red;
  GLclampf green;
  GLclampf blue;
  GLclampf alpha;
CODE:
  OGLM_GLEWINIT
  OGLM_CHECK_ERR(glClearColor, )
  glClearColor(red, green, blue, alpha);
  OGLM_CHECK_ERR(glClearColor, )

void
glClearColorIiEXT(red, green, blue, alpha)
  GLint red;
  GLint green;
  GLint blue;
  GLint alpha;
CODE:
  OGLM_GLEWINIT
  OGLM_CHECK_ERR(glClearColorIiEXT, )
  OGLM_AVAIL_CHECK(__glewClearColorIiEXT, glClearColorIiEXT)
  glClearColorIiEXT(red, green, blue, alpha);
  OGLM_CHECK_ERR(glClearColorIiEXT, )

void
glClearColorIuiEXT(red, green, blue, alpha)
  GLuint red;
  GLuint green;
  GLuint blue;
  GLuint alpha;
CODE:
  OGLM_GLEWINIT
  OGLM_CHECK_ERR(glClearColorIuiEXT, )
  OGLM_AVAIL_CHECK(__glewClearColorIuiEXT, glClearColorIuiEXT)
  glClearColorIuiEXT(red, green, blue, alpha);
  OGLM_CHECK_ERR(glClearColorIuiEXT, )

void
glClearColorx(red, green, blue, alpha)
  GLclampx red;
  GLclampx green;
  GLclampx blue;
  GLclampx alpha;
CODE:
  OGLM_GLEWINIT
  OGLM_CHECK_ERR(glClearColorx, )
  OGLM_AVAIL_CHECK(__glewClearColorx, glClearColorx)
  glClearColorx(red, green, blue, alpha);
  OGLM_CHECK_ERR(glClearColorx, )

void
glClearDepth(depth)
  GLclampd depth;
CODE:
  OGLM_GLEWINIT
  OGLM_CHECK_ERR(glClearDepth, )
  glClearDepth(depth);
  OGLM_CHECK_ERR(glClearDepth, )

void
glClearDepthdNV(depth)
  GLdouble depth;
CODE:
  OGLM_GLEWINIT
  OGLM_CHECK_ERR(glClearDepthdNV, )
  OGLM_AVAIL_CHECK(__glewClearDepthdNV, glClearDepthdNV)
  glClearDepthdNV(depth);
  OGLM_CHECK_ERR(glClearDepthdNV, )

void
glClearDepthf(d)
  GLclampf d;
CODE:
  OGLM_GLEWINIT
  OGLM_CHECK_ERR(glClearDepthf, )
  OGLM_AVAIL_CHECK(__glewClearDepthf, glClearDepthf)
  glClearDepthf(d);
  OGLM_CHECK_ERR(glClearDepthf, )

void
glClearDepthfOES(depth)
  GLclampf depth;
CODE:
  OGLM_GLEWINIT
  OGLM_CHECK_ERR(glClearDepthfOES, )
  OGLM_AVAIL_CHECK(__glewClearDepthfOES, glClearDepthfOES)
  glClearDepthfOES(depth);
  OGLM_CHECK_ERR(glClearDepthfOES, )

void
glClearDepthx(depth)
  GLclampx depth;
CODE:
  OGLM_GLEWINIT
  OGLM_CHECK_ERR(glClearDepthx, )
  OGLM_AVAIL_CHECK(__glewClearDepthx, glClearDepthx)
  glClearDepthx(depth);
  OGLM_CHECK_ERR(glClearDepthx, )

void
glClearIndex(c)
  GLfloat c;
CODE:
  OGLM_GLEWINIT
  OGLM_CHECK_ERR(glClearIndex, )
  glClearIndex(c);
  OGLM_CHECK_ERR(glClearIndex, )

void
glClearNamedBufferData_c(buffer, internalformat, format, type, data)
  GLuint buffer;
  GLenum internalformat;
  GLenum format;
  GLenum type;
  const void *data;
CODE:
  OGLM_GLEWINIT
  OGLM_CHECK_ERR(glClearNamedBufferData, )
  OGLM_AVAIL_CHECK(__glewClearNamedBufferData, glClearNamedBufferData)
  glClearNamedBufferData(buffer, internalformat, format, type, data);
  OGLM_CHECK_ERR(glClearNamedBufferData, )

void
glClearNamedBufferDataEXT_c(buffer, internalformat, format, type, data)
  GLuint buffer;
  GLenum internalformat;
  GLenum format;
  GLenum type;
  const void *data;
CODE:
  OGLM_GLEWINIT
  OGLM_CHECK_ERR(glClearNamedBufferDataEXT, )
  OGLM_AVAIL_CHECK(__glewClearNamedBufferDataEXT, glClearNamedBufferDataEXT)
  glClearNamedBufferDataEXT(buffer, internalformat, format, type, data);
  OGLM_CHECK_ERR(glClearNamedBufferDataEXT, )

void
glClearNamedBufferSubData_c(buffer, internalformat, offset, size, format, type, data)
  GLuint buffer;
  GLenum internalformat;
  GLintptr offset;
  GLsizeiptr size;
  GLenum format;
  GLenum type;
  const void *data;
CODE:
  OGLM_GLEWINIT
  OGLM_CHECK_ERR(glClearNamedBufferSubData, )
  OGLM_AVAIL_CHECK(__glewClearNamedBufferSubData, glClearNamedBufferSubData)
  glClearNamedBufferSubData(buffer, internalformat, offset, size, format, type, data);
  OGLM_CHECK_ERR(glClearNamedBufferSubData, )

void
glClearNamedBufferSubDataEXT_c(buffer, internalformat, offset, size, format, type, data)
  GLuint buffer;
  GLenum internalformat;
  GLintptr offset;
  GLsizeiptr size;
  GLenum format;
  GLenum type;
  const void *data;
CODE:
  OGLM_GLEWINIT
  OGLM_CHECK_ERR(glClearNamedBufferSubDataEXT, )
  OGLM_AVAIL_CHECK(__glewClearNamedBufferSubDataEXT, glClearNamedBufferSubDataEXT)
  glClearNamedBufferSubDataEXT(buffer, internalformat, offset, size, format, type, data);
  OGLM_CHECK_ERR(glClearNamedBufferSubDataEXT, )

void
glClearNamedFramebufferfi(framebuffer, buffer, drawbuffer, depth, stencil)
  GLuint framebuffer;
  GLenum buffer;
  GLint drawbuffer;
  GLfloat depth;
  GLint stencil;
CODE:
  OGLM_GLEWINIT
  OGLM_CHECK_ERR(glClearNamedFramebufferfi, )
  OGLM_AVAIL_CHECK(__glewClearNamedFramebufferfi, glClearNamedFramebufferfi)
  glClearNamedFramebufferfi(framebuffer, buffer, drawbuffer, depth, stencil);
  OGLM_CHECK_ERR(glClearNamedFramebufferfi, )

void
glClearNamedFramebufferfv_c(framebuffer, buffer, drawbuffer, value)
  GLuint framebuffer;
  GLenum buffer;
  GLint drawbuffer;
  const GLfloat* value;
CODE:
  OGLM_GLEWINIT
  OGLM_CHECK_ERR(glClearNamedFramebufferfv, )
  OGLM_AVAIL_CHECK(__glewClearNamedFramebufferfv, glClearNamedFramebufferfv)
  glClearNamedFramebufferfv(framebuffer, buffer, drawbuffer, value);
  OGLM_CHECK_ERR(glClearNamedFramebufferfv, )

void
glClearNamedFramebufferfv_p(framebuffer, buffer, drawbuffer, ...)
  GLuint framebuffer;
  GLenum buffer;
  GLint drawbuffer;
CODE:
  OGLM_GLEWINIT
  OGLM_CHECK_ERR(glClearNamedFramebufferfv, )
  OGLM_AVAIL_CHECK(__glewClearNamedFramebufferfv, glClearNamedFramebufferfv)
  OGLM_SIZE_ENUM(Buffer,buffer,1)
  GLfloat* value = OGLM_GET_VARARGS(value,3,GLfloat,NV,buffer_count);
  glClearNamedFramebufferfv((GLuint )framebuffer, (GLenum )buffer, (GLint )drawbuffer, (const GLfloat* )value);
  OGLM_CHECK_ERR(glClearNamedFramebufferfv, free(value);)
  free(value);

void
glClearNamedFramebufferiv_c(framebuffer, buffer, drawbuffer, value)
  GLuint framebuffer;
  GLenum buffer;
  GLint drawbuffer;
  const GLint* value;
CODE:
  OGLM_GLEWINIT
  OGLM_CHECK_ERR(glClearNamedFramebufferiv, )
  OGLM_AVAIL_CHECK(__glewClearNamedFramebufferiv, glClearNamedFramebufferiv)
  glClearNamedFramebufferiv(framebuffer, buffer, drawbuffer, value);
  OGLM_CHECK_ERR(glClearNamedFramebufferiv, )

void
glClearNamedFramebufferiv_p(framebuffer, buffer, drawbuffer, ...)
  GLuint framebuffer;
  GLenum buffer;
  GLint drawbuffer;
CODE:
  OGLM_GLEWINIT
  OGLM_CHECK_ERR(glClearNamedFramebufferiv, )
  OGLM_AVAIL_CHECK(__glewClearNamedFramebufferiv, glClearNamedFramebufferiv)
  OGLM_SIZE_ENUM(Buffer,buffer,1)
  GLint* value = OGLM_GET_VARARGS(value,3,GLint,IV,buffer_count);
  glClearNamedFramebufferiv((GLuint )framebuffer, (GLenum )buffer, (GLint )drawbuffer, (const GLint* )value);
  OGLM_CHECK_ERR(glClearNamedFramebufferiv, free(value);)
  free(value);

void
glClearNamedFramebufferuiv_c(framebuffer, buffer, drawbuffer, value)
  GLuint framebuffer;
  GLenum buffer;
  GLint drawbuffer;
  const GLuint* value;
CODE:
  OGLM_GLEWINIT
  OGLM_CHECK_ERR(glClearNamedFramebufferuiv, )
  OGLM_AVAIL_CHECK(__glewClearNamedFramebufferuiv, glClearNamedFramebufferuiv)
  glClearNamedFramebufferuiv(framebuffer, buffer, drawbuffer, value);
  OGLM_CHECK_ERR(glClearNamedFramebufferuiv, )

void
glClearNamedFramebufferuiv_p(framebuffer, buffer, drawbuffer, ...)
  GLuint framebuffer;
  GLenum buffer;
  GLint drawbuffer;
CODE:
  OGLM_GLEWINIT
  OGLM_CHECK_ERR(glClearNamedFramebufferuiv, )
  OGLM_AVAIL_CHECK(__glewClearNamedFramebufferuiv, glClearNamedFramebufferuiv)
  OGLM_SIZE_ENUM(Buffer,buffer,1)
  GLuint* value = OGLM_GET_VARARGS(value,3,GLuint,UV,buffer_count);
  glClearNamedFramebufferuiv((GLuint )framebuffer, (GLenum )buffer, (GLint )drawbuffer, (const GLuint* )value);
  OGLM_CHECK_ERR(glClearNamedFramebufferuiv, free(value);)
  free(value);

void
glClearPixelLocalStorageuiEXT_c(offset, n, values)
  GLsizei offset;
  GLsizei n;
  const GLuint* values;
CODE:
  OGLM_GLEWINIT
  OGLM_CHECK_ERR(glClearPixelLocalStorageuiEXT, )
  OGLM_AVAIL_CHECK(__glewClearPixelLocalStorageuiEXT, glClearPixelLocalStorageuiEXT)
  glClearPixelLocalStorageuiEXT(offset, n, values);
  OGLM_CHECK_ERR(glClearPixelLocalStorageuiEXT, )

void
glClearPixelLocalStorageuiEXT_p(offset, ...)
  GLsizei offset;
CODE:
  OGLM_GLEWINIT
  OGLM_CHECK_ERR(glClearPixelLocalStorageuiEXT, )
  OGLM_AVAIL_CHECK(__glewClearPixelLocalStorageuiEXT, glClearPixelLocalStorageuiEXT)
  GLsizei n = items-1;
  GLuint* values = OGLM_GET_VARARGS(values,1,GLuint,UV,n);
  glClearPixelLocalStorageuiEXT((GLsizei )offset, (GLsizei )n, (const GLuint* )values);
  OGLM_CHECK_ERR(glClearPixelLocalStorageuiEXT, free(values);)
  free(values);

void
glClearStencil(s)
  GLint s;
CODE:
  OGLM_GLEWINIT
  OGLM_CHECK_ERR(glClearStencil, )
  glClearStencil(s);
  OGLM_CHECK_ERR(glClearStencil, )

void
glClearTexImage_c(texture, level, format, type, data)
  GLuint texture;
  GLint level;
  GLenum format;
  GLenum type;
  const void *data;
ALIAS:
  glClearTexImageEXT_c = 1
CODE:
  OGLM_GLEWINIT
  OGLM_CHECK_ERR(glClearTexImage, )
  OGLM_AVAIL_CHECK(__glewClearTexImage, glClearTexImage)
  glClearTexImage(texture, level, format, type, data);
  OGLM_CHECK_ERR(glClearTexImage, )

void
glClearTexSubImage_c(texture, level, xoffset, yoffset, zoffset, width, height, depth, format, type, data)
  GLuint texture;
  GLint level;
  GLint xoffset;
  GLint yoffset;
  GLint zoffset;
  GLsizei width;
  GLsizei height;
  GLsizei depth;
  GLenum format;
  GLenum type;
  const void *data;
ALIAS:
  glClearTexSubImageEXT_c = 1
CODE:
  OGLM_GLEWINIT
  OGLM_CHECK_ERR(glClearTexSubImage, )
  OGLM_AVAIL_CHECK(__glewClearTexSubImage, glClearTexSubImage)
  glClearTexSubImage(texture, level, xoffset, yoffset, zoffset, width, height, depth, format, type, data);
  OGLM_CHECK_ERR(glClearTexSubImage, )

void
glClientActiveTexture(texture)
  GLenum texture;
ALIAS:
  glClientActiveTextureARB = 1
CODE:
  OGLM_GLEWINIT
  OGLM_CHECK_ERR(glClientActiveTexture, )
  OGLM_AVAIL_CHECK(__glewClientActiveTexture, glClientActiveTexture)
  glClientActiveTexture(texture);
  OGLM_CHECK_ERR(glClientActiveTexture, )

void
glClientActiveVertexStreamATI(stream)
  GLenum stream;
CODE:
  OGLM_GLEWINIT
  OGLM_CHECK_ERR(glClientActiveVertexStreamATI, )
  OGLM_AVAIL_CHECK(__glewClientActiveVertexStreamATI, glClientActiveVertexStreamATI)
  glClientActiveVertexStreamATI(stream);
  OGLM_CHECK_ERR(glClientActiveVertexStreamATI, )

void
glClientAttribDefaultEXT(mask)
  GLbitfield mask;
CODE:
  OGLM_GLEWINIT
  OGLM_CHECK_ERR(glClientAttribDefaultEXT, )
  OGLM_AVAIL_CHECK(__glewClientAttribDefaultEXT, glClientAttribDefaultEXT)
  glClientAttribDefaultEXT(mask);
  OGLM_CHECK_ERR(glClientAttribDefaultEXT, )

void
glClientWaitSemaphoreui64NVX_c(fenceObjectCount, semaphoreArray, fenceValueArray)
  GLsizei fenceObjectCount;
  const GLuint* semaphoreArray;
  const GLuint64 *fenceValueArray;
CODE:
  OGLM_GLEWINIT
  OGLM_CHECK_ERR(glClientWaitSemaphoreui64NVX, )
  OGLM_AVAIL_CHECK(__glewClientWaitSemaphoreui64NVX, glClientWaitSemaphoreui64NVX)
  glClientWaitSemaphoreui64NVX(fenceObjectCount, semaphoreArray, fenceValueArray);
  OGLM_CHECK_ERR(glClientWaitSemaphoreui64NVX, )

void
glClientWaitSemaphoreui64NVX_p(semaphoreArraySV, fenceValueArraySV)
  SV *semaphoreArraySV;
  SV *fenceValueArraySV;
CODE:
  OGLM_GLEWINIT
  OGLM_CHECK_ERR(glClientWaitSemaphoreui64NVX, )
  OGLM_AVAIL_CHECK(__glewClientWaitSemaphoreui64NVX, glClientWaitSemaphoreui64NVX)
  GLsizei fenceObjectCount = OGLM_LEN_ARRAY(fenceObjectCount, semaphoreArray);
  GLuint64 *fenceValueArray = OGLM_GET_ARRAY(fenceValueArray, GLuint64, UV, fenceObjectCount);
  GLuint* semaphoreArray = OGLM_GET_ARRAY(semaphoreArray, GLuint, UV, fenceObjectCount);
  glClientWaitSemaphoreui64NVX((GLsizei )fenceObjectCount, (const GLuint* )semaphoreArray, (const GLuint64 *)fenceValueArray);
  OGLM_CHECK_ERR(glClientWaitSemaphoreui64NVX, free(fenceValueArray);free(semaphoreArray);)
  free(fenceValueArray);free(semaphoreArray);

GLenum
glClientWaitSync(sync, flags, timeout)
  GLsync sync;
  GLbitfield flags;
  GLuint64 timeout;
ALIAS:
  glClientWaitSyncAPPLE = 1
CODE:
  OGLM_GLEWINIT
  OGLM_CHECK_ERR(glClientWaitSync, )
  OGLM_AVAIL_CHECK(__glewClientWaitSync, glClientWaitSync)
  RETVAL = glClientWaitSync(sync, flags, timeout);
  OGLM_CHECK_ERR(glClientWaitSync, )
OUTPUT:
  RETVAL

void
glClipControl(origin, depth)
  GLenum origin;
  GLenum depth;
ALIAS:
  glClipControlEXT = 1
CODE:
  OGLM_GLEWINIT
  OGLM_CHECK_ERR(glClipControl, )
  OGLM_AVAIL_CHECK(__glewClipControl, glClipControl)
  glClipControl(origin, depth);
  OGLM_CHECK_ERR(glClipControl, )

void
glClipPlane_c(plane, equation)
  GLenum plane;
  const GLdouble *equation;
CODE:
  OGLM_GLEWINIT
  OGLM_CHECK_ERR(glClipPlane, )
  glClipPlane(plane, equation);
  OGLM_CHECK_ERR(glClipPlane, )

void
glClipPlane_p(plane, ...)
  GLenum plane;
CODE:
  OGLM_GLEWINIT
  OGLM_CHECK_ERR(glClipPlane, )
  GLdouble *equation = OGLM_GET_VARARGS(equation,1,GLdouble,NV,4);
  glClipPlane((GLenum )plane, (const GLdouble *)equation);
  OGLM_CHECK_ERR(glClipPlane, free(equation);)
  free(equation);

void
glClipPlanef_c(p, eqn)
  GLenum p;
  const GLfloat* eqn;
CODE:
  OGLM_GLEWINIT
  OGLM_CHECK_ERR(glClipPlanef, )
  OGLM_AVAIL_CHECK(__glewClipPlanef, glClipPlanef)
  glClipPlanef(p, eqn);
  OGLM_CHECK_ERR(glClipPlanef, )

void
glClipPlanef_p(p, ...)
  GLenum p;
CODE:
  OGLM_GLEWINIT
  OGLM_CHECK_ERR(glClipPlanef, )
  OGLM_AVAIL_CHECK(__glewClipPlanef, glClipPlanef)
  GLfloat* eqn = OGLM_GET_VARARGS(eqn,1,GLfloat,NV,4);
  glClipPlanef((GLenum )p, (const GLfloat* )eqn);
  OGLM_CHECK_ERR(glClipPlanef, free(eqn);)
  free(eqn);

void
glClipPlanefOES_c(plane, equation)
  GLenum plane;
  const GLfloat* equation;
CODE:
  OGLM_GLEWINIT
  OGLM_CHECK_ERR(glClipPlanefOES, )
  OGLM_AVAIL_CHECK(__glewClipPlanefOES, glClipPlanefOES)
  glClipPlanefOES(plane, equation);
  OGLM_CHECK_ERR(glClipPlanefOES, )

void
glClipPlanex_c(plane, equation)
  GLenum plane;
  const GLfixed* equation;
CODE:
  OGLM_GLEWINIT
  OGLM_CHECK_ERR(glClipPlanex, )
  OGLM_AVAIL_CHECK(__glewClipPlanex, glClipPlanex)
  glClipPlanex(plane, equation);
  OGLM_CHECK_ERR(glClipPlanex, )

void
glClipPlanex_p(plane, ...)
  GLenum plane;
CODE:
  OGLM_GLEWINIT
  OGLM_CHECK_ERR(glClipPlanex, )
  OGLM_AVAIL_CHECK(__glewClipPlanex, glClipPlanex)
  GLfixed* equation = OGLM_GET_VARARGS(equation,1,GLfixed,IV,4);
  glClipPlanex((GLenum )plane, (const GLfixed* )equation);
  OGLM_CHECK_ERR(glClipPlanex, free(equation);)
  free(equation);

void
glColor3b(red, green, blue)
  GLbyte red;
  GLbyte green;
  GLbyte blue;
CODE:
  OGLM_GLEWINIT
  OGLM_CHECK_ERR(glColor3b, )
  glColor3b(red, green, blue);
  OGLM_CHECK_ERR(glColor3b, )

void
glColor3bv_c(v)
  const GLbyte *v;
CODE:
  OGLM_GLEWINIT
  OGLM_CHECK_ERR(glColor3bv, )
  glColor3bv(v);
  OGLM_CHECK_ERR(glColor3bv, )

void
glColor3bv_p(...)
CODE:
  OGLM_GLEWINIT
  OGLM_CHECK_ERR(glColor3bv, )
  GLbyte *v = OGLM_GET_VARARGS(v,0,GLbyte,IV,3);
  glColor3bv((const GLbyte *)v);
  OGLM_CHECK_ERR(glColor3bv, free(v);)
  free(v);

void
glColor3d(red, green, blue)
  GLdouble red;
  GLdouble green;
  GLdouble blue;
CODE:
  OGLM_GLEWINIT
  OGLM_CHECK_ERR(glColor3d, )
  glColor3d(red, green, blue);
  OGLM_CHECK_ERR(glColor3d, )

void
glColor3dv_c(v)
  const GLdouble *v;
CODE:
  OGLM_GLEWINIT
  OGLM_CHECK_ERR(glColor3dv, )
  glColor3dv(v);
  OGLM_CHECK_ERR(glColor3dv, )

void
glColor3dv_p(...)
CODE:
  OGLM_GLEWINIT
  OGLM_CHECK_ERR(glColor3dv, )
  GLdouble *v = OGLM_GET_VARARGS(v,0,GLdouble,NV,3);
  glColor3dv((const GLdouble *)v);
  OGLM_CHECK_ERR(glColor3dv, free(v);)
  free(v);

void
glColor3f(red, green, blue)
  GLfloat red;
  GLfloat green;
  GLfloat blue;
CODE:
  OGLM_GLEWINIT
  OGLM_CHECK_ERR(glColor3f, )
  glColor3f(red, green, blue);
  OGLM_CHECK_ERR(glColor3f, )

void
glColor3fVertex3fSUN(r, g, b, x, y, z)
  GLfloat r;
  GLfloat g;
  GLfloat b;
  GLfloat x;
  GLfloat y;
  GLfloat z;
CODE:
  OGLM_GLEWINIT
  OGLM_CHECK_ERR(glColor3fVertex3fSUN, )
  OGLM_AVAIL_CHECK(__glewColor3fVertex3fSUN, glColor3fVertex3fSUN)
  glColor3fVertex3fSUN(r, g, b, x, y, z);
  OGLM_CHECK_ERR(glColor3fVertex3fSUN, )

void
glColor3fVertex3fvSUN_c(c, v)
  const GLfloat* c;
  const GLfloat *v;
CODE:
  OGLM_GLEWINIT
  OGLM_CHECK_ERR(glColor3fVertex3fvSUN, )
  OGLM_AVAIL_CHECK(__glewColor3fVertex3fvSUN, glColor3fVertex3fvSUN)
  glColor3fVertex3fvSUN(c, v);
  OGLM_CHECK_ERR(glColor3fVertex3fvSUN, )

void
glColor3fVertex3fvSUN_p(cSV, vSV)
  SV *cSV;
  SV *vSV;
CODE:
  OGLM_GLEWINIT
  OGLM_CHECK_ERR(glColor3fVertex3fvSUN, )
  OGLM_AVAIL_CHECK(__glewColor3fVertex3fvSUN, glColor3fVertex3fvSUN)
  GLfloat* c = OGLM_GET_ARRAY(c, GLfloat, NV, 3);
  GLfloat *v = OGLM_GET_ARRAY(v, GLfloat, NV, 3);
  glColor3fVertex3fvSUN((const GLfloat* )c, (const GLfloat *)v);
  OGLM_CHECK_ERR(glColor3fVertex3fvSUN, free(c);free(v);)
  free(c);free(v);

void
glColor3fv_c(v)
  const GLfloat *v;
CODE:
  OGLM_GLEWINIT
  OGLM_CHECK_ERR(glColor3fv, )
  glColor3fv(v);
  OGLM_CHECK_ERR(glColor3fv, )

void
glColor3fv_p(...)
CODE:
  OGLM_GLEWINIT
  OGLM_CHECK_ERR(glColor3fv, )
  GLfloat *v = OGLM_GET_VARARGS(v,0,GLfloat,NV,3);
  glColor3fv((const GLfloat *)v);
  OGLM_CHECK_ERR(glColor3fv, free(v);)
  free(v);

void
glColor3hNV(red, green, blue)
  GLhalf red;
  GLhalf green;
  GLhalf blue;
CODE:
  OGLM_GLEWINIT
  OGLM_CHECK_ERR(glColor3hNV, )
  OGLM_AVAIL_CHECK(__glewColor3hNV, glColor3hNV)
  glColor3hNV(red, green, blue);
  OGLM_CHECK_ERR(glColor3hNV, )

void
glColor3hvNV_c(v)
  const GLhalf* v;
CODE:
  OGLM_GLEWINIT
  OGLM_CHECK_ERR(glColor3hvNV, )
  OGLM_AVAIL_CHECK(__glewColor3hvNV, glColor3hvNV)
  glColor3hvNV(v);
  OGLM_CHECK_ERR(glColor3hvNV, )

void
glColor3hvNV_p(...)
CODE:
  OGLM_GLEWINIT
  OGLM_CHECK_ERR(glColor3hvNV, )
  OGLM_AVAIL_CHECK(__glewColor3hvNV, glColor3hvNV)
  GLhalf* v = OGLM_GET_VARARGS(v,0,GLhalf,NV,3);
  glColor3hvNV((const GLhalf* )v);
  OGLM_CHECK_ERR(glColor3hvNV, free(v);)
  free(v);

void
glColor3i(red, green, blue)
  GLint red;
  GLint green;
  GLint blue;
CODE:
  OGLM_GLEWINIT
  OGLM_CHECK_ERR(glColor3i, )
  glColor3i(red, green, blue);
  OGLM_CHECK_ERR(glColor3i, )

void
glColor3iv_c(v)
  const GLint *v;
CODE:
  OGLM_GLEWINIT
  OGLM_CHECK_ERR(glColor3iv, )
  glColor3iv(v);
  OGLM_CHECK_ERR(glColor3iv, )

void
glColor3iv_p(...)
CODE:
  OGLM_GLEWINIT
  OGLM_CHECK_ERR(glColor3iv, )
  GLint *v = OGLM_GET_VARARGS(v,0,GLint,IV,3);
  glColor3iv((const GLint *)v);
  OGLM_CHECK_ERR(glColor3iv, free(v);)
  free(v);

void
glColor3s(red, green, blue)
  GLshort red;
  GLshort green;
  GLshort blue;
CODE:
  OGLM_GLEWINIT
  OGLM_CHECK_ERR(glColor3s, )
  glColor3s(red, green, blue);
  OGLM_CHECK_ERR(glColor3s, )

void
glColor3sv_c(v)
  const GLshort *v;
CODE:
  OGLM_GLEWINIT
  OGLM_CHECK_ERR(glColor3sv, )
  glColor3sv(v);
  OGLM_CHECK_ERR(glColor3sv, )

void
glColor3sv_p(...)
CODE:
  OGLM_GLEWINIT
  OGLM_CHECK_ERR(glColor3sv, )
  GLshort *v = OGLM_GET_VARARGS(v,0,GLshort,IV,3);
  glColor3sv((const GLshort *)v);
  OGLM_CHECK_ERR(glColor3sv, free(v);)
  free(v);

void
glColor3ub(red, green, blue)
  GLubyte red;
  GLubyte green;
  GLubyte blue;
CODE:
  OGLM_GLEWINIT
  OGLM_CHECK_ERR(glColor3ub, )
  glColor3ub(red, green, blue);
  OGLM_CHECK_ERR(glColor3ub, )

void
glColor3ubv_c(v)
  const GLubyte *v;
CODE:
  OGLM_GLEWINIT
  OGLM_CHECK_ERR(glColor3ubv, )
  glColor3ubv(v);
  OGLM_CHECK_ERR(glColor3ubv, )

void
glColor3ubv_p(...)
CODE:
  OGLM_GLEWINIT
  OGLM_CHECK_ERR(glColor3ubv, )
  GLubyte *v = OGLM_GET_VARARGS(v,0,GLubyte,UV,3);
  glColor3ubv((const GLubyte *)v);
  OGLM_CHECK_ERR(glColor3ubv, free(v);)
  free(v);

void
glColor3ui(red, green, blue)
  GLuint red;
  GLuint green;
  GLuint blue;
CODE:
  OGLM_GLEWINIT
  OGLM_CHECK_ERR(glColor3ui, )
  glColor3ui(red, green, blue);
  OGLM_CHECK_ERR(glColor3ui, )

void
glColor3uiv_c(v)
  const GLuint *v;
CODE:
  OGLM_GLEWINIT
  OGLM_CHECK_ERR(glColor3uiv, )
  glColor3uiv(v);
  OGLM_CHECK_ERR(glColor3uiv, )

void
glColor3uiv_p(...)
CODE:
  OGLM_GLEWINIT
  OGLM_CHECK_ERR(glColor3uiv, )
  GLuint *v = OGLM_GET_VARARGS(v,0,GLuint,UV,3);
  glColor3uiv((const GLuint *)v);
  OGLM_CHECK_ERR(glColor3uiv, free(v);)
  free(v);

void
glColor3us(red, green, blue)
  GLushort red;
  GLushort green;
  GLushort blue;
CODE:
  OGLM_GLEWINIT
  OGLM_CHECK_ERR(glColor3us, )
  glColor3us(red, green, blue);
  OGLM_CHECK_ERR(glColor3us, )

void
glColor3usv_c(v)
  const GLushort *v;
CODE:
  OGLM_GLEWINIT
  OGLM_CHECK_ERR(glColor3usv, )
  glColor3usv(v);
  OGLM_CHECK_ERR(glColor3usv, )

void
glColor3usv_p(...)
CODE:
  OGLM_GLEWINIT
  OGLM_CHECK_ERR(glColor3usv, )
  GLushort *v = OGLM_GET_VARARGS(v,0,GLushort,UV,3);
  glColor3usv((const GLushort *)v);
  OGLM_CHECK_ERR(glColor3usv, free(v);)
  free(v);

void
glColor4b(red, green, blue, alpha)
  GLbyte red;
  GLbyte green;
  GLbyte blue;
  GLbyte alpha;
CODE:
  OGLM_GLEWINIT
  OGLM_CHECK_ERR(glColor4b, )
  glColor4b(red, green, blue, alpha);
  OGLM_CHECK_ERR(glColor4b, )

void
glColor4bv_c(v)
  const GLbyte *v;
CODE:
  OGLM_GLEWINIT
  OGLM_CHECK_ERR(glColor4bv, )
  glColor4bv(v);
  OGLM_CHECK_ERR(glColor4bv, )

void
glColor4bv_p(...)
CODE:
  OGLM_GLEWINIT
  OGLM_CHECK_ERR(glColor4bv, )
  GLbyte *v = OGLM_GET_VARARGS(v,0,GLbyte,IV,4);
  glColor4bv((const GLbyte *)v);
  OGLM_CHECK_ERR(glColor4bv, free(v);)
  free(v);

void
glColor4d(red, green, blue, alpha)
  GLdouble red;
  GLdouble green;
  GLdouble blue;
  GLdouble alpha;
CODE:
  OGLM_GLEWINIT
  OGLM_CHECK_ERR(glColor4d, )
  glColor4d(red, green, blue, alpha);
  OGLM_CHECK_ERR(glColor4d, )

void
glColor4dv_c(v)
  const GLdouble *v;
CODE:
  OGLM_GLEWINIT
  OGLM_CHECK_ERR(glColor4dv, )
  glColor4dv(v);
  OGLM_CHECK_ERR(glColor4dv, )

void
glColor4dv_p(...)
CODE:
  OGLM_GLEWINIT
  OGLM_CHECK_ERR(glColor4dv, )
  GLdouble *v = OGLM_GET_VARARGS(v,0,GLdouble,NV,4);
  glColor4dv((const GLdouble *)v);
  OGLM_CHECK_ERR(glColor4dv, free(v);)
  free(v);

void
glColor4f(red, green, blue, alpha)
  GLfloat red;
  GLfloat green;
  GLfloat blue;
  GLfloat alpha;
CODE:
  OGLM_GLEWINIT
  OGLM_CHECK_ERR(glColor4f, )
  glColor4f(red, green, blue, alpha);
  OGLM_CHECK_ERR(glColor4f, )

void
glColor4fNormal3fVertex3fSUN(r, g, b, a, nx, ny, nz, x, y, z)
  GLfloat r;
  GLfloat g;
  GLfloat b;
  GLfloat a;
  GLfloat nx;
  GLfloat ny;
  GLfloat nz;
  GLfloat x;
  GLfloat y;
  GLfloat z;
CODE:
  OGLM_GLEWINIT
  OGLM_CHECK_ERR(glColor4fNormal3fVertex3fSUN, )
  OGLM_AVAIL_CHECK(__glewColor4fNormal3fVertex3fSUN, glColor4fNormal3fVertex3fSUN)
  glColor4fNormal3fVertex3fSUN(r, g, b, a, nx, ny, nz, x, y, z);
  OGLM_CHECK_ERR(glColor4fNormal3fVertex3fSUN, )

void
glColor4fNormal3fVertex3fvSUN_c(c, n, v)
  const GLfloat* c;
  const GLfloat *n;
  const GLfloat *v;
CODE:
  OGLM_GLEWINIT
  OGLM_CHECK_ERR(glColor4fNormal3fVertex3fvSUN, )
  OGLM_AVAIL_CHECK(__glewColor4fNormal3fVertex3fvSUN, glColor4fNormal3fVertex3fvSUN)
  glColor4fNormal3fVertex3fvSUN(c, n, v);
  OGLM_CHECK_ERR(glColor4fNormal3fVertex3fvSUN, )

void
glColor4fNormal3fVertex3fvSUN_p(cSV, nSV, vSV)
  SV *cSV;
  SV *nSV;
  SV *vSV;
CODE:
  OGLM_GLEWINIT
  OGLM_CHECK_ERR(glColor4fNormal3fVertex3fvSUN, )
  OGLM_AVAIL_CHECK(__glewColor4fNormal3fVertex3fvSUN, glColor4fNormal3fVertex3fvSUN)
  GLfloat* c = OGLM_GET_ARRAY(c, GLfloat, NV, 4);
  GLfloat *n = OGLM_GET_ARRAY(n, GLfloat, NV, 3);
  GLfloat *v = OGLM_GET_ARRAY(v, GLfloat, NV, 3);
  glColor4fNormal3fVertex3fvSUN((const GLfloat* )c, (const GLfloat *)n, (const GLfloat *)v);
  OGLM_CHECK_ERR(glColor4fNormal3fVertex3fvSUN, free(c);free(n);free(v);)
  free(c);free(n);free(v);

void
glColor4fv_c(v)
  const GLfloat *v;
CODE:
  OGLM_GLEWINIT
  OGLM_CHECK_ERR(glColor4fv, )
  glColor4fv(v);
  OGLM_CHECK_ERR(glColor4fv, )

void
glColor4fv_p(...)
CODE:
  OGLM_GLEWINIT
  OGLM_CHECK_ERR(glColor4fv, )
  GLfloat *v = OGLM_GET_VARARGS(v,0,GLfloat,NV,4);
  glColor4fv((const GLfloat *)v);
  OGLM_CHECK_ERR(glColor4fv, free(v);)
  free(v);

void
glColor4hNV(red, green, blue, alpha)
  GLhalf red;
  GLhalf green;
  GLhalf blue;
  GLhalf alpha;
CODE:
  OGLM_GLEWINIT
  OGLM_CHECK_ERR(glColor4hNV, )
  OGLM_AVAIL_CHECK(__glewColor4hNV, glColor4hNV)
  glColor4hNV(red, green, blue, alpha);
  OGLM_CHECK_ERR(glColor4hNV, )

void
glColor4hvNV_c(v)
  const GLhalf* v;
CODE:
  OGLM_GLEWINIT
  OGLM_CHECK_ERR(glColor4hvNV, )
  OGLM_AVAIL_CHECK(__glewColor4hvNV, glColor4hvNV)
  glColor4hvNV(v);
  OGLM_CHECK_ERR(glColor4hvNV, )

void
glColor4hvNV_p(...)
CODE:
  OGLM_GLEWINIT
  OGLM_CHECK_ERR(glColor4hvNV, )
  OGLM_AVAIL_CHECK(__glewColor4hvNV, glColor4hvNV)
  GLhalf* v = OGLM_GET_VARARGS(v,0,GLhalf,NV,4);
  glColor4hvNV((const GLhalf* )v);
  OGLM_CHECK_ERR(glColor4hvNV, free(v);)
  free(v);

void
glColor4i(red, green, blue, alpha)
  GLint red;
  GLint green;
  GLint blue;
  GLint alpha;
CODE:
  OGLM_GLEWINIT
  OGLM_CHECK_ERR(glColor4i, )
  glColor4i(red, green, blue, alpha);
  OGLM_CHECK_ERR(glColor4i, )

void
glColor4iv_c(v)
  const GLint *v;
CODE:
  OGLM_GLEWINIT
  OGLM_CHECK_ERR(glColor4iv, )
  glColor4iv(v);
  OGLM_CHECK_ERR(glColor4iv, )

void
glColor4iv_p(...)
CODE:
  OGLM_GLEWINIT
  OGLM_CHECK_ERR(glColor4iv, )
  GLint *v = OGLM_GET_VARARGS(v,0,GLint,IV,4);
  glColor4iv((const GLint *)v);
  OGLM_CHECK_ERR(glColor4iv, free(v);)
  free(v);

void
glColor4s(red, green, blue, alpha)
  GLshort red;
  GLshort green;
  GLshort blue;
  GLshort alpha;
CODE:
  OGLM_GLEWINIT
  OGLM_CHECK_ERR(glColor4s, )
  glColor4s(red, green, blue, alpha);
  OGLM_CHECK_ERR(glColor4s, )

void
glColor4sv_c(v)
  const GLshort *v;
CODE:
  OGLM_GLEWINIT
  OGLM_CHECK_ERR(glColor4sv, )
  glColor4sv(v);
  OGLM_CHECK_ERR(glColor4sv, )

void
glColor4sv_p(...)
CODE:
  OGLM_GLEWINIT
  OGLM_CHECK_ERR(glColor4sv, )
  GLshort *v = OGLM_GET_VARARGS(v,0,GLshort,IV,4);
  glColor4sv((const GLshort *)v);
  OGLM_CHECK_ERR(glColor4sv, free(v);)
  free(v);

void
glColor4ub(red, green, blue, alpha)
  GLubyte red;
  GLubyte green;
  GLubyte blue;
  GLubyte alpha;
CODE:
  OGLM_GLEWINIT
  OGLM_CHECK_ERR(glColor4ub, )
  glColor4ub(red, green, blue, alpha);
  OGLM_CHECK_ERR(glColor4ub, )

void
glColor4ubVertex2fSUN(r, g, b, a, x, y)
  GLubyte r;
  GLubyte g;
  GLubyte b;
  GLubyte a;
  GLfloat x;
  GLfloat y;
CODE:
  OGLM_GLEWINIT
  OGLM_CHECK_ERR(glColor4ubVertex2fSUN, )
  OGLM_AVAIL_CHECK(__glewColor4ubVertex2fSUN, glColor4ubVertex2fSUN)
  glColor4ubVertex2fSUN(r, g, b, a, x, y);
  OGLM_CHECK_ERR(glColor4ubVertex2fSUN, )

void
glColor4ubVertex2fvSUN_c(c, v)
  const GLubyte* c;
  const GLfloat *v;
CODE:
  OGLM_GLEWINIT
  OGLM_CHECK_ERR(glColor4ubVertex2fvSUN, )
  OGLM_AVAIL_CHECK(__glewColor4ubVertex2fvSUN, glColor4ubVertex2fvSUN)
  glColor4ubVertex2fvSUN(c, v);
  OGLM_CHECK_ERR(glColor4ubVertex2fvSUN, )

void
glColor4ubVertex2fvSUN_p(cSV, vSV)
  SV *cSV;
  SV *vSV;
CODE:
  OGLM_GLEWINIT
  OGLM_CHECK_ERR(glColor4ubVertex2fvSUN, )
  OGLM_AVAIL_CHECK(__glewColor4ubVertex2fvSUN, glColor4ubVertex2fvSUN)
  GLubyte* c = OGLM_GET_ARRAY(c, GLubyte, UV, 4);
  GLfloat *v = OGLM_GET_ARRAY(v, GLfloat, NV, 2);
  glColor4ubVertex2fvSUN((const GLubyte* )c, (const GLfloat *)v);
  OGLM_CHECK_ERR(glColor4ubVertex2fvSUN, free(c);free(v);)
  free(c);free(v);

void
glColor4ubVertex3fSUN(r, g, b, a, x, y, z)
  GLubyte r;
  GLubyte g;
  GLubyte b;
  GLubyte a;
  GLfloat x;
  GLfloat y;
  GLfloat z;
CODE:
  OGLM_GLEWINIT
  OGLM_CHECK_ERR(glColor4ubVertex3fSUN, )
  OGLM_AVAIL_CHECK(__glewColor4ubVertex3fSUN, glColor4ubVertex3fSUN)
  glColor4ubVertex3fSUN(r, g, b, a, x, y, z);
  OGLM_CHECK_ERR(glColor4ubVertex3fSUN, )

void
glColor4ubVertex3fvSUN_c(c, v)
  const GLubyte* c;
  const GLfloat *v;
CODE:
  OGLM_GLEWINIT
  OGLM_CHECK_ERR(glColor4ubVertex3fvSUN, )
  OGLM_AVAIL_CHECK(__glewColor4ubVertex3fvSUN, glColor4ubVertex3fvSUN)
  glColor4ubVertex3fvSUN(c, v);
  OGLM_CHECK_ERR(glColor4ubVertex3fvSUN, )

void
glColor4ubVertex3fvSUN_p(cSV, vSV)
  SV *cSV;
  SV *vSV;
CODE:
  OGLM_GLEWINIT
  OGLM_CHECK_ERR(glColor4ubVertex3fvSUN, )
  OGLM_AVAIL_CHECK(__glewColor4ubVertex3fvSUN, glColor4ubVertex3fvSUN)
  GLubyte* c = OGLM_GET_ARRAY(c, GLubyte, UV, 4);
  GLfloat *v = OGLM_GET_ARRAY(v, GLfloat, NV, 3);
  glColor4ubVertex3fvSUN((const GLubyte* )c, (const GLfloat *)v);
  OGLM_CHECK_ERR(glColor4ubVertex3fvSUN, free(c);free(v);)
  free(c);free(v);

void
glColor4ubv_c(v)
  const GLubyte *v;
CODE:
  OGLM_GLEWINIT
  OGLM_CHECK_ERR(glColor4ubv, )
  glColor4ubv(v);
  OGLM_CHECK_ERR(glColor4ubv, )

void
glColor4ubv_p(...)
CODE:
  OGLM_GLEWINIT
  OGLM_CHECK_ERR(glColor4ubv, )
  GLubyte *v = OGLM_GET_VARARGS(v,0,GLubyte,UV,4);
  glColor4ubv((const GLubyte *)v);
  OGLM_CHECK_ERR(glColor4ubv, free(v);)
  free(v);

void
glColor4ui(red, green, blue, alpha)
  GLuint red;
  GLuint green;
  GLuint blue;
  GLuint alpha;
CODE:
  OGLM_GLEWINIT
  OGLM_CHECK_ERR(glColor4ui, )
  glColor4ui(red, green, blue, alpha);
  OGLM_CHECK_ERR(glColor4ui, )

void
glColor4uiv_c(v)
  const GLuint *v;
CODE:
  OGLM_GLEWINIT
  OGLM_CHECK_ERR(glColor4uiv, )
  glColor4uiv(v);
  OGLM_CHECK_ERR(glColor4uiv, )

void
glColor4uiv_p(...)
CODE:
  OGLM_GLEWINIT
  OGLM_CHECK_ERR(glColor4uiv, )
  GLuint *v = OGLM_GET_VARARGS(v,0,GLuint,UV,4);
  glColor4uiv((const GLuint *)v);
  OGLM_CHECK_ERR(glColor4uiv, free(v);)
  free(v);

void
glColor4us(red, green, blue, alpha)
  GLushort red;
  GLushort green;
  GLushort blue;
  GLushort alpha;
CODE:
  OGLM_GLEWINIT
  OGLM_CHECK_ERR(glColor4us, )
  glColor4us(red, green, blue, alpha);
  OGLM_CHECK_ERR(glColor4us, )

void
glColor4usv_c(v)
  const GLushort *v;
CODE:
  OGLM_GLEWINIT
  OGLM_CHECK_ERR(glColor4usv, )
  glColor4usv(v);
  OGLM_CHECK_ERR(glColor4usv, )

void
glColor4usv_p(...)
CODE:
  OGLM_GLEWINIT
  OGLM_CHECK_ERR(glColor4usv, )
  GLushort *v = OGLM_GET_VARARGS(v,0,GLushort,UV,4);
  glColor4usv((const GLushort *)v);
  OGLM_CHECK_ERR(glColor4usv, free(v);)
  free(v);

void
glColor4x(red, green, blue, alpha)
  GLfixed red;
  GLfixed green;
  GLfixed blue;
  GLfixed alpha;
CODE:
  OGLM_GLEWINIT
  OGLM_CHECK_ERR(glColor4x, )
  OGLM_AVAIL_CHECK(__glewColor4x, glColor4x)
  glColor4x(red, green, blue, alpha);
  OGLM_CHECK_ERR(glColor4x, )

void
glColorFormatNV(size, type, stride)
  GLint size;
  GLenum type;
  GLsizei stride;
CODE:
  OGLM_GLEWINIT
  OGLM_CHECK_ERR(glColorFormatNV, )
  OGLM_AVAIL_CHECK(__glewColorFormatNV, glColorFormatNV)
  glColorFormatNV(size, type, stride);
  OGLM_CHECK_ERR(glColorFormatNV, )

void
glColorFragmentOp1ATI(op, dst, dstMask, dstMod, arg1, arg1Rep, arg1Mod)
  GLenum op;
  GLuint dst;
  GLuint dstMask;
  GLuint dstMod;
  GLuint arg1;
  GLuint arg1Rep;
  GLuint arg1Mod;
CODE:
  OGLM_GLEWINIT
  OGLM_CHECK_ERR(glColorFragmentOp1ATI, )
  OGLM_AVAIL_CHECK(__glewColorFragmentOp1ATI, glColorFragmentOp1ATI)
  glColorFragmentOp1ATI(op, dst, dstMask, dstMod, arg1, arg1Rep, arg1Mod);
  OGLM_CHECK_ERR(glColorFragmentOp1ATI, )

void
glColorFragmentOp2ATI(op, dst, dstMask, dstMod, arg1, arg1Rep, arg1Mod, arg2, arg2Rep, arg2Mod)
  GLenum op;
  GLuint dst;
  GLuint dstMask;
  GLuint dstMod;
  GLuint arg1;
  GLuint arg1Rep;
  GLuint arg1Mod;
  GLuint arg2;
  GLuint arg2Rep;
  GLuint arg2Mod;
CODE:
  OGLM_GLEWINIT
  OGLM_CHECK_ERR(glColorFragmentOp2ATI, )
  OGLM_AVAIL_CHECK(__glewColorFragmentOp2ATI, glColorFragmentOp2ATI)
  glColorFragmentOp2ATI(op, dst, dstMask, dstMod, arg1, arg1Rep, arg1Mod, arg2, arg2Rep, arg2Mod);
  OGLM_CHECK_ERR(glColorFragmentOp2ATI, )

void
glColorFragmentOp3ATI(op, dst, dstMask, dstMod, arg1, arg1Rep, arg1Mod, arg2, arg2Rep, arg2Mod, arg3, arg3Rep, arg3Mod)
  GLenum op;
  GLuint dst;
  GLuint dstMask;
  GLuint dstMod;
  GLuint arg1;
  GLuint arg1Rep;
  GLuint arg1Mod;
  GLuint arg2;
  GLuint arg2Rep;
  GLuint arg2Mod;
  GLuint arg3;
  GLuint arg3Rep;
  GLuint arg3Mod;
CODE:
  OGLM_GLEWINIT
  OGLM_CHECK_ERR(glColorFragmentOp3ATI, )
  OGLM_AVAIL_CHECK(__glewColorFragmentOp3ATI, glColorFragmentOp3ATI)
  glColorFragmentOp3ATI(op, dst, dstMask, dstMod, arg1, arg1Rep, arg1Mod, arg2, arg2Rep, arg2Mod, arg3, arg3Rep, arg3Mod);
  OGLM_CHECK_ERR(glColorFragmentOp3ATI, )

void
glColorMask(red, green, blue, alpha)
  GLboolean red;
  GLboolean green;
  GLboolean blue;
  GLboolean alpha;
CODE:
  OGLM_GLEWINIT
  OGLM_CHECK_ERR(glColorMask, )
  glColorMask(red, green, blue, alpha);
  OGLM_CHECK_ERR(glColorMask, )

void
glColorMaski(buf, red, green, blue, alpha)
  GLuint buf;
  GLboolean red;
  GLboolean green;
  GLboolean blue;
  GLboolean alpha;
ALIAS:
  glColorMaskIndexedEXT = 1
  glColorMaskiEXT = 2
CODE:
  OGLM_GLEWINIT
  OGLM_CHECK_ERR(glColorMaski, )
  OGLM_AVAIL_CHECK(__glewColorMaski, glColorMaski)
  glColorMaski(buf, red, green, blue, alpha);
  OGLM_CHECK_ERR(glColorMaski, )

void
glColorMaskiOES(buf, r, g, b, a)
  GLuint buf;
  GLboolean r;
  GLboolean g;
  GLboolean b;
  GLboolean a;
CODE:
  OGLM_GLEWINIT
  OGLM_CHECK_ERR(glColorMaskiOES, )
  OGLM_AVAIL_CHECK(__glewColorMaskiOES, glColorMaskiOES)
  glColorMaskiOES(buf, r, g, b, a);
  OGLM_CHECK_ERR(glColorMaskiOES, )

void
glColorMaterial(face, mode)
  GLenum face;
  GLenum mode;
CODE:
  OGLM_GLEWINIT
  OGLM_CHECK_ERR(glColorMaterial, )
  glColorMaterial(face, mode);
  OGLM_CHECK_ERR(glColorMaterial, )

void
glColorP3ui(type, color)
  GLenum type;
  GLuint color;
CODE:
  OGLM_GLEWINIT
  OGLM_CHECK_ERR(glColorP3ui, )
  OGLM_AVAIL_CHECK(__glewColorP3ui, glColorP3ui)
  glColorP3ui(type, color);
  OGLM_CHECK_ERR(glColorP3ui, )

void
glColorP3uiv_c(type, color)
  GLenum type;
  const GLuint* color;
CODE:
  OGLM_GLEWINIT
  OGLM_CHECK_ERR(glColorP3uiv, )
  OGLM_AVAIL_CHECK(__glewColorP3uiv, glColorP3uiv)
  glColorP3uiv(type, color);
  OGLM_CHECK_ERR(glColorP3uiv, )

void
glColorP3uiv_p(type, ...)
  GLenum type;
CODE:
  OGLM_GLEWINIT
  OGLM_CHECK_ERR(glColorP3uiv, )
  OGLM_AVAIL_CHECK(__glewColorP3uiv, glColorP3uiv)
  GLuint* color = OGLM_GET_VARARGS(color,1,GLuint,UV,1);
  glColorP3uiv((GLenum )type, (const GLuint* )color);
  OGLM_CHECK_ERR(glColorP3uiv, free(color);)
  free(color);

void
glColorP4ui(type, color)
  GLenum type;
  GLuint color;
CODE:
  OGLM_GLEWINIT
  OGLM_CHECK_ERR(glColorP4ui, )
  OGLM_AVAIL_CHECK(__glewColorP4ui, glColorP4ui)
  glColorP4ui(type, color);
  OGLM_CHECK_ERR(glColorP4ui, )

void
glColorP4uiv_c(type, color)
  GLenum type;
  const GLuint* color;
CODE:
  OGLM_GLEWINIT
  OGLM_CHECK_ERR(glColorP4uiv, )
  OGLM_AVAIL_CHECK(__glewColorP4uiv, glColorP4uiv)
  glColorP4uiv(type, color);
  OGLM_CHECK_ERR(glColorP4uiv, )

void
glColorP4uiv_p(type, ...)
  GLenum type;
CODE:
  OGLM_GLEWINIT
  OGLM_CHECK_ERR(glColorP4uiv, )
  OGLM_AVAIL_CHECK(__glewColorP4uiv, glColorP4uiv)
  GLuint* color = OGLM_GET_VARARGS(color,1,GLuint,UV,1);
  glColorP4uiv((GLenum )type, (const GLuint* )color);
  OGLM_CHECK_ERR(glColorP4uiv, free(color);)
  free(color);

void
glColorPointer_c(size, type, stride, pointer)
  GLint size;
  GLenum type;
  GLsizei stride;
  const void *pointer;
CODE:
  OGLM_GLEWINIT
  OGLM_CHECK_ERR(glColorPointer, )
  glColorPointer(size, type, stride, pointer);
  OGLM_CHECK_ERR(glColorPointer, )

void
glColorPointerEXT_c(size, type, stride, count, pointer)
  GLint size;
  GLenum type;
  GLsizei stride;
  GLsizei count;
  const void *pointer;
CODE:
  OGLM_GLEWINIT
  OGLM_CHECK_ERR(glColorPointerEXT, )
  OGLM_AVAIL_CHECK(__glewColorPointerEXT, glColorPointerEXT)
  glColorPointerEXT(size, type, stride, count, pointer);
  OGLM_CHECK_ERR(glColorPointerEXT, )

void
glColorPointerListIBM_c(size, type, stride, pointer, ptrstride)
  GLint size;
  GLenum type;
  GLint stride;
  const void** pointer;
  GLint ptrstride;
CODE:
  OGLM_GLEWINIT
  OGLM_CHECK_ERR(glColorPointerListIBM, )
  OGLM_AVAIL_CHECK(__glewColorPointerListIBM, glColorPointerListIBM)
  glColorPointerListIBM(size, type, stride, pointer, ptrstride);
  OGLM_CHECK_ERR(glColorPointerListIBM, )

void
glColorPointervINTEL_c(size, type, pointer)
  GLint size;
  GLenum type;
  const void** pointer;
CODE:
  OGLM_GLEWINIT
  OGLM_CHECK_ERR(glColorPointervINTEL, )
  OGLM_AVAIL_CHECK(__glewColorPointervINTEL, glColorPointervINTEL)
  glColorPointervINTEL(size, type, pointer);
  OGLM_CHECK_ERR(glColorPointervINTEL, )

void
glColorSubTable_c(target, start, count, format, type, data)
  GLenum target;
  GLsizei start;
  GLsizei count;
  GLenum format;
  GLenum type;
  const void *data;
ALIAS:
  glColorSubTableEXT_c = 1
CODE:
  OGLM_GLEWINIT
  OGLM_CHECK_ERR(glColorSubTable, )
  OGLM_AVAIL_CHECK(__glewColorSubTable, glColorSubTable)
  glColorSubTable(target, start, count, format, type, data);
  OGLM_CHECK_ERR(glColorSubTable, )

void
glColorTable_c(target, internalformat, width, format, type, table)
  GLenum target;
  GLenum internalformat;
  GLsizei width;
  GLenum format;
  GLenum type;
  const void *table;
ALIAS:
  glColorTableEXT_c = 1
  glColorTableSGI_c = 2
CODE:
  OGLM_GLEWINIT
  OGLM_CHECK_ERR(glColorTable, )
  OGLM_AVAIL_CHECK(__glewColorTable, glColorTable)
  glColorTable(target, internalformat, width, format, type, table);
  OGLM_CHECK_ERR(glColorTable, )

void
glColorTableParameterfv_c(target, pname, params)
  GLenum target;
  GLenum pname;
  const GLfloat *params;
ALIAS:
  glColorTableParameterfvSGI_c = 1
CODE:
  OGLM_GLEWINIT
  OGLM_CHECK_ERR(glColorTableParameterfv, )
  OGLM_AVAIL_CHECK(__glewColorTableParameterfv, glColorTableParameterfv)
  glColorTableParameterfv(target, pname, params);
  OGLM_CHECK_ERR(glColorTableParameterfv, )

void
glColorTableParameterfv_p(target, pname, ...)
  GLenum target;
  GLenum pname;
ALIAS:
  glColorTableParameterfvSGI_p = 1
CODE:
  OGLM_GLEWINIT
  OGLM_CHECK_ERR(glColorTableParameterfv, )
  OGLM_AVAIL_CHECK(__glewColorTableParameterfv, glColorTableParameterfv)
  OGLM_SIZE_ENUM(ColorTableParameterPName,pname,1)
  GLfloat *params = OGLM_GET_VARARGS(params,2,GLfloat,NV,pname_count);
  glColorTableParameterfv((GLenum )target, (GLenum )pname, (const GLfloat *)params);
  OGLM_CHECK_ERR(glColorTableParameterfv, free(params);)
  free(params);

void
glColorTableParameteriv_c(target, pname, params)
  GLenum target;
  GLenum pname;
  const GLint *params;
ALIAS:
  glColorTableParameterivSGI_c = 1
CODE:
  OGLM_GLEWINIT
  OGLM_CHECK_ERR(glColorTableParameteriv, )
  OGLM_AVAIL_CHECK(__glewColorTableParameteriv, glColorTableParameteriv)
  glColorTableParameteriv(target, pname, params);
  OGLM_CHECK_ERR(glColorTableParameteriv, )

void
glColorTableParameteriv_p(target, pname, ...)
  GLenum target;
  GLenum pname;
ALIAS:
  glColorTableParameterivSGI_p = 1
CODE:
  OGLM_GLEWINIT
  OGLM_CHECK_ERR(glColorTableParameteriv, )
  OGLM_AVAIL_CHECK(__glewColorTableParameteriv, glColorTableParameteriv)
  OGLM_SIZE_ENUM(ColorTableParameterPName,pname,1)
  GLint *params = OGLM_GET_VARARGS(params,2,GLint,IV,pname_count);
  glColorTableParameteriv((GLenum )target, (GLenum )pname, (const GLint *)params);
  OGLM_CHECK_ERR(glColorTableParameteriv, free(params);)
  free(params);

void
glCombinerInputNV(stage, portion, variable, input, mapping, componentUsage)
  GLenum stage;
  GLenum portion;
  GLenum variable;
  GLenum input;
  GLenum mapping;
  GLenum componentUsage;
CODE:
  OGLM_GLEWINIT
  OGLM_CHECK_ERR(glCombinerInputNV, )
  OGLM_AVAIL_CHECK(__glewCombinerInputNV, glCombinerInputNV)
  glCombinerInputNV(stage, portion, variable, input, mapping, componentUsage);
  OGLM_CHECK_ERR(glCombinerInputNV, )

void
glCombinerOutputNV(stage, portion, abOutput, cdOutput, sumOutput, scale, bias, abDotProduct, cdDotProduct, muxSum)
  GLenum stage;
  GLenum portion;
  GLenum abOutput;
  GLenum cdOutput;
  GLenum sumOutput;
  GLenum scale;
  GLenum bias;
  GLboolean abDotProduct;
  GLboolean cdDotProduct;
  GLboolean muxSum;
CODE:
  OGLM_GLEWINIT
  OGLM_CHECK_ERR(glCombinerOutputNV, )
  OGLM_AVAIL_CHECK(__glewCombinerOutputNV, glCombinerOutputNV)
  glCombinerOutputNV(stage, portion, abOutput, cdOutput, sumOutput, scale, bias, abDotProduct, cdDotProduct, muxSum);
  OGLM_CHECK_ERR(glCombinerOutputNV, )

void
glCombinerParameterfNV(pname, param)
  GLenum pname;
  GLfloat param;
CODE:
  OGLM_GLEWINIT
  OGLM_CHECK_ERR(glCombinerParameterfNV, )
  OGLM_AVAIL_CHECK(__glewCombinerParameterfNV, glCombinerParameterfNV)
  glCombinerParameterfNV(pname, param);
  OGLM_CHECK_ERR(glCombinerParameterfNV, )

void
glCombinerParameterfvNV_c(pname, params)
  GLenum pname;
  const GLfloat* params;
CODE:
  OGLM_GLEWINIT
  OGLM_CHECK_ERR(glCombinerParameterfvNV, )
  OGLM_AVAIL_CHECK(__glewCombinerParameterfvNV, glCombinerParameterfvNV)
  glCombinerParameterfvNV(pname, params);
  OGLM_CHECK_ERR(glCombinerParameterfvNV, )

void
glCombinerParameteriNV(pname, param)
  GLenum pname;
  GLint param;
CODE:
  OGLM_GLEWINIT
  OGLM_CHECK_ERR(glCombinerParameteriNV, )
  OGLM_AVAIL_CHECK(__glewCombinerParameteriNV, glCombinerParameteriNV)
  glCombinerParameteriNV(pname, param);
  OGLM_CHECK_ERR(glCombinerParameteriNV, )

void
glCombinerParameterivNV_c(pname, params)
  GLenum pname;
  const GLint* params;
CODE:
  OGLM_GLEWINIT
  OGLM_CHECK_ERR(glCombinerParameterivNV, )
  OGLM_AVAIL_CHECK(__glewCombinerParameterivNV, glCombinerParameterivNV)
  glCombinerParameterivNV(pname, params);
  OGLM_CHECK_ERR(glCombinerParameterivNV, )

void
glCombinerStageParameterfvNV_c(stage, pname, params)
  GLenum stage;
  GLenum pname;
  const GLfloat* params;
CODE:
  OGLM_GLEWINIT
  OGLM_CHECK_ERR(glCombinerStageParameterfvNV, )
  OGLM_AVAIL_CHECK(__glewCombinerStageParameterfvNV, glCombinerStageParameterfvNV)
  glCombinerStageParameterfvNV(stage, pname, params);
  OGLM_CHECK_ERR(glCombinerStageParameterfvNV, )

void
glCommandListSegmentsNV(list, segments)
  GLuint list;
  GLuint segments;
CODE:
  OGLM_GLEWINIT
  OGLM_CHECK_ERR(glCommandListSegmentsNV, )
  OGLM_AVAIL_CHECK(__glewCommandListSegmentsNV, glCommandListSegmentsNV)
  glCommandListSegmentsNV(list, segments);
  OGLM_CHECK_ERR(glCommandListSegmentsNV, )

void
glCompileCommandListNV(list)
  GLuint list;
CODE:
  OGLM_GLEWINIT
  OGLM_CHECK_ERR(glCompileCommandListNV, )
  OGLM_AVAIL_CHECK(__glewCompileCommandListNV, glCompileCommandListNV)
  glCompileCommandListNV(list);
  OGLM_CHECK_ERR(glCompileCommandListNV, )

void
glCompileShader(shader)
  GLuint shader;
CODE:
  OGLM_GLEWINIT
  OGLM_CHECK_ERR(glCompileShader, )
  OGLM_AVAIL_CHECK(__glewCompileShader, glCompileShader)
  glCompileShader(shader);
  OGLM_CHECK_ERR(glCompileShader, )

void
glCompileShaderARB(shaderObj)
  GLhandleARB shaderObj;
CODE:
  OGLM_GLEWINIT
  OGLM_CHECK_ERR(glCompileShaderARB, )
  OGLM_AVAIL_CHECK(__glewCompileShaderARB, glCompileShaderARB)
  glCompileShaderARB(shaderObj);
  OGLM_CHECK_ERR(glCompileShaderARB, )

void
glCompileShaderIncludeARB_c(shader, count, path, length)
  GLuint shader;
  GLsizei count;
  const GLchar* const *path;
  const GLint *length;
CODE:
  OGLM_GLEWINIT
  OGLM_CHECK_ERR(glCompileShaderIncludeARB, )
  OGLM_AVAIL_CHECK(__glewCompileShaderIncludeARB, glCompileShaderIncludeARB)
  glCompileShaderIncludeARB(shader, count, path, length);
  OGLM_CHECK_ERR(glCompileShaderIncludeARB, )

void
glCompileShaderIncludeARB_p(shader, pathSV, lengthSV)
  GLuint shader;
  SV *pathSV;
  SV *lengthSV;
CODE:
  OGLM_GLEWINIT
  OGLM_CHECK_ERR(glCompileShaderIncludeARB, )
  OGLM_AVAIL_CHECK(__glewCompileShaderIncludeARB, glCompileShaderIncludeARB)
  GLsizei count = OGLM_LEN_ARRAY(count, path);
  GLint *length = OGLM_GET_ARRAY(length, GLint, IV, count);
  GLchar* *path = OGLM_GET_ARRAY(path, GLchar*, PV_nolen, count);
  glCompileShaderIncludeARB((GLuint )shader, (GLsizei )count, (const GLchar* const *)path, (const GLint *)length);
  OGLM_CHECK_ERR(glCompileShaderIncludeARB, free(length);free(path);)
  free(length);free(path);

void
glCompressedMultiTexImage1DEXT_c(texunit, target, level, internalformat, width, border, imageSize, bits)
  GLenum texunit;
  GLenum target;
  GLint level;
  GLenum internalformat;
  GLsizei width;
  GLint border;
  GLsizei imageSize;
  const void *bits;
CODE:
  OGLM_GLEWINIT
  OGLM_CHECK_ERR(glCompressedMultiTexImage1DEXT, )
  OGLM_AVAIL_CHECK(__glewCompressedMultiTexImage1DEXT, glCompressedMultiTexImage1DEXT)
  glCompressedMultiTexImage1DEXT(texunit, target, level, internalformat, width, border, imageSize, bits);
  OGLM_CHECK_ERR(glCompressedMultiTexImage1DEXT, )

void
glCompressedMultiTexImage2DEXT_c(texunit, target, level, internalformat, width, height, border, imageSize, bits)
  GLenum texunit;
  GLenum target;
  GLint level;
  GLenum internalformat;
  GLsizei width;
  GLsizei height;
  GLint border;
  GLsizei imageSize;
  const void *bits;
CODE:
  OGLM_GLEWINIT
  OGLM_CHECK_ERR(glCompressedMultiTexImage2DEXT, )
  OGLM_AVAIL_CHECK(__glewCompressedMultiTexImage2DEXT, glCompressedMultiTexImage2DEXT)
  glCompressedMultiTexImage2DEXT(texunit, target, level, internalformat, width, height, border, imageSize, bits);
  OGLM_CHECK_ERR(glCompressedMultiTexImage2DEXT, )

void
glCompressedMultiTexImage3DEXT_c(texunit, target, level, internalformat, width, height, depth, border, imageSize, bits)
  GLenum texunit;
  GLenum target;
  GLint level;
  GLenum internalformat;
  GLsizei width;
  GLsizei height;
  GLsizei depth;
  GLint border;
  GLsizei imageSize;
  const void *bits;
CODE:
  OGLM_GLEWINIT
  OGLM_CHECK_ERR(glCompressedMultiTexImage3DEXT, )
  OGLM_AVAIL_CHECK(__glewCompressedMultiTexImage3DEXT, glCompressedMultiTexImage3DEXT)
  glCompressedMultiTexImage3DEXT(texunit, target, level, internalformat, width, height, depth, border, imageSize, bits);
  OGLM_CHECK_ERR(glCompressedMultiTexImage3DEXT, )

void
glCompressedMultiTexSubImage1DEXT_c(texunit, target, level, xoffset, width, format, imageSize, bits)
  GLenum texunit;
  GLenum target;
  GLint level;
  GLint xoffset;
  GLsizei width;
  GLenum format;
  GLsizei imageSize;
  const void *bits;
CODE:
  OGLM_GLEWINIT
  OGLM_CHECK_ERR(glCompressedMultiTexSubImage1DEXT, )
  OGLM_AVAIL_CHECK(__glewCompressedMultiTexSubImage1DEXT, glCompressedMultiTexSubImage1DEXT)
  glCompressedMultiTexSubImage1DEXT(texunit, target, level, xoffset, width, format, imageSize, bits);
  OGLM_CHECK_ERR(glCompressedMultiTexSubImage1DEXT, )

void
glCompressedMultiTexSubImage2DEXT_c(texunit, target, level, xoffset, yoffset, width, height, format, imageSize, bits)
  GLenum texunit;
  GLenum target;
  GLint level;
  GLint xoffset;
  GLint yoffset;
  GLsizei width;
  GLsizei height;
  GLenum format;
  GLsizei imageSize;
  const void *bits;
CODE:
  OGLM_GLEWINIT
  OGLM_CHECK_ERR(glCompressedMultiTexSubImage2DEXT, )
  OGLM_AVAIL_CHECK(__glewCompressedMultiTexSubImage2DEXT, glCompressedMultiTexSubImage2DEXT)
  glCompressedMultiTexSubImage2DEXT(texunit, target, level, xoffset, yoffset, width, height, format, imageSize, bits);
  OGLM_CHECK_ERR(glCompressedMultiTexSubImage2DEXT, )

void
glCompressedMultiTexSubImage3DEXT_c(texunit, target, level, xoffset, yoffset, zoffset, width, height, depth, format, imageSize, bits)
  GLenum texunit;
  GLenum target;
  GLint level;
  GLint xoffset;
  GLint yoffset;
  GLint zoffset;
  GLsizei width;
  GLsizei height;
  GLsizei depth;
  GLenum format;
  GLsizei imageSize;
  const void *bits;
CODE:
  OGLM_GLEWINIT
  OGLM_CHECK_ERR(glCompressedMultiTexSubImage3DEXT, )
  OGLM_AVAIL_CHECK(__glewCompressedMultiTexSubImage3DEXT, glCompressedMultiTexSubImage3DEXT)
  glCompressedMultiTexSubImage3DEXT(texunit, target, level, xoffset, yoffset, zoffset, width, height, depth, format, imageSize, bits);
  OGLM_CHECK_ERR(glCompressedMultiTexSubImage3DEXT, )

void
glCompressedTexImage1D_c(target, level, internalformat, width, border, imageSize, data)
  GLenum target;
  GLint level;
  GLenum internalformat;
  GLsizei width;
  GLint border;
  GLsizei imageSize;
  const void *data;
ALIAS:
  glCompressedTexImage1DARB_c = 1
CODE:
  OGLM_GLEWINIT
  OGLM_CHECK_ERR(glCompressedTexImage1D, )
  OGLM_AVAIL_CHECK(__glewCompressedTexImage1D, glCompressedTexImage1D)
  glCompressedTexImage1D(target, level, internalformat, width, border, imageSize, data);
  OGLM_CHECK_ERR(glCompressedTexImage1D, )

void
glCompressedTexImage2D_c(target, level, internalformat, width, height, border, imageSize, data)
  GLenum target;
  GLint level;
  GLenum internalformat;
  GLsizei width;
  GLsizei height;
  GLint border;
  GLsizei imageSize;
  const void *data;
ALIAS:
  glCompressedTexImage2DARB_c = 1
CODE:
  OGLM_GLEWINIT
  OGLM_CHECK_ERR(glCompressedTexImage2D, )
  OGLM_AVAIL_CHECK(__glewCompressedTexImage2D, glCompressedTexImage2D)
  glCompressedTexImage2D(target, level, internalformat, width, height, border, imageSize, data);
  OGLM_CHECK_ERR(glCompressedTexImage2D, )

void
glCompressedTexImage3D_c(target, level, internalformat, width, height, depth, border, imageSize, data)
  GLenum target;
  GLint level;
  GLenum internalformat;
  GLsizei width;
  GLsizei height;
  GLsizei depth;
  GLint border;
  GLsizei imageSize;
  const void *data;
ALIAS:
  glCompressedTexImage3DARB_c = 1
CODE:
  OGLM_GLEWINIT
  OGLM_CHECK_ERR(glCompressedTexImage3D, )
  OGLM_AVAIL_CHECK(__glewCompressedTexImage3D, glCompressedTexImage3D)
  glCompressedTexImage3D(target, level, internalformat, width, height, depth, border, imageSize, data);
  OGLM_CHECK_ERR(glCompressedTexImage3D, )

void
glCompressedTexImage3DNV_c(target, level, internalformat, width, height, depth, border, imageSize, data)
  GLenum target;
  GLint level;
  GLenum internalformat;
  GLsizei width;
  GLsizei height;
  GLsizei depth;
  GLint border;
  GLsizei imageSize;
  const void *data;
CODE:
  OGLM_GLEWINIT
  OGLM_CHECK_ERR(glCompressedTexImage3DNV, )
  OGLM_AVAIL_CHECK(__glewCompressedTexImage3DNV, glCompressedTexImage3DNV)
  glCompressedTexImage3DNV(target, level, internalformat, width, height, depth, border, imageSize, data);
  OGLM_CHECK_ERR(glCompressedTexImage3DNV, )

void
glCompressedTexImage3DOES_c(target, level, internalformat, width, height, depth, border, imageSize, data)
  GLenum target;
  GLint level;
  GLenum internalformat;
  GLsizei width;
  GLsizei height;
  GLsizei depth;
  GLint border;
  GLsizei imageSize;
  const void *data;
CODE:
  OGLM_GLEWINIT
  OGLM_CHECK_ERR(glCompressedTexImage3DOES, )
  OGLM_AVAIL_CHECK(__glewCompressedTexImage3DOES, glCompressedTexImage3DOES)
  glCompressedTexImage3DOES(target, level, internalformat, width, height, depth, border, imageSize, data);
  OGLM_CHECK_ERR(glCompressedTexImage3DOES, )

void
glCompressedTexSubImage1D_c(target, level, xoffset, width, format, imageSize, data)
  GLenum target;
  GLint level;
  GLint xoffset;
  GLsizei width;
  GLenum format;
  GLsizei imageSize;
  const void *data;
ALIAS:
  glCompressedTexSubImage1DARB_c = 1
CODE:
  OGLM_GLEWINIT
  OGLM_CHECK_ERR(glCompressedTexSubImage1D, )
  OGLM_AVAIL_CHECK(__glewCompressedTexSubImage1D, glCompressedTexSubImage1D)
  glCompressedTexSubImage1D(target, level, xoffset, width, format, imageSize, data);
  OGLM_CHECK_ERR(glCompressedTexSubImage1D, )

void
glCompressedTexSubImage2D_c(target, level, xoffset, yoffset, width, height, format, imageSize, data)
  GLenum target;
  GLint level;
  GLint xoffset;
  GLint yoffset;
  GLsizei width;
  GLsizei height;
  GLenum format;
  GLsizei imageSize;
  const void *data;
ALIAS:
  glCompressedTexSubImage2DARB_c = 1
CODE:
  OGLM_GLEWINIT
  OGLM_CHECK_ERR(glCompressedTexSubImage2D, )
  OGLM_AVAIL_CHECK(__glewCompressedTexSubImage2D, glCompressedTexSubImage2D)
  glCompressedTexSubImage2D(target, level, xoffset, yoffset, width, height, format, imageSize, data);
  OGLM_CHECK_ERR(glCompressedTexSubImage2D, )

void
glCompressedTexSubImage3D_c(target, level, xoffset, yoffset, zoffset, width, height, depth, format, imageSize, data)
  GLenum target;
  GLint level;
  GLint xoffset;
  GLint yoffset;
  GLint zoffset;
  GLsizei width;
  GLsizei height;
  GLsizei depth;
  GLenum format;
  GLsizei imageSize;
  const void *data;
ALIAS:
  glCompressedTexSubImage3DARB_c = 1
CODE:
  OGLM_GLEWINIT
  OGLM_CHECK_ERR(glCompressedTexSubImage3D, )
  OGLM_AVAIL_CHECK(__glewCompressedTexSubImage3D, glCompressedTexSubImage3D)
  glCompressedTexSubImage3D(target, level, xoffset, yoffset, zoffset, width, height, depth, format, imageSize, data);
  OGLM_CHECK_ERR(glCompressedTexSubImage3D, )

void
glCompressedTexSubImage3DNV_c(target, level, xoffset, yoffset, zoffset, width, height, depth, format, imageSize, data)
  GLenum target;
  GLint level;
  GLint xoffset;
  GLint yoffset;
  GLint zoffset;
  GLsizei width;
  GLsizei height;
  GLsizei depth;
  GLenum format;
  GLsizei imageSize;
  const void *data;
CODE:
  OGLM_GLEWINIT
  OGLM_CHECK_ERR(glCompressedTexSubImage3DNV, )
  OGLM_AVAIL_CHECK(__glewCompressedTexSubImage3DNV, glCompressedTexSubImage3DNV)
  glCompressedTexSubImage3DNV(target, level, xoffset, yoffset, zoffset, width, height, depth, format, imageSize, data);
  OGLM_CHECK_ERR(glCompressedTexSubImage3DNV, )

void
glCompressedTexSubImage3DOES_c(target, level, xoffset, yoffset, zoffset, width, height, depth, format, imageSize, data)
  GLenum target;
  GLint level;
  GLint xoffset;
  GLint yoffset;
  GLint zoffset;
  GLsizei width;
  GLsizei height;
  GLsizei depth;
  GLenum format;
  GLsizei imageSize;
  const void *data;
CODE:
  OGLM_GLEWINIT
  OGLM_CHECK_ERR(glCompressedTexSubImage3DOES, )
  OGLM_AVAIL_CHECK(__glewCompressedTexSubImage3DOES, glCompressedTexSubImage3DOES)
  glCompressedTexSubImage3DOES(target, level, xoffset, yoffset, zoffset, width, height, depth, format, imageSize, data);
  OGLM_CHECK_ERR(glCompressedTexSubImage3DOES, )

void
glCompressedTextureImage1DEXT_c(texture, target, level, internalformat, width, border, imageSize, bits)
  GLuint texture;
  GLenum target;
  GLint level;
  GLenum internalformat;
  GLsizei width;
  GLint border;
  GLsizei imageSize;
  const void *bits;
CODE:
  OGLM_GLEWINIT
  OGLM_CHECK_ERR(glCompressedTextureImage1DEXT, )
  OGLM_AVAIL_CHECK(__glewCompressedTextureImage1DEXT, glCompressedTextureImage1DEXT)
  glCompressedTextureImage1DEXT(texture, target, level, internalformat, width, border, imageSize, bits);
  OGLM_CHECK_ERR(glCompressedTextureImage1DEXT, )

void
glCompressedTextureImage2DEXT_c(texture, target, level, internalformat, width, height, border, imageSize, bits)
  GLuint texture;
  GLenum target;
  GLint level;
  GLenum internalformat;
  GLsizei width;
  GLsizei height;
  GLint border;
  GLsizei imageSize;
  const void *bits;
CODE:
  OGLM_GLEWINIT
  OGLM_CHECK_ERR(glCompressedTextureImage2DEXT, )
  OGLM_AVAIL_CHECK(__glewCompressedTextureImage2DEXT, glCompressedTextureImage2DEXT)
  glCompressedTextureImage2DEXT(texture, target, level, internalformat, width, height, border, imageSize, bits);
  OGLM_CHECK_ERR(glCompressedTextureImage2DEXT, )

void
glCompressedTextureImage3DEXT_c(texture, target, level, internalformat, width, height, depth, border, imageSize, bits)
  GLuint texture;
  GLenum target;
  GLint level;
  GLenum internalformat;
  GLsizei width;
  GLsizei height;
  GLsizei depth;
  GLint border;
  GLsizei imageSize;
  const void *bits;
CODE:
  OGLM_GLEWINIT
  OGLM_CHECK_ERR(glCompressedTextureImage3DEXT, )
  OGLM_AVAIL_CHECK(__glewCompressedTextureImage3DEXT, glCompressedTextureImage3DEXT)
  glCompressedTextureImage3DEXT(texture, target, level, internalformat, width, height, depth, border, imageSize, bits);
  OGLM_CHECK_ERR(glCompressedTextureImage3DEXT, )

void
glCompressedTextureSubImage1D_c(texture, level, xoffset, width, format, imageSize, data)
  GLuint texture;
  GLint level;
  GLint xoffset;
  GLsizei width;
  GLenum format;
  GLsizei imageSize;
  const void *data;
CODE:
  OGLM_GLEWINIT
  OGLM_CHECK_ERR(glCompressedTextureSubImage1D, )
  OGLM_AVAIL_CHECK(__glewCompressedTextureSubImage1D, glCompressedTextureSubImage1D)
  glCompressedTextureSubImage1D(texture, level, xoffset, width, format, imageSize, data);
  OGLM_CHECK_ERR(glCompressedTextureSubImage1D, )

void
glCompressedTextureSubImage1DEXT_c(texture, target, level, xoffset, width, format, imageSize, bits)
  GLuint texture;
  GLenum target;
  GLint level;
  GLint xoffset;
  GLsizei width;
  GLenum format;
  GLsizei imageSize;
  const void *bits;
CODE:
  OGLM_GLEWINIT
  OGLM_CHECK_ERR(glCompressedTextureSubImage1DEXT, )
  OGLM_AVAIL_CHECK(__glewCompressedTextureSubImage1DEXT, glCompressedTextureSubImage1DEXT)
  glCompressedTextureSubImage1DEXT(texture, target, level, xoffset, width, format, imageSize, bits);
  OGLM_CHECK_ERR(glCompressedTextureSubImage1DEXT, )

void
glCompressedTextureSubImage2D_c(texture, level, xoffset, yoffset, width, height, format, imageSize, data)
  GLuint texture;
  GLint level;
  GLint xoffset;
  GLint yoffset;
  GLsizei width;
  GLsizei height;
  GLenum format;
  GLsizei imageSize;
  const void *data;
CODE:
  OGLM_GLEWINIT
  OGLM_CHECK_ERR(glCompressedTextureSubImage2D, )
  OGLM_AVAIL_CHECK(__glewCompressedTextureSubImage2D, glCompressedTextureSubImage2D)
  glCompressedTextureSubImage2D(texture, level, xoffset, yoffset, width, height, format, imageSize, data);
  OGLM_CHECK_ERR(glCompressedTextureSubImage2D, )

void
glCompressedTextureSubImage2DEXT_c(texture, target, level, xoffset, yoffset, width, height, format, imageSize, bits)
  GLuint texture;
  GLenum target;
  GLint level;
  GLint xoffset;
  GLint yoffset;
  GLsizei width;
  GLsizei height;
  GLenum format;
  GLsizei imageSize;
  const void *bits;
CODE:
  OGLM_GLEWINIT
  OGLM_CHECK_ERR(glCompressedTextureSubImage2DEXT, )
  OGLM_AVAIL_CHECK(__glewCompressedTextureSubImage2DEXT, glCompressedTextureSubImage2DEXT)
  glCompressedTextureSubImage2DEXT(texture, target, level, xoffset, yoffset, width, height, format, imageSize, bits);
  OGLM_CHECK_ERR(glCompressedTextureSubImage2DEXT, )

void
glCompressedTextureSubImage3D_c(texture, level, xoffset, yoffset, zoffset, width, height, depth, format, imageSize, data)
  GLuint texture;
  GLint level;
  GLint xoffset;
  GLint yoffset;
  GLint zoffset;
  GLsizei width;
  GLsizei height;
  GLsizei depth;
  GLenum format;
  GLsizei imageSize;
  const void *data;
CODE:
  OGLM_GLEWINIT
  OGLM_CHECK_ERR(glCompressedTextureSubImage3D, )
  OGLM_AVAIL_CHECK(__glewCompressedTextureSubImage3D, glCompressedTextureSubImage3D)
  glCompressedTextureSubImage3D(texture, level, xoffset, yoffset, zoffset, width, height, depth, format, imageSize, data);
  OGLM_CHECK_ERR(glCompressedTextureSubImage3D, )

void
glCompressedTextureSubImage3DEXT_c(texture, target, level, xoffset, yoffset, zoffset, width, height, depth, format, imageSize, bits)
  GLuint texture;
  GLenum target;
  GLint level;
  GLint xoffset;
  GLint yoffset;
  GLint zoffset;
  GLsizei width;
  GLsizei height;
  GLsizei depth;
  GLenum format;
  GLsizei imageSize;
  const void *bits;
CODE:
  OGLM_GLEWINIT
  OGLM_CHECK_ERR(glCompressedTextureSubImage3DEXT, )
  OGLM_AVAIL_CHECK(__glewCompressedTextureSubImage3DEXT, glCompressedTextureSubImage3DEXT)
  glCompressedTextureSubImage3DEXT(texture, target, level, xoffset, yoffset, zoffset, width, height, depth, format, imageSize, bits);
  OGLM_CHECK_ERR(glCompressedTextureSubImage3DEXT, )

void
glConservativeRasterParameterfNV(pname, value)
  GLenum pname;
  GLfloat value;
CODE:
  OGLM_GLEWINIT
  OGLM_CHECK_ERR(glConservativeRasterParameterfNV, )
  OGLM_AVAIL_CHECK(__glewConservativeRasterParameterfNV, glConservativeRasterParameterfNV)
  glConservativeRasterParameterfNV(pname, value);
  OGLM_CHECK_ERR(glConservativeRasterParameterfNV, )

void
glConservativeRasterParameteriNV(pname, param)
  GLenum pname;
  GLint param;
CODE:
  OGLM_GLEWINIT
  OGLM_CHECK_ERR(glConservativeRasterParameteriNV, )
  OGLM_AVAIL_CHECK(__glewConservativeRasterParameteriNV, glConservativeRasterParameteriNV)
  glConservativeRasterParameteriNV(pname, param);
  OGLM_CHECK_ERR(glConservativeRasterParameteriNV, )

void
glConvolutionFilter1D_c(target, internalformat, width, format, type, image)
  GLenum target;
  GLenum internalformat;
  GLsizei width;
  GLenum format;
  GLenum type;
  const void *image;
ALIAS:
  glConvolutionFilter1DEXT_c = 1
CODE:
  OGLM_GLEWINIT
  OGLM_CHECK_ERR(glConvolutionFilter1D, )
  OGLM_AVAIL_CHECK(__glewConvolutionFilter1D, glConvolutionFilter1D)
  glConvolutionFilter1D(target, internalformat, width, format, type, image);
  OGLM_CHECK_ERR(glConvolutionFilter1D, )

void
glConvolutionFilter2D_c(target, internalformat, width, height, format, type, image)
  GLenum target;
  GLenum internalformat;
  GLsizei width;
  GLsizei height;
  GLenum format;
  GLenum type;
  const void *image;
ALIAS:
  glConvolutionFilter2DEXT_c = 1
CODE:
  OGLM_GLEWINIT
  OGLM_CHECK_ERR(glConvolutionFilter2D, )
  OGLM_AVAIL_CHECK(__glewConvolutionFilter2D, glConvolutionFilter2D)
  glConvolutionFilter2D(target, internalformat, width, height, format, type, image);
  OGLM_CHECK_ERR(glConvolutionFilter2D, )

void
glConvolutionParameterf(target, pname, params)
  GLenum target;
  GLenum pname;
  GLfloat params;
ALIAS:
  glConvolutionParameterfEXT = 1
CODE:
  OGLM_GLEWINIT
  OGLM_CHECK_ERR(glConvolutionParameterf, )
  OGLM_AVAIL_CHECK(__glewConvolutionParameterf, glConvolutionParameterf)
  glConvolutionParameterf(target, pname, params);
  OGLM_CHECK_ERR(glConvolutionParameterf, )

void
glConvolutionParameterfv_c(target, pname, params)
  GLenum target;
  GLenum pname;
  const GLfloat *params;
ALIAS:
  glConvolutionParameterfvEXT_c = 1
CODE:
  OGLM_GLEWINIT
  OGLM_CHECK_ERR(glConvolutionParameterfv, )
  OGLM_AVAIL_CHECK(__glewConvolutionParameterfv, glConvolutionParameterfv)
  glConvolutionParameterfv(target, pname, params);
  OGLM_CHECK_ERR(glConvolutionParameterfv, )

void
glConvolutionParameterfv_p(target, pname, ...)
  GLenum target;
  GLenum pname;
ALIAS:
  glConvolutionParameterfvEXT_p = 1
CODE:
  OGLM_GLEWINIT
  OGLM_CHECK_ERR(glConvolutionParameterfv, )
  OGLM_AVAIL_CHECK(__glewConvolutionParameterfv, glConvolutionParameterfv)
  OGLM_SIZE_ENUM(ConvolutionParameter,pname,1)
  GLfloat *params = OGLM_GET_VARARGS(params,2,GLfloat,NV,pname_count);
  glConvolutionParameterfv((GLenum )target, (GLenum )pname, (const GLfloat *)params);
  OGLM_CHECK_ERR(glConvolutionParameterfv, free(params);)
  free(params);

void
glConvolutionParameteri(target, pname, params)
  GLenum target;
  GLenum pname;
  GLint params;
ALIAS:
  glConvolutionParameteriEXT = 1
CODE:
  OGLM_GLEWINIT
  OGLM_CHECK_ERR(glConvolutionParameteri, )
  OGLM_AVAIL_CHECK(__glewConvolutionParameteri, glConvolutionParameteri)
  glConvolutionParameteri(target, pname, params);
  OGLM_CHECK_ERR(glConvolutionParameteri, )

void
glConvolutionParameteriv_c(target, pname, params)
  GLenum target;
  GLenum pname;
  const GLint *params;
ALIAS:
  glConvolutionParameterivEXT_c = 1
CODE:
  OGLM_GLEWINIT
  OGLM_CHECK_ERR(glConvolutionParameteriv, )
  OGLM_AVAIL_CHECK(__glewConvolutionParameteriv, glConvolutionParameteriv)
  glConvolutionParameteriv(target, pname, params);
  OGLM_CHECK_ERR(glConvolutionParameteriv, )

void
glConvolutionParameteriv_p(target, pname, ...)
  GLenum target;
  GLenum pname;
ALIAS:
  glConvolutionParameterivEXT_p = 1
CODE:
  OGLM_GLEWINIT
  OGLM_CHECK_ERR(glConvolutionParameteriv, )
  OGLM_AVAIL_CHECK(__glewConvolutionParameteriv, glConvolutionParameteriv)
  OGLM_SIZE_ENUM(ConvolutionParameter,pname,1)
  GLint *params = OGLM_GET_VARARGS(params,2,GLint,IV,pname_count);
  glConvolutionParameteriv((GLenum )target, (GLenum )pname, (const GLint *)params);
  OGLM_CHECK_ERR(glConvolutionParameteriv, free(params);)
  free(params);

void
glCopyBufferSubData(readTarget, writeTarget, readOffset, writeOffset, size)
  GLenum readTarget;
  GLenum writeTarget;
  GLintptr readOffset;
  GLintptr writeOffset;
  GLsizeiptr size;
ALIAS:
  glCopyBufferSubDataNV = 1
CODE:
  OGLM_GLEWINIT
  OGLM_CHECK_ERR(glCopyBufferSubData, )
  OGLM_AVAIL_CHECK(__glewCopyBufferSubData, glCopyBufferSubData)
  glCopyBufferSubData(readTarget, writeTarget, readOffset, writeOffset, size);
  OGLM_CHECK_ERR(glCopyBufferSubData, )

void
glCopyColorSubTable(target, start, x, y, width)
  GLenum target;
  GLsizei start;
  GLint x;
  GLint y;
  GLsizei width;
ALIAS:
  glCopyColorSubTableEXT = 1
CODE:
  OGLM_GLEWINIT
  OGLM_CHECK_ERR(glCopyColorSubTable, )
  OGLM_AVAIL_CHECK(__glewCopyColorSubTable, glCopyColorSubTable)
  glCopyColorSubTable(target, start, x, y, width);
  OGLM_CHECK_ERR(glCopyColorSubTable, )

void
glCopyColorTable(target, internalformat, x, y, width)
  GLenum target;
  GLenum internalformat;
  GLint x;
  GLint y;
  GLsizei width;
ALIAS:
  glCopyColorTableSGI = 1
CODE:
  OGLM_GLEWINIT
  OGLM_CHECK_ERR(glCopyColorTable, )
  OGLM_AVAIL_CHECK(__glewCopyColorTable, glCopyColorTable)
  glCopyColorTable(target, internalformat, x, y, width);
  OGLM_CHECK_ERR(glCopyColorTable, )

void
glCopyConvolutionFilter1D(target, internalformat, x, y, width)
  GLenum target;
  GLenum internalformat;
  GLint x;
  GLint y;
  GLsizei width;
ALIAS:
  glCopyConvolutionFilter1DEXT = 1
CODE:
  OGLM_GLEWINIT
  OGLM_CHECK_ERR(glCopyConvolutionFilter1D, )
  OGLM_AVAIL_CHECK(__glewCopyConvolutionFilter1D, glCopyConvolutionFilter1D)
  glCopyConvolutionFilter1D(target, internalformat, x, y, width);
  OGLM_CHECK_ERR(glCopyConvolutionFilter1D, )

void
glCopyConvolutionFilter2D(target, internalformat, x, y, width, height)
  GLenum target;
  GLenum internalformat;
  GLint x;
  GLint y;
  GLsizei width;
  GLsizei height;
ALIAS:
  glCopyConvolutionFilter2DEXT = 1
CODE:
  OGLM_GLEWINIT
  OGLM_CHECK_ERR(glCopyConvolutionFilter2D, )
  OGLM_AVAIL_CHECK(__glewCopyConvolutionFilter2D, glCopyConvolutionFilter2D)
  glCopyConvolutionFilter2D(target, internalformat, x, y, width, height);
  OGLM_CHECK_ERR(glCopyConvolutionFilter2D, )

void
glCopyImageSubData(srcName, srcTarget, srcLevel, srcX, srcY, srcZ, dstName, dstTarget, dstLevel, dstX, dstY, dstZ, srcWidth, srcHeight, srcDepth)
  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;
ALIAS:
  glCopyImageSubDataEXT = 1
CODE:
  OGLM_GLEWINIT
  OGLM_CHECK_ERR(glCopyImageSubData, )
  OGLM_AVAIL_CHECK(__glewCopyImageSubData, glCopyImageSubData)
  glCopyImageSubData(srcName, srcTarget, srcLevel, srcX, srcY, srcZ, dstName, dstTarget, dstLevel, dstX, dstY, dstZ, srcWidth, srcHeight, srcDepth);
  OGLM_CHECK_ERR(glCopyImageSubData, )

void
glCopyImageSubDataNV(srcName, srcTarget, srcLevel, srcX, srcY, srcZ, dstName, dstTarget, dstLevel, dstX, dstY, dstZ, width, height, depth)
  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 width;
  GLsizei height;
  GLsizei depth;
CODE:
  OGLM_GLEWINIT
  OGLM_CHECK_ERR(glCopyImageSubDataNV, )
  OGLM_AVAIL_CHECK(__glewCopyImageSubDataNV, glCopyImageSubDataNV)
  glCopyImageSubDataNV(srcName, srcTarget, srcLevel, srcX, srcY, srcZ, dstName, dstTarget, dstLevel, dstX, dstY, dstZ, width, height, depth);
  OGLM_CHECK_ERR(glCopyImageSubDataNV, )

void
glCopyImageSubDataOES(srcName, srcTarget, srcLevel, srcX, srcY, srcZ, dstName, dstTarget, dstLevel, dstX, dstY, dstZ, srcWidth, srcHeight, srcDepth)
  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;
CODE:
  OGLM_GLEWINIT
  OGLM_CHECK_ERR(glCopyImageSubDataOES, )
  OGLM_AVAIL_CHECK(__glewCopyImageSubDataOES, glCopyImageSubDataOES)
  glCopyImageSubDataOES(srcName, srcTarget, srcLevel, srcX, srcY, srcZ, dstName, dstTarget, dstLevel, dstX, dstY, dstZ, srcWidth, srcHeight, srcDepth);
  OGLM_CHECK_ERR(glCopyImageSubDataOES, )

void
glCopyMultiTexImage1DEXT(texunit, target, level, internalformat, x, y, width, border)
  GLenum texunit;
  GLenum target;
  GLint level;
  GLenum internalformat;
  GLint x;
  GLint y;
  GLsizei width;
  GLint border;
CODE:
  OGLM_GLEWINIT
  OGLM_CHECK_ERR(glCopyMultiTexImage1DEXT, )
  OGLM_AVAIL_CHECK(__glewCopyMultiTexImage1DEXT, glCopyMultiTexImage1DEXT)
  glCopyMultiTexImage1DEXT(texunit, target, level, internalformat, x, y, width, border);
  OGLM_CHECK_ERR(glCopyMultiTexImage1DEXT, )

void
glCopyMultiTexImage2DEXT(texunit, target, level, internalformat, x, y, width, height, border)
  GLenum texunit;
  GLenum target;
  GLint level;
  GLenum internalformat;
  GLint x;
  GLint y;
  GLsizei width;
  GLsizei height;
  GLint border;
CODE:
  OGLM_GLEWINIT
  OGLM_CHECK_ERR(glCopyMultiTexImage2DEXT, )
  OGLM_AVAIL_CHECK(__glewCopyMultiTexImage2DEXT, glCopyMultiTexImage2DEXT)
  glCopyMultiTexImage2DEXT(texunit, target, level, internalformat, x, y, width, height, border);
  OGLM_CHECK_ERR(glCopyMultiTexImage2DEXT, )

void
glCopyMultiTexSubImage1DEXT(texunit, target, level, xoffset, x, y, width)
  GLenum texunit;
  GLenum target;
  GLint level;
  GLint xoffset;
  GLint x;
  GLint y;
  GLsizei width;
CODE:
  OGLM_GLEWINIT
  OGLM_CHECK_ERR(glCopyMultiTexSubImage1DEXT, )
  OGLM_AVAIL_CHECK(__glewCopyMultiTexSubImage1DEXT, glCopyMultiTexSubImage1DEXT)
  glCopyMultiTexSubImage1DEXT(texunit, target, level, xoffset, x, y, width);
  OGLM_CHECK_ERR(glCopyMultiTexSubImage1DEXT, )

void
glCopyMultiTexSubImage2DEXT(texunit, target, level, xoffset, yoffset, x, y, width, height)
  GLenum texunit;
  GLenum target;
  GLint level;
  GLint xoffset;
  GLint yoffset;
  GLint x;
  GLint y;
  GLsizei width;
  GLsizei height;
CODE:
  OGLM_GLEWINIT
  OGLM_CHECK_ERR(glCopyMultiTexSubImage2DEXT, )
  OGLM_AVAIL_CHECK(__glewCopyMultiTexSubImage2DEXT, glCopyMultiTexSubImage2DEXT)
  glCopyMultiTexSubImage2DEXT(texunit, target, level, xoffset, yoffset, x, y, width, height);
  OGLM_CHECK_ERR(glCopyMultiTexSubImage2DEXT, )

void
glCopyMultiTexSubImage3DEXT(texunit, target, level, xoffset, yoffset, zoffset, x, y, width, height)
  GLenum texunit;
  GLenum target;
  GLint level;
  GLint xoffset;
  GLint yoffset;
  GLint zoffset;
  GLint x;
  GLint y;
  GLsizei width;
  GLsizei height;
CODE:
  OGLM_GLEWINIT
  OGLM_CHECK_ERR(glCopyMultiTexSubImage3DEXT, )
  OGLM_AVAIL_CHECK(__glewCopyMultiTexSubImage3DEXT, glCopyMultiTexSubImage3DEXT)
  glCopyMultiTexSubImage3DEXT(texunit, target, level, xoffset, yoffset, zoffset, x, y, width, height);
  OGLM_CHECK_ERR(glCopyMultiTexSubImage3DEXT, )

void
glCopyNamedBufferSubData(readBuffer, writeBuffer, readOffset, writeOffset, size)
  GLuint readBuffer;
  GLuint writeBuffer;
  GLintptr readOffset;
  GLintptr writeOffset;
  GLsizeiptr size;
CODE:
  OGLM_GLEWINIT
  OGLM_CHECK_ERR(glCopyNamedBufferSubData, )
  OGLM_AVAIL_CHECK(__glewCopyNamedBufferSubData, glCopyNamedBufferSubData)
  glCopyNamedBufferSubData(readBuffer, writeBuffer, readOffset, writeOffset, size);
  OGLM_CHECK_ERR(glCopyNamedBufferSubData, )

void
glCopyPathNV(resultPath, srcPath)
  GLuint resultPath;
  GLuint srcPath;
CODE:
  OGLM_GLEWINIT
  OGLM_CHECK_ERR(glCopyPathNV, )
  OGLM_AVAIL_CHECK(__glewCopyPathNV, glCopyPathNV)
  glCopyPathNV(resultPath, srcPath);
  OGLM_CHECK_ERR(glCopyPathNV, )

void
glCopyPixels(x, y, width, height, type)
  GLint x;
  GLint y;
  GLsizei width;
  GLsizei height;
  GLenum type;
CODE:
  OGLM_GLEWINIT
  OGLM_CHECK_ERR(glCopyPixels, )
  glCopyPixels(x, y, width, height, type);
  OGLM_CHECK_ERR(glCopyPixels, )

void
glCopyTexImage1D(target, level, internalformat, x, y, width, border)
  GLenum target;
  GLint level;
  GLenum internalformat;
  GLint x;
  GLint y;
  GLsizei width;
  GLint border;
ALIAS:
  glCopyTexImage1DEXT = 1
CODE:
  OGLM_GLEWINIT
  OGLM_CHECK_ERR(glCopyTexImage1D, )
  glCopyTexImage1D(target, level, internalformat, x, y, width, border);
  OGLM_CHECK_ERR(glCopyTexImage1D, )

void
glCopyTexImage2D(target, level, internalformat, x, y, width, height, border)
  GLenum target;
  GLint level;
  GLenum internalformat;
  GLint x;
  GLint y;
  GLsizei width;
  GLsizei height;
  GLint border;
ALIAS:
  glCopyTexImage2DEXT = 1
CODE:
  OGLM_GLEWINIT
  OGLM_CHECK_ERR(glCopyTexImage2D, )
  glCopyTexImage2D(target, level, internalformat, x, y, width, height, border);
  OGLM_CHECK_ERR(glCopyTexImage2D, )

void
glCopyTexSubImage1D(target, level, xoffset, x, y, width)
  GLenum target;
  GLint level;
  GLint xoffset;
  GLint x;
  GLint y;
  GLsizei width;
ALIAS:
  glCopyTexSubImage1DEXT = 1
CODE:
  OGLM_GLEWINIT
  OGLM_CHECK_ERR(glCopyTexSubImage1D, )
  glCopyTexSubImage1D(target, level, xoffset, x, y, width);
  OGLM_CHECK_ERR(glCopyTexSubImage1D, )

void
glCopyTexSubImage2D(target, level, xoffset, yoffset, x, y, width, height)
  GLenum target;
  GLint level;
  GLint xoffset;
  GLint yoffset;
  GLint x;
  GLint y;
  GLsizei width;
  GLsizei height;
ALIAS:
  glCopyTexSubImage2DEXT = 1
CODE:
  OGLM_GLEWINIT
  OGLM_CHECK_ERR(glCopyTexSubImage2D, )
  glCopyTexSubImage2D(target, level, xoffset, yoffset, x, y, width, height);
  OGLM_CHECK_ERR(glCopyTexSubImage2D, )

void
glCopyTexSubImage3D(target, level, xoffset, yoffset, zoffset, x, y, width, height)
  GLenum target;
  GLint level;
  GLint xoffset;
  GLint yoffset;
  GLint zoffset;
  GLint x;
  GLint y;
  GLsizei width;
  GLsizei height;
ALIAS:
  glCopyTexSubImage3DEXT = 1
CODE:
  OGLM_GLEWINIT
  OGLM_CHECK_ERR(glCopyTexSubImage3D, )
  OGLM_AVAIL_CHECK(__glewCopyTexSubImage3D, glCopyTexSubImage3D)
  glCopyTexSubImage3D(target, level, xoffset, yoffset, zoffset, x, y, width, height);
  OGLM_CHECK_ERR(glCopyTexSubImage3D, )

void
glCopyTexSubImage3DNV(target, level, xoffset, yoffset, zoffset, x, y, width, height)
  GLenum target;
  GLint level;
  GLint xoffset;
  GLint yoffset;
  GLint zoffset;
  GLint x;
  GLint y;
  GLsizei width;
  GLsizei height;
CODE:
  OGLM_GLEWINIT
  OGLM_CHECK_ERR(glCopyTexSubImage3DNV, )
  OGLM_AVAIL_CHECK(__glewCopyTexSubImage3DNV, glCopyTexSubImage3DNV)
  glCopyTexSubImage3DNV(target, level, xoffset, yoffset, zoffset, x, y, width, height);
  OGLM_CHECK_ERR(glCopyTexSubImage3DNV, )

void
glCopyTexSubImage3DOES(target, level, xoffset, yoffset, zoffset, x, y, width, height)
  GLenum target;
  GLint level;
  GLint xoffset;
  GLint yoffset;
  GLint zoffset;
  GLint x;
  GLint y;
  GLsizei width;
  GLsizei height;
CODE:
  OGLM_GLEWINIT
  OGLM_CHECK_ERR(glCopyTexSubImage3DOES, )
  OGLM_AVAIL_CHECK(__glewCopyTexSubImage3DOES, glCopyTexSubImage3DOES)
  glCopyTexSubImage3DOES(target, level, xoffset, yoffset, zoffset, x, y, width, height);
  OGLM_CHECK_ERR(glCopyTexSubImage3DOES, )

void
glCopyTextureImage1DEXT(texture, target, level, internalformat, x, y, width, border)
  GLuint texture;
  GLenum target;
  GLint level;
  GLenum internalformat;
  GLint x;
  GLint y;
  GLsizei width;
  GLint border;
CODE:
  OGLM_GLEWINIT
  OGLM_CHECK_ERR(glCopyTextureImage1DEXT, )
  OGLM_AVAIL_CHECK(__glewCopyTextureImage1DEXT, glCopyTextureImage1DEXT)
  glCopyTextureImage1DEXT(texture, target, level, internalformat, x, y, width, border);
  OGLM_CHECK_ERR(glCopyTextureImage1DEXT, )

void
glCopyTextureImage2DEXT(texture, target, level, internalformat, x, y, width, height, border)
  GLuint texture;
  GLenum target;
  GLint level;
  GLenum internalformat;
  GLint x;
  GLint y;
  GLsizei width;
  GLsizei height;
  GLint border;
CODE:
  OGLM_GLEWINIT
  OGLM_CHECK_ERR(glCopyTextureImage2DEXT, )
  OGLM_AVAIL_CHECK(__glewCopyTextureImage2DEXT, glCopyTextureImage2DEXT)
  glCopyTextureImage2DEXT(texture, target, level, internalformat, x, y, width, height, border);
  OGLM_CHECK_ERR(glCopyTextureImage2DEXT, )

void
glCopyTextureLevelsAPPLE(destinationTexture, sourceTexture, sourceBaseLevel, sourceLevelCount)
  GLuint destinationTexture;
  GLuint sourceTexture;
  GLint sourceBaseLevel;
  GLsizei sourceLevelCount;
CODE:
  OGLM_GLEWINIT
  OGLM_CHECK_ERR(glCopyTextureLevelsAPPLE, )
  OGLM_AVAIL_CHECK(__glewCopyTextureLevelsAPPLE, glCopyTextureLevelsAPPLE)
  glCopyTextureLevelsAPPLE(destinationTexture, sourceTexture, sourceBaseLevel, sourceLevelCount);
  OGLM_CHECK_ERR(glCopyTextureLevelsAPPLE, )

void
glCopyTextureSubImage1D(texture, level, xoffset, x, y, width)
  GLuint texture;
  GLint level;
  GLint xoffset;
  GLint x;
  GLint y;
  GLsizei width;
CODE:
  OGLM_GLEWINIT
  OGLM_CHECK_ERR(glCopyTextureSubImage1D, )
  OGLM_AVAIL_CHECK(__glewCopyTextureSubImage1D, glCopyTextureSubImage1D)
  glCopyTextureSubImage1D(texture, level, xoffset, x, y, width);
  OGLM_CHECK_ERR(glCopyTextureSubImage1D, )

void
glCopyTextureSubImage1DEXT(texture, target, level, xoffset, x, y, width)
  GLuint texture;
  GLenum target;
  GLint level;
  GLint xoffset;
  GLint x;
  GLint y;
  GLsizei width;
CODE:
  OGLM_GLEWINIT
  OGLM_CHECK_ERR(glCopyTextureSubImage1DEXT, )
  OGLM_AVAIL_CHECK(__glewCopyTextureSubImage1DEXT, glCopyTextureSubImage1DEXT)
  glCopyTextureSubImage1DEXT(texture, target, level, xoffset, x, y, width);
  OGLM_CHECK_ERR(glCopyTextureSubImage1DEXT, )

void
glCopyTextureSubImage2D(texture, level, xoffset, yoffset, x, y, width, height)
  GLuint texture;
  GLint level;
  GLint xoffset;
  GLint yoffset;
  GLint x;
  GLint y;
  GLsizei width;
  GLsizei height;
CODE:
  OGLM_GLEWINIT
  OGLM_CHECK_ERR(glCopyTextureSubImage2D, )
  OGLM_AVAIL_CHECK(__glewCopyTextureSubImage2D, glCopyTextureSubImage2D)
  glCopyTextureSubImage2D(texture, level, xoffset, yoffset, x, y, width, height);
  OGLM_CHECK_ERR(glCopyTextureSubImage2D, )

void
glCopyTextureSubImage2DEXT(texture, target, level, xoffset, yoffset, x, y, width, height)
  GLuint texture;
  GLenum target;
  GLint level;
  GLint xoffset;
  GLint yoffset;
  GLint x;
  GLint y;
  GLsizei width;
  GLsizei height;
CODE:
  OGLM_GLEWINIT
  OGLM_CHECK_ERR(glCopyTextureSubImage2DEXT, )
  OGLM_AVAIL_CHECK(__glewCopyTextureSubImage2DEXT, glCopyTextureSubImage2DEXT)
  glCopyTextureSubImage2DEXT(texture, target, level, xoffset, yoffset, x, y, width, height);
  OGLM_CHECK_ERR(glCopyTextureSubImage2DEXT, )

void
glCopyTextureSubImage3D(texture, level, xoffset, yoffset, zoffset, x, y, width, height)
  GLuint texture;
  GLint level;
  GLint xoffset;
  GLint yoffset;
  GLint zoffset;
  GLint x;
  GLint y;
  GLsizei width;
  GLsizei height;
CODE:
  OGLM_GLEWINIT
  OGLM_CHECK_ERR(glCopyTextureSubImage3D, )
  OGLM_AVAIL_CHECK(__glewCopyTextureSubImage3D, glCopyTextureSubImage3D)
  glCopyTextureSubImage3D(texture, level, xoffset, yoffset, zoffset, x, y, width, height);
  OGLM_CHECK_ERR(glCopyTextureSubImage3D, )

void
glCopyTextureSubImage3DEXT(texture, target, level, xoffset, yoffset, zoffset, x, y, width, height)
  GLuint texture;
  GLenum target;
  GLint level;
  GLint xoffset;
  GLint yoffset;
  GLint zoffset;
  GLint x;
  GLint y;
  GLsizei width;
  GLsizei height;
CODE:
  OGLM_GLEWINIT
  OGLM_CHECK_ERR(glCopyTextureSubImage3DEXT, )
  OGLM_AVAIL_CHECK(__glewCopyTextureSubImage3DEXT, glCopyTextureSubImage3DEXT)
  glCopyTextureSubImage3DEXT(texture, target, level, xoffset, yoffset, zoffset, x, y, width, height);
  OGLM_CHECK_ERR(glCopyTextureSubImage3DEXT, )

void
glCoverFillPathInstancedNV_c(numPaths, pathNameType, paths, pathBase, coverMode, transformType, transformValues)
  GLsizei numPaths;
  GLenum pathNameType;
  const void *paths;
  GLuint pathBase;
  GLenum coverMode;
  GLenum transformType;
  const GLfloat *transformValues;
CODE:
  OGLM_GLEWINIT
  OGLM_CHECK_ERR(glCoverFillPathInstancedNV, )
  OGLM_AVAIL_CHECK(__glewCoverFillPathInstancedNV, glCoverFillPathInstancedNV)
  glCoverFillPathInstancedNV(numPaths, pathNameType, paths, pathBase, coverMode, transformType, transformValues);
  OGLM_CHECK_ERR(glCoverFillPathInstancedNV, )

void
glCoverFillPathNV(path, coverMode)
  GLuint path;
  GLenum coverMode;
CODE:
  OGLM_GLEWINIT
  OGLM_CHECK_ERR(glCoverFillPathNV, )
  OGLM_AVAIL_CHECK(__glewCoverFillPathNV, glCoverFillPathNV)
  glCoverFillPathNV(path, coverMode);
  OGLM_CHECK_ERR(glCoverFillPathNV, )

void
glCoverStrokePathInstancedNV_c(numPaths, pathNameType, paths, pathBase, coverMode, transformType, transformValues)
  GLsizei numPaths;
  GLenum pathNameType;
  const void *paths;
  GLuint pathBase;
  GLenum coverMode;
  GLenum transformType;
  const GLfloat *transformValues;
CODE:
  OGLM_GLEWINIT
  OGLM_CHECK_ERR(glCoverStrokePathInstancedNV, )
  OGLM_AVAIL_CHECK(__glewCoverStrokePathInstancedNV, glCoverStrokePathInstancedNV)
  glCoverStrokePathInstancedNV(numPaths, pathNameType, paths, pathBase, coverMode, transformType, transformValues);
  OGLM_CHECK_ERR(glCoverStrokePathInstancedNV, )

void
glCoverStrokePathNV(path, coverMode)
  GLuint path;
  GLenum coverMode;
CODE:
  OGLM_GLEWINIT
  OGLM_CHECK_ERR(glCoverStrokePathNV, )
  OGLM_AVAIL_CHECK(__glewCoverStrokePathNV, glCoverStrokePathNV)
  glCoverStrokePathNV(path, coverMode);
  OGLM_CHECK_ERR(glCoverStrokePathNV, )

void
glCoverageModulationNV(components)
  GLenum components;
CODE:
  OGLM_GLEWINIT
  OGLM_CHECK_ERR(glCoverageModulationNV, )
  OGLM_AVAIL_CHECK(__glewCoverageModulationNV, glCoverageModulationNV)
  glCoverageModulationNV(components);
  OGLM_CHECK_ERR(glCoverageModulationNV, )

void
glCoverageModulationTableNV_c(n, v)
  GLsizei n;
  const GLfloat* v;
CODE:
  OGLM_GLEWINIT
  OGLM_CHECK_ERR(glCoverageModulationTableNV, )
  OGLM_AVAIL_CHECK(__glewCoverageModulationTableNV, glCoverageModulationTableNV)
  glCoverageModulationTableNV(n, v);
  OGLM_CHECK_ERR(glCoverageModulationTableNV, )

void
glCoverageModulationTableNV_p(...)
CODE:
  OGLM_GLEWINIT
  OGLM_CHECK_ERR(glCoverageModulationTableNV, )
  OGLM_AVAIL_CHECK(__glewCoverageModulationTableNV, glCoverageModulationTableNV)
  GLsizei n = items;
  GLfloat* v = OGLM_GET_VARARGS(v,0,GLfloat,NV,n);
  glCoverageModulationTableNV((GLsizei )n, (const GLfloat* )v);
  OGLM_CHECK_ERR(glCoverageModulationTableNV, free(v);)
  free(v);

void
glCreateBuffers_c(n, buffers)
  GLsizei n;
  GLuint* buffers;
CODE:
  OGLM_GLEWINIT
  OGLM_CHECK_ERR(glCreateBuffers, )
  OGLM_AVAIL_CHECK(__glewCreateBuffers, glCreateBuffers)
  glCreateBuffers(n, buffers);
  OGLM_CHECK_ERR(glCreateBuffers, )

void
glCreateBuffers_p(n)
  GLsizei n;
PPCODE:
  OGLM_GLEWINIT
  OGLM_CHECK_ERR(glCreateBuffers, )
  OGLM_AVAIL_CHECK(__glewCreateBuffers, glCreateBuffers)
  GLuint* buffers = OGLM_ALLOC(n,GLuint,buffers);
  glCreateBuffers(n, buffers);
  OGLM_CHECK_ERR(glCreateBuffers, free(buffers);)
  OGLM_OUT_FINISH(buffers,n,newSVuv)
  free(buffers);

void
glCreateCommandListsNV_c(n, lists)
  GLsizei n;
  GLuint* lists;
CODE:
  OGLM_GLEWINIT
  OGLM_CHECK_ERR(glCreateCommandListsNV, )
  OGLM_AVAIL_CHECK(__glewCreateCommandListsNV, glCreateCommandListsNV)
  glCreateCommandListsNV(n, lists);
  OGLM_CHECK_ERR(glCreateCommandListsNV, )

void
glCreateCommandListsNV_p(n)
  GLsizei n;
PPCODE:
  OGLM_GLEWINIT
  OGLM_CHECK_ERR(glCreateCommandListsNV, )
  OGLM_AVAIL_CHECK(__glewCreateCommandListsNV, glCreateCommandListsNV)
  GLuint* lists = OGLM_ALLOC(n,GLuint,lists);
  glCreateCommandListsNV(n, lists);
  OGLM_CHECK_ERR(glCreateCommandListsNV, free(lists);)
  OGLM_OUT_FINISH(lists,n,newSVuv)
  free(lists);

void
glCreateFramebuffers_c(n, framebuffers)
  GLsizei n;
  GLuint* framebuffers;
CODE:
  OGLM_GLEWINIT
  OGLM_CHECK_ERR(glCreateFramebuffers, )
  OGLM_AVAIL_CHECK(__glewCreateFramebuffers, glCreateFramebuffers)
  glCreateFramebuffers(n, framebuffers);
  OGLM_CHECK_ERR(glCreateFramebuffers, )

void
glCreateFramebuffers_p(n)
  GLsizei n;
PPCODE:
  OGLM_GLEWINIT
  OGLM_CHECK_ERR(glCreateFramebuffers, )
  OGLM_AVAIL_CHECK(__glewCreateFramebuffers, glCreateFramebuffers)
  GLuint* framebuffers = OGLM_ALLOC(n,GLuint,framebuffers);
  glCreateFramebuffers(n, framebuffers);
  OGLM_CHECK_ERR(glCreateFramebuffers, free(framebuffers);)
  OGLM_OUT_FINISH(framebuffers,n,newSVuv)
  free(framebuffers);

void
glCreateMemoryObjectsEXT_c(n, memoryObjects)
  GLsizei n;
  GLuint* memoryObjects;
CODE:
  OGLM_GLEWINIT
  OGLM_CHECK_ERR(glCreateMemoryObjectsEXT, )
  OGLM_AVAIL_CHECK(__glewCreateMemoryObjectsEXT, glCreateMemoryObjectsEXT)
  glCreateMemoryObjectsEXT(n, memoryObjects);
  OGLM_CHECK_ERR(glCreateMemoryObjectsEXT, )

void
glCreatePerfQueryINTEL_c(queryId, queryHandle)
  GLuint queryId;
  GLuint* queryHandle;
CODE:
  OGLM_GLEWINIT
  OGLM_CHECK_ERR(glCreatePerfQueryINTEL, )
  OGLM_AVAIL_CHECK(__glewCreatePerfQueryINTEL, glCreatePerfQueryINTEL)
  glCreatePerfQueryINTEL(queryId, queryHandle);
  OGLM_CHECK_ERR(glCreatePerfQueryINTEL, )

GLuint
glCreateProgram()
ALIAS:
  glCreateProgramObjectARB = 1
CODE:
  OGLM_GLEWINIT
  OGLM_CHECK_ERR(glCreateProgram, )
  OGLM_AVAIL_CHECK(__glewCreateProgram, glCreateProgram)
  RETVAL = glCreateProgram();
  OGLM_CHECK_ERR(glCreateProgram, )
OUTPUT:
  RETVAL

void
glCreateProgramPipelines_c(n, pipelines)
  GLsizei n;
  GLuint* pipelines;
CODE:
  OGLM_GLEWINIT
  OGLM_CHECK_ERR(glCreateProgramPipelines, )
  OGLM_AVAIL_CHECK(__glewCreateProgramPipelines, glCreateProgramPipelines)
  glCreateProgramPipelines(n, pipelines);
  OGLM_CHECK_ERR(glCreateProgramPipelines, )

void
glCreateProgramPipelines_p(n)
  GLsizei n;
PPCODE:
  OGLM_GLEWINIT
  OGLM_CHECK_ERR(glCreateProgramPipelines, )
  OGLM_AVAIL_CHECK(__glewCreateProgramPipelines, glCreateProgramPipelines)
  GLuint* pipelines = OGLM_ALLOC(n,GLuint,pipelines);
  glCreateProgramPipelines(n, pipelines);
  OGLM_CHECK_ERR(glCreateProgramPipelines, free(pipelines);)
  OGLM_OUT_FINISH(pipelines,n,newSVuv)
  free(pipelines);

GLuint
glCreateProgressFenceNVX()
CODE:
  OGLM_GLEWINIT
  OGLM_CHECK_ERR(glCreateProgressFenceNVX, )
  OGLM_AVAIL_CHECK(__glewCreateProgressFenceNVX, glCreateProgressFenceNVX)
  RETVAL = glCreateProgressFenceNVX();
  OGLM_CHECK_ERR(glCreateProgressFenceNVX, )
OUTPUT:
  RETVAL

void
glCreateQueries_c(target, n, ids)
  GLenum target;
  GLsizei n;
  GLuint* ids;
CODE:
  OGLM_GLEWINIT
  OGLM_CHECK_ERR(glCreateQueries, )
  OGLM_AVAIL_CHECK(__glewCreateQueries, glCreateQueries)
  glCreateQueries(target, n, ids);
  OGLM_CHECK_ERR(glCreateQueries, )

void
glCreateQueries_p(target, n)
  GLenum target;
  GLsizei n;
PPCODE:
  OGLM_GLEWINIT
  OGLM_CHECK_ERR(glCreateQueries, )
  OGLM_AVAIL_CHECK(__glewCreateQueries, glCreateQueries)
  GLuint* ids = OGLM_ALLOC(n,GLuint,ids);
  glCreateQueries(target, n, ids);
  OGLM_CHECK_ERR(glCreateQueries, free(ids);)
  OGLM_OUT_FINISH(ids,n,newSVuv)
  free(ids);

void
glCreateRenderbuffers_c(n, renderbuffers)
  GLsizei n;
  GLuint* renderbuffers;
CODE:
  OGLM_GLEWINIT
  OGLM_CHECK_ERR(glCreateRenderbuffers, )
  OGLM_AVAIL_CHECK(__glewCreateRenderbuffers, glCreateRenderbuffers)
  glCreateRenderbuffers(n, renderbuffers);
  OGLM_CHECK_ERR(glCreateRenderbuffers, )

void
glCreateRenderbuffers_p(n)
  GLsizei n;
PPCODE:
  OGLM_GLEWINIT
  OGLM_CHECK_ERR(glCreateRenderbuffers, )
  OGLM_AVAIL_CHECK(__glewCreateRenderbuffers, glCreateRenderbuffers)
  GLuint* renderbuffers = OGLM_ALLOC(n,GLuint,renderbuffers);
  glCreateRenderbuffers(n, renderbuffers);
  OGLM_CHECK_ERR(glCreateRenderbuffers, free(renderbuffers);)
  OGLM_OUT_FINISH(renderbuffers,n,newSVuv)
  free(renderbuffers);

void
glCreateSamplers_c(n, samplers)
  GLsizei n;
  GLuint* samplers;
CODE:
  OGLM_GLEWINIT
  OGLM_CHECK_ERR(glCreateSamplers, )
  OGLM_AVAIL_CHECK(__glewCreateSamplers, glCreateSamplers)
  glCreateSamplers(n, samplers);
  OGLM_CHECK_ERR(glCreateSamplers, )

void
glCreateSamplers_p(n)
  GLsizei n;
PPCODE:
  OGLM_GLEWINIT
  OGLM_CHECK_ERR(glCreateSamplers, )
  OGLM_AVAIL_CHECK(__glewCreateSamplers, glCreateSamplers)
  GLuint* samplers = OGLM_ALLOC(n,GLuint,samplers);
  glCreateSamplers(n, samplers);
  OGLM_CHECK_ERR(glCreateSamplers, free(samplers);)
  OGLM_OUT_FINISH(samplers,n,newSVuv)
  free(samplers);

void
glCreateSemaphoresNV_c(n, semaphores)
  GLsizei n;
  GLuint* semaphores;
CODE:
  OGLM_GLEWINIT
  OGLM_CHECK_ERR(glCreateSemaphoresNV, )
  OGLM_AVAIL_CHECK(__glewCreateSemaphoresNV, glCreateSemaphoresNV)
  glCreateSemaphoresNV(n, semaphores);
  OGLM_CHECK_ERR(glCreateSemaphoresNV, )

void
glCreateSemaphoresNV_p(n)
  GLsizei n;
PPCODE:
  OGLM_GLEWINIT
  OGLM_CHECK_ERR(glCreateSemaphoresNV, )
  OGLM_AVAIL_CHECK(__glewCreateSemaphoresNV, glCreateSemaphoresNV)
  GLuint* semaphores = OGLM_ALLOC(n,GLuint,semaphores);
  glCreateSemaphoresNV(n, semaphores);
  OGLM_CHECK_ERR(glCreateSemaphoresNV, free(semaphores);)
  OGLM_OUT_FINISH(semaphores,n,newSVuv)
  free(semaphores);

GLuint
glCreateShader(type)
  GLenum type;
ALIAS:
  glCreateShaderObjectARB = 1
CODE:
  OGLM_GLEWINIT
  OGLM_CHECK_ERR(glCreateShader, )
  OGLM_AVAIL_CHECK(__glewCreateShader, glCreateShader)
  RETVAL = glCreateShader(type);
  OGLM_CHECK_ERR(glCreateShader, )
OUTPUT:
  RETVAL

GLuint
glCreateShaderProgramEXT(type, string)
  GLenum type;
  const GLchar* string;
CODE:
  OGLM_GLEWINIT
  OGLM_CHECK_ERR(glCreateShaderProgramEXT, )
  OGLM_AVAIL_CHECK(__glewCreateShaderProgramEXT, glCreateShaderProgramEXT)
  RETVAL = glCreateShaderProgramEXT(type, string);
  OGLM_CHECK_ERR(glCreateShaderProgramEXT, )
OUTPUT:
  RETVAL

GLuint
glCreateShaderProgramv_c(type, count, strings)
  GLenum type;
  GLsizei count;
  const GLchar * const * strings;
CODE:
  OGLM_GLEWINIT
  OGLM_CHECK_ERR(glCreateShaderProgramv, )
  OGLM_AVAIL_CHECK(__glewCreateShaderProgramv, glCreateShaderProgramv)
  RETVAL = glCreateShaderProgramv(type, count, strings);
  OGLM_CHECK_ERR(glCreateShaderProgramv, )
OUTPUT:
  RETVAL

GLuint
glCreateShaderProgramv_p(type, ...)
  GLenum type;
CODE:
  OGLM_GLEWINIT
  OGLM_CHECK_ERR(glCreateShaderProgramv, )
  OGLM_AVAIL_CHECK(__glewCreateShaderProgramv, glCreateShaderProgramv)
  GLsizei count = items-1;
  GLchar * * strings = OGLM_GET_VARARGS(strings,1,GLchar*,PV_nolen,count);
  RETVAL = glCreateShaderProgramv((GLenum )type, (GLsizei )count, (const GLchar * const * )strings);
  OGLM_CHECK_ERR(glCreateShaderProgramv, free(strings);)
  free(strings);
OUTPUT:
  RETVAL

void
glCreateStatesNV_c(n, states)
  GLsizei n;
  GLuint* states;
CODE:
  OGLM_GLEWINIT
  OGLM_CHECK_ERR(glCreateStatesNV, )
  OGLM_AVAIL_CHECK(__glewCreateStatesNV, glCreateStatesNV)
  glCreateStatesNV(n, states);
  OGLM_CHECK_ERR(glCreateStatesNV, )

void
glCreateStatesNV_p(n)
  GLsizei n;
PPCODE:
  OGLM_GLEWINIT
  OGLM_CHECK_ERR(glCreateStatesNV, )
  OGLM_AVAIL_CHECK(__glewCreateStatesNV, glCreateStatesNV)
  GLuint* states = OGLM_ALLOC(n,GLuint,states);
  glCreateStatesNV(n, states);
  OGLM_CHECK_ERR(glCreateStatesNV, free(states);)
  OGLM_OUT_FINISH(states,n,newSVuv)
  free(states);

GLsync
glCreateSyncFromCLeventARB(context, event, flags)
  cl_context context;
  cl_event event;
  GLbitfield flags;
CODE:
  OGLM_GLEWINIT
  OGLM_CHECK_ERR(glCreateSyncFromCLeventARB, )
  OGLM_AVAIL_CHECK(__glewCreateSyncFromCLeventARB, glCreateSyncFromCLeventARB)
  RETVAL = glCreateSyncFromCLeventARB(context, event, flags);
  OGLM_CHECK_ERR(glCreateSyncFromCLeventARB, )
OUTPUT:
  RETVAL

void
glCreateTextures_c(target, n, textures)
  GLenum target;
  GLsizei n;
  GLuint* textures;
CODE:
  OGLM_GLEWINIT
  OGLM_CHECK_ERR(glCreateTextures, )
  OGLM_AVAIL_CHECK(__glewCreateTextures, glCreateTextures)
  glCreateTextures(target, n, textures);
  OGLM_CHECK_ERR(glCreateTextures, )

void
glCreateTextures_p(target, n)
  GLenum target;
  GLsizei n;
PPCODE:
  OGLM_GLEWINIT
  OGLM_CHECK_ERR(glCreateTextures, )
  OGLM_AVAIL_CHECK(__glewCreateTextures, glCreateTextures)
  GLuint* textures = OGLM_ALLOC(n,GLuint,textures);
  glCreateTextures(target, n, textures);
  OGLM_CHECK_ERR(glCreateTextures, free(textures);)
  OGLM_OUT_FINISH(textures,n,newSVuv)
  free(textures);

void
glCreateTransformFeedbacks_c(n, ids)
  GLsizei n;
  GLuint* ids;
CODE:
  OGLM_GLEWINIT
  OGLM_CHECK_ERR(glCreateTransformFeedbacks, )
  OGLM_AVAIL_CHECK(__glewCreateTransformFeedbacks, glCreateTransformFeedbacks)
  glCreateTransformFeedbacks(n, ids);
  OGLM_CHECK_ERR(glCreateTransformFeedbacks, )

void
glCreateTransformFeedbacks_p(n)
  GLsizei n;
PPCODE:
  OGLM_GLEWINIT
  OGLM_CHECK_ERR(glCreateTransformFeedbacks, )
  OGLM_AVAIL_CHECK(__glewCreateTransformFeedbacks, glCreateTransformFeedbacks)
  GLuint* ids = OGLM_ALLOC(n,GLuint,ids);
  glCreateTransformFeedbacks(n, ids);
  OGLM_CHECK_ERR(glCreateTransformFeedbacks, free(ids);)
  OGLM_OUT_FINISH(ids,n,newSVuv)
  free(ids);

void
glCreateVertexArrays_c(n, arrays)
  GLsizei n;
  GLuint* arrays;
CODE:
  OGLM_GLEWINIT
  OGLM_CHECK_ERR(glCreateVertexArrays, )
  OGLM_AVAIL_CHECK(__glewCreateVertexArrays, glCreateVertexArrays)
  glCreateVertexArrays(n, arrays);
  OGLM_CHECK_ERR(glCreateVertexArrays, )

void
glCreateVertexArrays_p(n)
  GLsizei n;
PPCODE:
  OGLM_GLEWINIT
  OGLM_CHECK_ERR(glCreateVertexArrays, )
  OGLM_AVAIL_CHECK(__glewCreateVertexArrays, glCreateVertexArrays)
  GLuint* arrays = OGLM_ALLOC(n,GLuint,arrays);
  glCreateVertexArrays(n, arrays);
  OGLM_CHECK_ERR(glCreateVertexArrays, free(arrays);)
  OGLM_OUT_FINISH(arrays,n,newSVuv)
  free(arrays);

void
glCullFace(mode)
  GLenum mode;
CODE:
  OGLM_GLEWINIT
  OGLM_CHECK_ERR(glCullFace, )
  glCullFace(mode);
  OGLM_CHECK_ERR(glCullFace, )

void
glCullParameterdvEXT_c(pname, params)
  GLenum pname;
  GLdouble* params;
CODE:
  OGLM_GLEWINIT
  OGLM_CHECK_ERR(glCullParameterdvEXT, )
  OGLM_AVAIL_CHECK(__glewCullParameterdvEXT, glCullParameterdvEXT)
  glCullParameterdvEXT(pname, params);
  OGLM_CHECK_ERR(glCullParameterdvEXT, )

void
glCullParameterdvEXT_p(pname)
  GLenum pname;
PPCODE:
  OGLM_GLEWINIT
  OGLM_CHECK_ERR(glCullParameterdvEXT, )
  OGLM_AVAIL_CHECK(__glewCullParameterdvEXT, glCullParameterdvEXT)
  GLdouble* params = OGLM_ALLOC(4,GLdouble,params);
  glCullParameterdvEXT(pname, params);
  OGLM_CHECK_ERR(glCullParameterdvEXT, free(params);)
  OGLM_OUT_FINISH(params,4,newSVnv)
  free(params);

void
glCullParameterfvEXT_c(pname, params)
  GLenum pname;
  GLfloat* params;
CODE:
  OGLM_GLEWINIT
  OGLM_CHECK_ERR(glCullParameterfvEXT, )
  OGLM_AVAIL_CHECK(__glewCullParameterfvEXT, glCullParameterfvEXT)
  glCullParameterfvEXT(pname, params);
  OGLM_CHECK_ERR(glCullParameterfvEXT, )

void
glCullParameterfvEXT_p(pname)
  GLenum pname;
PPCODE:
  OGLM_GLEWINIT
  OGLM_CHECK_ERR(glCullParameterfvEXT, )
  OGLM_AVAIL_CHECK(__glewCullParameterfvEXT, glCullParameterfvEXT)
  GLfloat* params = OGLM_ALLOC(4,GLfloat,params);
  glCullParameterfvEXT(pname, params);
  OGLM_CHECK_ERR(glCullParameterfvEXT, free(params);)
  OGLM_OUT_FINISH(params,4,newSVnv)
  free(params);

void
glCurrentPaletteMatrixARB(index)
  GLint index;
CODE:
  OGLM_GLEWINIT
  OGLM_CHECK_ERR(glCurrentPaletteMatrixARB, )
  OGLM_AVAIL_CHECK(__glewCurrentPaletteMatrixARB, glCurrentPaletteMatrixARB)
  glCurrentPaletteMatrixARB(index);
  OGLM_CHECK_ERR(glCurrentPaletteMatrixARB, )

void
glCurrentPaletteMatrixOES(index)
  GLuint index;
CODE:
  OGLM_GLEWINIT
  OGLM_CHECK_ERR(glCurrentPaletteMatrixOES, )
  OGLM_AVAIL_CHECK(__glewCurrentPaletteMatrixOES, glCurrentPaletteMatrixOES)
  glCurrentPaletteMatrixOES(index);
  OGLM_CHECK_ERR(glCurrentPaletteMatrixOES, )

GLint
glDataPipe(space)
  GLenum space;
CODE:
  OGLM_GLEWINIT
  OGLM_CHECK_ERR(glDataPipe, )
  OGLM_AVAIL_CHECK(__glewDataPipe, glDataPipe)
  RETVAL = glDataPipe(space);
  OGLM_CHECK_ERR(glDataPipe, )
OUTPUT:
  RETVAL

void
glDebugMessageCallback_c(callback, userParam)
  GLDEBUGPROC callback;
  const void *userParam;
ALIAS:
  glDebugMessageCallbackARB_c = 1
  glDebugMessageCallbackKHR_c = 2
CODE:
  OGLM_GLEWINIT
  OGLM_CHECK_ERR(glDebugMessageCallback, )
  OGLM_AVAIL_CHECK(__glewDebugMessageCallback, glDebugMessageCallback)
  glDebugMessageCallback(callback, userParam);
  OGLM_CHECK_ERR(glDebugMessageCallback, )

void
glDebugMessageCallbackAMD_c(callback, userParam)
  GLDEBUGPROCAMD callback;
  void *userParam;
CODE:
  OGLM_GLEWINIT
  OGLM_CHECK_ERR(glDebugMessageCallbackAMD, )
  OGLM_AVAIL_CHECK(__glewDebugMessageCallbackAMD, glDebugMessageCallbackAMD)
  glDebugMessageCallbackAMD(callback, userParam);
  OGLM_CHECK_ERR(glDebugMessageCallbackAMD, )

void
glDebugMessageControl_c(source, type, severity, count, ids, enabled)
  GLenum source;
  GLenum type;
  GLenum severity;
  GLsizei count;
  const GLuint* ids;
  GLboolean enabled;
ALIAS:
  glDebugMessageControlARB_c = 1
  glDebugMessageControlKHR_c = 2
CODE:
  OGLM_GLEWINIT
  OGLM_CHECK_ERR(glDebugMessageControl, )
  OGLM_AVAIL_CHECK(__glewDebugMessageControl, glDebugMessageControl)
  glDebugMessageControl(source, type, severity, count, ids, enabled);
  OGLM_CHECK_ERR(glDebugMessageControl, )

void
glDebugMessageControl_p(source, type, severity, enabled, ...)
  GLenum source;
  GLenum type;
  GLenum severity;
  GLboolean enabled;
ALIAS:
  glDebugMessageControlARB_p = 1
  glDebugMessageControlKHR_p = 2
CODE:
  OGLM_GLEWINIT
  OGLM_CHECK_ERR(glDebugMessageControl, )
  OGLM_AVAIL_CHECK(__glewDebugMessageControl, glDebugMessageControl)
  GLsizei count = items-4;
  GLuint* ids = OGLM_GET_VARARGS(ids,4,GLuint,UV,count);
  glDebugMessageControl((GLenum )source, (GLenum )type, (GLenum )severity, (GLsizei )count, (const GLuint* )ids, (GLboolean )enabled);
  OGLM_CHECK_ERR(glDebugMessageControl, free(ids);)
  free(ids);

void
glDebugMessageEnableAMD_c(category, severity, count, ids, enabled)
  GLenum category;
  GLenum severity;
  GLsizei count;
  const GLuint* ids;
  GLboolean enabled;
CODE:
  OGLM_GLEWINIT
  OGLM_CHECK_ERR(glDebugMessageEnableAMD, )
  OGLM_AVAIL_CHECK(__glewDebugMessageEnableAMD, glDebugMessageEnableAMD)
  glDebugMessageEnableAMD(category, severity, count, ids, enabled);
  OGLM_CHECK_ERR(glDebugMessageEnableAMD, )

void
glDebugMessageEnableAMD_p(category, severity, enabled, ...)
  GLenum category;
  GLenum severity;
  GLboolean enabled;
CODE:
  OGLM_GLEWINIT
  OGLM_CHECK_ERR(glDebugMessageEnableAMD, )
  OGLM_AVAIL_CHECK(__glewDebugMessageEnableAMD, glDebugMessageEnableAMD)
  GLsizei count = items-3;
  GLuint* ids = OGLM_GET_VARARGS(ids,3,GLuint,UV,count);
  glDebugMessageEnableAMD((GLenum )category, (GLenum )severity, (GLsizei )count, (const GLuint* )ids, (GLboolean )enabled);
  OGLM_CHECK_ERR(glDebugMessageEnableAMD, free(ids);)
  free(ids);

void
glDebugMessageInsert(source, type, id, severity, length, buf)
  GLenum source;
  GLenum type;
  GLuint id;
  GLenum severity;
  GLsizei length;
  const GLchar* buf;
ALIAS:
  glDebugMessageInsertARB = 1
  glDebugMessageInsertKHR = 2
CODE:
  OGLM_GLEWINIT
  OGLM_CHECK_ERR(glDebugMessageInsert, )
  OGLM_AVAIL_CHECK(__glewDebugMessageInsert, glDebugMessageInsert)
  glDebugMessageInsert(source, type, id, severity, length, buf);
  OGLM_CHECK_ERR(glDebugMessageInsert, )

void
glDebugMessageInsertAMD(category, severity, id, length, buf)
  GLenum category;
  GLenum severity;
  GLuint id;
  GLsizei length;
  const GLchar* buf;
CODE:
  OGLM_GLEWINIT
  OGLM_CHECK_ERR(glDebugMessageInsertAMD, )
  OGLM_AVAIL_CHECK(__glewDebugMessageInsertAMD, glDebugMessageInsertAMD)
  glDebugMessageInsertAMD(category, severity, id, length, buf);
  OGLM_CHECK_ERR(glDebugMessageInsertAMD, )

void
glDeformSGIX(mask)
  GLbitfield mask;
CODE:
  OGLM_GLEWINIT
  OGLM_CHECK_ERR(glDeformSGIX, )
  OGLM_AVAIL_CHECK(__glewDeformSGIX, glDeformSGIX)
  glDeformSGIX(mask);
  OGLM_CHECK_ERR(glDeformSGIX, )

void
glDeleteArraySetsEXT_c(n, arrayset)
  GLsizei n;
  const void * *arrayset;
CODE:
  OGLM_GLEWINIT
  OGLM_CHECK_ERR(glDeleteArraySetsEXT, )
  OGLM_AVAIL_CHECK(__glewDeleteArraySetsEXT, glDeleteArraySetsEXT)
  glDeleteArraySetsEXT(n, arrayset);
  OGLM_CHECK_ERR(glDeleteArraySetsEXT, )

void
glDeleteAsyncMarkersSGIX(marker, range)
  GLuint marker;
  GLsizei range;
CODE:
  OGLM_GLEWINIT
  OGLM_CHECK_ERR(glDeleteAsyncMarkersSGIX, )
  OGLM_AVAIL_CHECK(__glewDeleteAsyncMarkersSGIX, glDeleteAsyncMarkersSGIX)
  glDeleteAsyncMarkersSGIX(marker, range);
  OGLM_CHECK_ERR(glDeleteAsyncMarkersSGIX, )

void
glDeleteBufferRegion(region)
  GLenum region;
CODE:
  OGLM_GLEWINIT
  OGLM_CHECK_ERR(glDeleteBufferRegion, )
  OGLM_AVAIL_CHECK(__glewDeleteBufferRegion, glDeleteBufferRegion)
  glDeleteBufferRegion(region);
  OGLM_CHECK_ERR(glDeleteBufferRegion, )

void
glDeleteBuffers_c(n, buffers)
  GLsizei n;
  const GLuint* buffers;
ALIAS:
  glDeleteBuffersARB_c = 1
CODE:
  OGLM_GLEWINIT
  OGLM_CHECK_ERR(glDeleteBuffers, )
  OGLM_AVAIL_CHECK(__glewDeleteBuffers, glDeleteBuffers)
  glDeleteBuffers(n, buffers);
  OGLM_CHECK_ERR(glDeleteBuffers, )

void
glDeleteBuffers_p(...)
ALIAS:
  glDeleteBuffersARB_p = 1
CODE:
  OGLM_GLEWINIT
  OGLM_CHECK_ERR(glDeleteBuffers, )
  OGLM_AVAIL_CHECK(__glewDeleteBuffers, glDeleteBuffers)
  GLsizei n = items;
  GLuint* buffers = OGLM_GET_VARARGS(buffers,0,GLuint,UV,n);
  glDeleteBuffers((GLsizei )n, (const GLuint* )buffers);
  OGLM_CHECK_ERR(glDeleteBuffers, free(buffers);)
  free(buffers);

void
glDeleteCommandListsNV_c(n, lists)
  GLsizei n;
  const GLuint* lists;
CODE:
  OGLM_GLEWINIT
  OGLM_CHECK_ERR(glDeleteCommandListsNV, )
  OGLM_AVAIL_CHECK(__glewDeleteCommandListsNV, glDeleteCommandListsNV)
  glDeleteCommandListsNV(n, lists);
  OGLM_CHECK_ERR(glDeleteCommandListsNV, )

void
glDeleteCommandListsNV_p(...)
CODE:
  OGLM_GLEWINIT
  OGLM_CHECK_ERR(glDeleteCommandListsNV, )
  OGLM_AVAIL_CHECK(__glewDeleteCommandListsNV, glDeleteCommandListsNV)
  GLsizei n = items;
  GLuint* lists = OGLM_GET_VARARGS(lists,0,GLuint,UV,n);
  glDeleteCommandListsNV((GLsizei )n, (const GLuint* )lists);
  OGLM_CHECK_ERR(glDeleteCommandListsNV, free(lists);)
  free(lists);

void
glDeleteFencesAPPLE_c(n, fences)
  GLsizei n;
  const GLuint* fences;
CODE:
  OGLM_GLEWINIT
  OGLM_CHECK_ERR(glDeleteFencesAPPLE, )
  OGLM_AVAIL_CHECK(__glewDeleteFencesAPPLE, glDeleteFencesAPPLE)
  glDeleteFencesAPPLE(n, fences);
  OGLM_CHECK_ERR(glDeleteFencesAPPLE, )

void
glDeleteFencesAPPLE_p(...)
CODE:
  OGLM_GLEWINIT
  OGLM_CHECK_ERR(glDeleteFencesAPPLE, )
  OGLM_AVAIL_CHECK(__glewDeleteFencesAPPLE, glDeleteFencesAPPLE)
  GLsizei n = items;
  GLuint* fences = OGLM_GET_VARARGS(fences,0,GLuint,UV,n);
  glDeleteFencesAPPLE((GLsizei )n, (const GLuint* )fences);
  OGLM_CHECK_ERR(glDeleteFencesAPPLE, free(fences);)
  free(fences);

void
glDeleteFencesNV_c(n, fences)
  GLsizei n;
  const GLuint* fences;
CODE:
  OGLM_GLEWINIT
  OGLM_CHECK_ERR(glDeleteFencesNV, )
  OGLM_AVAIL_CHECK(__glewDeleteFencesNV, glDeleteFencesNV)
  glDeleteFencesNV(n, fences);
  OGLM_CHECK_ERR(glDeleteFencesNV, )

void
glDeleteFencesNV_p(...)
CODE:
  OGLM_GLEWINIT
  OGLM_CHECK_ERR(glDeleteFencesNV, )
  OGLM_AVAIL_CHECK(__glewDeleteFencesNV, glDeleteFencesNV)
  GLsizei n = items;
  GLuint* fences = OGLM_GET_VARARGS(fences,0,GLuint,UV,n);
  glDeleteFencesNV((GLsizei )n, (const GLuint* )fences);
  OGLM_CHECK_ERR(glDeleteFencesNV, free(fences);)
  free(fences);

void
glDeleteFragmentShaderATI(id)
  GLuint id;
CODE:
  OGLM_GLEWINIT
  OGLM_CHECK_ERR(glDeleteFragmentShaderATI, )
  OGLM_AVAIL_CHECK(__glewDeleteFragmentShaderATI, glDeleteFragmentShaderATI)
  glDeleteFragmentShaderATI(id);
  OGLM_CHECK_ERR(glDeleteFragmentShaderATI, )

void
glDeleteFramebuffers_c(n, framebuffers)
  GLsizei n;
  const GLuint* framebuffers;
ALIAS:
  glDeleteFramebuffersEXT_c = 1
CODE:
  OGLM_GLEWINIT
  OGLM_CHECK_ERR(glDeleteFramebuffers, )
  OGLM_AVAIL_CHECK(__glewDeleteFramebuffers, glDeleteFramebuffers)
  glDeleteFramebuffers(n, framebuffers);
  OGLM_CHECK_ERR(glDeleteFramebuffers, )

void
glDeleteFramebuffers_p(...)
ALIAS:
  glDeleteFramebuffersEXT_p = 1
CODE:
  OGLM_GLEWINIT
  OGLM_CHECK_ERR(glDeleteFramebuffers, )
  OGLM_AVAIL_CHECK(__glewDeleteFramebuffers, glDeleteFramebuffers)
  GLsizei n = items;
  GLuint* framebuffers = OGLM_GET_VARARGS(framebuffers,0,GLuint,UV,n);
  glDeleteFramebuffers((GLsizei )n, (const GLuint* )framebuffers);
  OGLM_CHECK_ERR(glDeleteFramebuffers, free(framebuffers);)
  free(framebuffers);

void
glDeleteFramebuffersOES_c(n, framebuffers)
  GLsizei n;
  const GLuint* framebuffers;
CODE:
  OGLM_GLEWINIT
  OGLM_CHECK_ERR(glDeleteFramebuffersOES, )
  OGLM_AVAIL_CHECK(__glewDeleteFramebuffersOES, glDeleteFramebuffersOES)
  glDeleteFramebuffersOES(n, framebuffers);
  OGLM_CHECK_ERR(glDeleteFramebuffersOES, )

void
glDeleteLists(list, range)
  GLuint list;
  GLsizei range;
CODE:
  OGLM_GLEWINIT
  OGLM_CHECK_ERR(glDeleteLists, )
  glDeleteLists(list, range);
  OGLM_CHECK_ERR(glDeleteLists, )

void
glDeleteMPEGPredictorsSGIX_c(n, predictors)
  GLsizei n;
  GLuint* predictors;
CODE:
  OGLM_GLEWINIT
  OGLM_CHECK_ERR(glDeleteMPEGPredictorsSGIX, )
  OGLM_AVAIL_CHECK(__glewDeleteMPEGPredictorsSGIX, glDeleteMPEGPredictorsSGIX)
  glDeleteMPEGPredictorsSGIX(n, predictors);
  OGLM_CHECK_ERR(glDeleteMPEGPredictorsSGIX, )

void
glDeleteMemoryObjectsEXT_c(n, memoryObjects)
  GLsizei n;
  const GLuint* memoryObjects;
CODE:
  OGLM_GLEWINIT
  OGLM_CHECK_ERR(glDeleteMemoryObjectsEXT, )
  OGLM_AVAIL_CHECK(__glewDeleteMemoryObjectsEXT, glDeleteMemoryObjectsEXT)
  glDeleteMemoryObjectsEXT(n, memoryObjects);
  OGLM_CHECK_ERR(glDeleteMemoryObjectsEXT, )

void
glDeleteMemoryObjectsEXT_p(...)
CODE:
  OGLM_GLEWINIT
  OGLM_CHECK_ERR(glDeleteMemoryObjectsEXT, )
  OGLM_AVAIL_CHECK(__glewDeleteMemoryObjectsEXT, glDeleteMemoryObjectsEXT)
  GLsizei n = items;
  GLuint* memoryObjects = OGLM_GET_VARARGS(memoryObjects,0,GLuint,UV,n);
  glDeleteMemoryObjectsEXT((GLsizei )n, (const GLuint* )memoryObjects);
  OGLM_CHECK_ERR(glDeleteMemoryObjectsEXT, free(memoryObjects);)
  free(memoryObjects);

void
glDeleteNamedStringARB(namelen, name)
  GLint namelen;
  const GLchar* name;
CODE:
  OGLM_GLEWINIT
  OGLM_CHECK_ERR(glDeleteNamedStringARB, )
  OGLM_AVAIL_CHECK(__glewDeleteNamedStringARB, glDeleteNamedStringARB)
  glDeleteNamedStringARB(namelen, name);
  OGLM_CHECK_ERR(glDeleteNamedStringARB, )

void
glDeleteNamesAMD_c(identifier, num, names)
  GLenum identifier;
  GLuint num;
  const GLuint* names;
CODE:
  OGLM_GLEWINIT
  OGLM_CHECK_ERR(glDeleteNamesAMD, )
  OGLM_AVAIL_CHECK(__glewDeleteNamesAMD, glDeleteNamesAMD)
  glDeleteNamesAMD(identifier, num, names);
  OGLM_CHECK_ERR(glDeleteNamesAMD, )

void
glDeleteNamesAMD_p(identifier, ...)
  GLenum identifier;
CODE:
  OGLM_GLEWINIT
  OGLM_CHECK_ERR(glDeleteNamesAMD, )
  OGLM_AVAIL_CHECK(__glewDeleteNamesAMD, glDeleteNamesAMD)
  GLuint num = items-1;
  GLuint* names = OGLM_GET_VARARGS(names,1,GLuint,UV,num);
  glDeleteNamesAMD((GLenum )identifier, (GLuint )num, (const GLuint* )names);
  OGLM_CHECK_ERR(glDeleteNamesAMD, free(names);)
  free(names);

void
glDeleteObjectARB(obj)
  GLhandleARB obj;
CODE:
  OGLM_GLEWINIT
  OGLM_CHECK_ERR(glDeleteObjectARB, )
  OGLM_AVAIL_CHECK(__glewDeleteObjectARB, glDeleteObjectARB)
  glDeleteObjectARB(obj);
  OGLM_CHECK_ERR(glDeleteObjectARB, )

void
glDeleteOcclusionQueriesNV_c(n, ids)
  GLsizei n;
  const GLuint* ids;
CODE:
  OGLM_GLEWINIT
  OGLM_CHECK_ERR(glDeleteOcclusionQueriesNV, )
  OGLM_AVAIL_CHECK(__glewDeleteOcclusionQueriesNV, glDeleteOcclusionQueriesNV)
  glDeleteOcclusionQueriesNV(n, ids);
  OGLM_CHECK_ERR(glDeleteOcclusionQueriesNV, )

void
glDeleteOcclusionQueriesNV_p(...)
CODE:
  OGLM_GLEWINIT
  OGLM_CHECK_ERR(glDeleteOcclusionQueriesNV, )
  OGLM_AVAIL_CHECK(__glewDeleteOcclusionQueriesNV, glDeleteOcclusionQueriesNV)
  GLsizei n = items;
  GLuint* ids = OGLM_GET_VARARGS(ids,0,GLuint,UV,n);
  glDeleteOcclusionQueriesNV((GLsizei )n, (const GLuint* )ids);
  OGLM_CHECK_ERR(glDeleteOcclusionQueriesNV, free(ids);)
  free(ids);

void
glDeletePathsNV(path, range)
  GLuint path;
  GLsizei range;
CODE:
  OGLM_GLEWINIT
  OGLM_CHECK_ERR(glDeletePathsNV, )
  OGLM_AVAIL_CHECK(__glewDeletePathsNV, glDeletePathsNV)
  glDeletePathsNV(path, range);
  OGLM_CHECK_ERR(glDeletePathsNV, )

void
glDeletePerfMonitorsAMD_c(n, monitors)
  GLsizei n;
  GLuint* monitors;
CODE:
  OGLM_GLEWINIT
  OGLM_CHECK_ERR(glDeletePerfMonitorsAMD, )
  OGLM_AVAIL_CHECK(__glewDeletePerfMonitorsAMD, glDeletePerfMonitorsAMD)
  glDeletePerfMonitorsAMD(n, monitors);
  OGLM_CHECK_ERR(glDeletePerfMonitorsAMD, )

void
glDeletePerfMonitorsAMD_p(n)
  GLsizei n;
PPCODE:
  OGLM_GLEWINIT
  OGLM_CHECK_ERR(glDeletePerfMonitorsAMD, )
  OGLM_AVAIL_CHECK(__glewDeletePerfMonitorsAMD, glDeletePerfMonitorsAMD)
  GLuint* monitors = OGLM_ALLOC(n,GLuint,monitors);
  glDeletePerfMonitorsAMD(n, monitors);
  OGLM_CHECK_ERR(glDeletePerfMonitorsAMD, free(monitors);)
  OGLM_OUT_FINISH(monitors,n,newSVuv)
  free(monitors);

void
glDeletePerfQueryINTEL(queryHandle)
  GLuint queryHandle;
CODE:
  OGLM_GLEWINIT
  OGLM_CHECK_ERR(glDeletePerfQueryINTEL, )
  OGLM_AVAIL_CHECK(__glewDeletePerfQueryINTEL, glDeletePerfQueryINTEL)
  glDeletePerfQueryINTEL(queryHandle);
  OGLM_CHECK_ERR(glDeletePerfQueryINTEL, )

void
glDeleteProgram(program)
  GLuint program;
CODE:
  OGLM_GLEWINIT
  OGLM_CHECK_ERR(glDeleteProgram, )
  OGLM_AVAIL_CHECK(__glewDeleteProgram, glDeleteProgram)
  glDeleteProgram(program);
  OGLM_CHECK_ERR(glDeleteProgram, )

void
glDeleteProgramPipelines_c(n, pipelines)
  GLsizei n;
  const GLuint* pipelines;
CODE:
  OGLM_GLEWINIT
  OGLM_CHECK_ERR(glDeleteProgramPipelines, )
  OGLM_AVAIL_CHECK(__glewDeleteProgramPipelines, glDeleteProgramPipelines)
  glDeleteProgramPipelines(n, pipelines);
  OGLM_CHECK_ERR(glDeleteProgramPipelines, )

void
glDeleteProgramPipelines_p(...)
CODE:
  OGLM_GLEWINIT
  OGLM_CHECK_ERR(glDeleteProgramPipelines, )
  OGLM_AVAIL_CHECK(__glewDeleteProgramPipelines, glDeleteProgramPipelines)
  GLsizei n = items;
  GLuint* pipelines = OGLM_GET_VARARGS(pipelines,0,GLuint,UV,n);
  glDeleteProgramPipelines((GLsizei )n, (const GLuint* )pipelines);
  OGLM_CHECK_ERR(glDeleteProgramPipelines, free(pipelines);)
  free(pipelines);

void
glDeleteProgramsARB_c(n, programs)
  GLsizei n;
  const GLuint* programs;
ALIAS:
  glDeleteProgramsNV_c = 1
CODE:
  OGLM_GLEWINIT
  OGLM_CHECK_ERR(glDeleteProgramsARB, )
  OGLM_AVAIL_CHECK(__glewDeleteProgramsARB, glDeleteProgramsARB)
  glDeleteProgramsARB(n, programs);
  OGLM_CHECK_ERR(glDeleteProgramsARB, )

void
glDeleteProgramsARB_p(...)
ALIAS:
  glDeleteProgramsNV_p = 1
CODE:
  OGLM_GLEWINIT
  OGLM_CHECK_ERR(glDeleteProgramsARB, )
  OGLM_AVAIL_CHECK(__glewDeleteProgramsARB, glDeleteProgramsARB)
  GLsizei n = items;
  GLuint* programs = OGLM_GET_VARARGS(programs,0,GLuint,UV,n);
  glDeleteProgramsARB((GLsizei )n, (const GLuint* )programs);
  OGLM_CHECK_ERR(glDeleteProgramsARB, free(programs);)
  free(programs);

void
glDeleteQueries_c(n, ids)
  GLsizei n;
  const GLuint* ids;
ALIAS:
  glDeleteQueriesARB_c = 1
CODE:
  OGLM_GLEWINIT
  OGLM_CHECK_ERR(glDeleteQueries, )
  OGLM_AVAIL_CHECK(__glewDeleteQueries, glDeleteQueries)
  glDeleteQueries(n, ids);
  OGLM_CHECK_ERR(glDeleteQueries, )

void
glDeleteQueries_p(...)
ALIAS:
  glDeleteQueriesARB_p = 1
CODE:
  OGLM_GLEWINIT
  OGLM_CHECK_ERR(glDeleteQueries, )
  OGLM_AVAIL_CHECK(__glewDeleteQueries, glDeleteQueries)
  GLsizei n = items;
  GLuint* ids = OGLM_GET_VARARGS(ids,0,GLuint,UV,n);
  glDeleteQueries((GLsizei )n, (const GLuint* )ids);
  OGLM_CHECK_ERR(glDeleteQueries, free(ids);)
  free(ids);

void
glDeleteQueriesANGLE_c(n, ids)
  GLsizei n;
  const GLuint* ids;
CODE:
  OGLM_GLEWINIT
  OGLM_CHECK_ERR(glDeleteQueriesANGLE, )
  OGLM_AVAIL_CHECK(__glewDeleteQueriesANGLE, glDeleteQueriesANGLE)
  glDeleteQueriesANGLE(n, ids);
  OGLM_CHECK_ERR(glDeleteQueriesANGLE, )

void
glDeleteQueriesEXT_c(n, ids)
  GLsizei n;
  const GLuint* ids;
CODE:
  OGLM_GLEWINIT
  OGLM_CHECK_ERR(glDeleteQueriesEXT, )
  OGLM_AVAIL_CHECK(__glewDeleteQueriesEXT, glDeleteQueriesEXT)
  glDeleteQueriesEXT(n, ids);
  OGLM_CHECK_ERR(glDeleteQueriesEXT, )

void
glDeleteQueriesEXT_p(...)
CODE:
  OGLM_GLEWINIT
  OGLM_CHECK_ERR(glDeleteQueriesEXT, )
  OGLM_AVAIL_CHECK(__glewDeleteQueriesEXT, glDeleteQueriesEXT)
  GLsizei n = items;
  GLuint* ids = OGLM_GET_VARARGS(ids,0,GLuint,UV,n);
  glDeleteQueriesEXT((GLsizei )n, (const GLuint* )ids);
  OGLM_CHECK_ERR(glDeleteQueriesEXT, free(ids);)
  free(ids);

void
glDeleteRenderbuffers_c(n, renderbuffers)
  GLsizei n;
  const GLuint* renderbuffers;
ALIAS:
  glDeleteRenderbuffersEXT_c = 1
CODE:
  OGLM_GLEWINIT
  OGLM_CHECK_ERR(glDeleteRenderbuffers, )
  OGLM_AVAIL_CHECK(__glewDeleteRenderbuffers, glDeleteRenderbuffers)
  glDeleteRenderbuffers(n, renderbuffers);
  OGLM_CHECK_ERR(glDeleteRenderbuffers, )

void
glDeleteRenderbuffers_p(...)
ALIAS:
  glDeleteRenderbuffersEXT_p = 1
CODE:
  OGLM_GLEWINIT
  OGLM_CHECK_ERR(glDeleteRenderbuffers, )
  OGLM_AVAIL_CHECK(__glewDeleteRenderbuffers, glDeleteRenderbuffers)
  GLsizei n = items;
  GLuint* renderbuffers = OGLM_GET_VARARGS(renderbuffers,0,GLuint,UV,n);
  glDeleteRenderbuffers((GLsizei )n, (const GLuint* )renderbuffers);
  OGLM_CHECK_ERR(glDeleteRenderbuffers, free(renderbuffers);)
  free(renderbuffers);

void
glDeleteRenderbuffersOES_c(n, renderbuffers)
  GLsizei n;
  const GLuint* renderbuffers;
CODE:
  OGLM_GLEWINIT
  OGLM_CHECK_ERR(glDeleteRenderbuffersOES, )
  OGLM_AVAIL_CHECK(__glewDeleteRenderbuffersOES, glDeleteRenderbuffersOES)
  glDeleteRenderbuffersOES(n, renderbuffers);
  OGLM_CHECK_ERR(glDeleteRenderbuffersOES, )

void
glDeleteSamplers_c(count, samplers)
  GLsizei count;
  const GLuint * samplers;
CODE:
  OGLM_GLEWINIT
  OGLM_CHECK_ERR(glDeleteSamplers, )
  OGLM_AVAIL_CHECK(__glewDeleteSamplers, glDeleteSamplers)
  glDeleteSamplers(count, samplers);
  OGLM_CHECK_ERR(glDeleteSamplers, )

void
glDeleteSamplers_p(...)
CODE:
  OGLM_GLEWINIT
  OGLM_CHECK_ERR(glDeleteSamplers, )
  OGLM_AVAIL_CHECK(__glewDeleteSamplers, glDeleteSamplers)
  GLsizei count = items;
  GLuint * samplers = OGLM_GET_VARARGS(samplers,0,GLuint,UV,count);
  glDeleteSamplers((GLsizei )count, (const GLuint * )samplers);
  OGLM_CHECK_ERR(glDeleteSamplers, free(samplers);)
  free(samplers);

void
glDeleteSemaphoresEXT_c(n, semaphores)
  GLsizei n;
  const GLuint* semaphores;
CODE:
  OGLM_GLEWINIT
  OGLM_CHECK_ERR(glDeleteSemaphoresEXT, )
  OGLM_AVAIL_CHECK(__glewDeleteSemaphoresEXT, glDeleteSemaphoresEXT)
  glDeleteSemaphoresEXT(n, semaphores);
  OGLM_CHECK_ERR(glDeleteSemaphoresEXT, )

void
glDeleteSemaphoresEXT_p(...)
CODE:
  OGLM_GLEWINIT
  OGLM_CHECK_ERR(glDeleteSemaphoresEXT, )
  OGLM_AVAIL_CHECK(__glewDeleteSemaphoresEXT, glDeleteSemaphoresEXT)
  GLsizei n = items;
  GLuint* semaphores = OGLM_GET_VARARGS(semaphores,0,GLuint,UV,n);
  glDeleteSemaphoresEXT((GLsizei )n, (const GLuint* )semaphores);
  OGLM_CHECK_ERR(glDeleteSemaphoresEXT, free(semaphores);)
  free(semaphores);

void
glDeleteShader(shader)
  GLuint shader;
CODE:
  OGLM_GLEWINIT
  OGLM_CHECK_ERR(glDeleteShader, )
  OGLM_AVAIL_CHECK(__glewDeleteShader, glDeleteShader)
  glDeleteShader(shader);
  OGLM_CHECK_ERR(glDeleteShader, )

void
glDeleteStatesNV_c(n, states)
  GLsizei n;
  const GLuint* states;
CODE:
  OGLM_GLEWINIT
  OGLM_CHECK_ERR(glDeleteStatesNV, )
  OGLM_AVAIL_CHECK(__glewDeleteStatesNV, glDeleteStatesNV)
  glDeleteStatesNV(n, states);
  OGLM_CHECK_ERR(glDeleteStatesNV, )

void
glDeleteStatesNV_p(...)
CODE:
  OGLM_GLEWINIT
  OGLM_CHECK_ERR(glDeleteStatesNV, )
  OGLM_AVAIL_CHECK(__glewDeleteStatesNV, glDeleteStatesNV)
  GLsizei n = items;
  GLuint* states = OGLM_GET_VARARGS(states,0,GLuint,UV,n);
  glDeleteStatesNV((GLsizei )n, (const GLuint* )states);
  OGLM_CHECK_ERR(glDeleteStatesNV, free(states);)
  free(states);

void
glDeleteSync(myGLsync)
  GLsync myGLsync;
ALIAS:
  glDeleteSyncAPPLE = 1
CODE:
  OGLM_GLEWINIT
  OGLM_CHECK_ERR(glDeleteSync, )
  OGLM_AVAIL_CHECK(__glewDeleteSync, glDeleteSync)
  glDeleteSync(myGLsync);
  OGLM_CHECK_ERR(glDeleteSync, )

void
glDeleteTextures_c(n, textures)
  GLsizei n;
  const GLuint *textures;
CODE:
  OGLM_GLEWINIT
  OGLM_CHECK_ERR(glDeleteTextures, )
  glDeleteTextures(n, textures);
  OGLM_CHECK_ERR(glDeleteTextures, )

void
glDeleteTextures_p(...)
CODE:
  OGLM_GLEWINIT
  OGLM_CHECK_ERR(glDeleteTextures, )
  GLsizei n = items;
  GLuint *textures = OGLM_GET_VARARGS(textures,0,GLuint,UV,n);
  glDeleteTextures((GLsizei )n, (const GLuint *)textures);
  OGLM_CHECK_ERR(glDeleteTextures, free(textures);)
  free(textures);

void
glDeleteTexturesEXT_c(n, textures)
  GLsizei n;
  const GLuint* textures;
CODE:
  OGLM_GLEWINIT
  OGLM_CHECK_ERR(glDeleteTexturesEXT, )
  OGLM_AVAIL_CHECK(__glewDeleteTexturesEXT, glDeleteTexturesEXT)
  glDeleteTexturesEXT(n, textures);
  OGLM_CHECK_ERR(glDeleteTexturesEXT, )

void
glDeleteTexturesEXT_p(...)
CODE:
  OGLM_GLEWINIT
  OGLM_CHECK_ERR(glDeleteTexturesEXT, )
  OGLM_AVAIL_CHECK(__glewDeleteTexturesEXT, glDeleteTexturesEXT)
  GLsizei n = items;
  GLuint* textures = OGLM_GET_VARARGS(textures,0,GLuint,UV,n);
  glDeleteTexturesEXT((GLsizei )n, (const GLuint* )textures);
  OGLM_CHECK_ERR(glDeleteTexturesEXT, free(textures);)
  free(textures);

void
glDeleteTransformFeedbacks_c(n, ids)
  GLsizei n;
  const GLuint* ids;
ALIAS:
  glDeleteTransformFeedbacksNV_c = 1
CODE:
  OGLM_GLEWINIT
  OGLM_CHECK_ERR(glDeleteTransformFeedbacks, )
  OGLM_AVAIL_CHECK(__glewDeleteTransformFeedbacks, glDeleteTransformFeedbacks)
  glDeleteTransformFeedbacks(n, ids);
  OGLM_CHECK_ERR(glDeleteTransformFeedbacks, )

void
glDeleteTransformFeedbacks_p(...)
ALIAS:
  glDeleteTransformFeedbacksNV_p = 1
CODE:
  OGLM_GLEWINIT
  OGLM_CHECK_ERR(glDeleteTransformFeedbacks, )
  OGLM_AVAIL_CHECK(__glewDeleteTransformFeedbacks, glDeleteTransformFeedbacks)
  GLsizei n = items;
  GLuint* ids = OGLM_GET_VARARGS(ids,0,GLuint,UV,n);
  glDeleteTransformFeedbacks((GLsizei )n, (const GLuint* )ids);
  OGLM_CHECK_ERR(glDeleteTransformFeedbacks, free(ids);)
  free(ids);

void
glDeleteVertexArrays_c(n, arrays)
  GLsizei n;
  const GLuint* arrays;
ALIAS:
  glDeleteVertexArraysAPPLE_c = 1
CODE:
  OGLM_GLEWINIT
  OGLM_CHECK_ERR(glDeleteVertexArrays, )
  OGLM_AVAIL_CHECK(__glewDeleteVertexArrays, glDeleteVertexArrays)
  glDeleteVertexArrays(n, arrays);
  OGLM_CHECK_ERR(glDeleteVertexArrays, )

void
glDeleteVertexArrays_p(...)
ALIAS:
  glDeleteVertexArraysAPPLE_p = 1
CODE:
  OGLM_GLEWINIT
  OGLM_CHECK_ERR(glDeleteVertexArrays, )
  OGLM_AVAIL_CHECK(__glewDeleteVertexArrays, glDeleteVertexArrays)
  GLsizei n = items;
  GLuint* arrays = OGLM_GET_VARARGS(arrays,0,GLuint,UV,n);
  glDeleteVertexArrays((GLsizei )n, (const GLuint* )arrays);
  OGLM_CHECK_ERR(glDeleteVertexArrays, free(arrays);)
  free(arrays);

void
glDeleteVertexArraysOES_c(n, arrays)
  GLsizei n;
  const GLuint* arrays;
CODE:
  OGLM_GLEWINIT
  OGLM_CHECK_ERR(glDeleteVertexArraysOES, )
  OGLM_AVAIL_CHECK(__glewDeleteVertexArraysOES, glDeleteVertexArraysOES)
  glDeleteVertexArraysOES(n, arrays);
  OGLM_CHECK_ERR(glDeleteVertexArraysOES, )

void
glDeleteVertexArraysSGIX_c(n, arrays)
  GLsizei n;
  const GLuint* arrays;
CODE:
  OGLM_GLEWINIT
  OGLM_CHECK_ERR(glDeleteVertexArraysSGIX, )
  OGLM_AVAIL_CHECK(__glewDeleteVertexArraysSGIX, glDeleteVertexArraysSGIX)
  glDeleteVertexArraysSGIX(n, arrays);
  OGLM_CHECK_ERR(glDeleteVertexArraysSGIX, )

void
glDeleteVertexShaderEXT(id)
  GLuint id;
CODE:
  OGLM_GLEWINIT
  OGLM_CHECK_ERR(glDeleteVertexShaderEXT, )
  OGLM_AVAIL_CHECK(__glewDeleteVertexShaderEXT, glDeleteVertexShaderEXT)
  glDeleteVertexShaderEXT(id);
  OGLM_CHECK_ERR(glDeleteVertexShaderEXT, )

void
glDepthBoundsEXT(zmin, zmax)
  GLclampd zmin;
  GLclampd zmax;
CODE:
  OGLM_GLEWINIT
  OGLM_CHECK_ERR(glDepthBoundsEXT, )
  OGLM_AVAIL_CHECK(__glewDepthBoundsEXT, glDepthBoundsEXT)
  glDepthBoundsEXT(zmin, zmax);
  OGLM_CHECK_ERR(glDepthBoundsEXT, )

void
glDepthBoundsdNV(zmin, zmax)
  GLdouble zmin;
  GLdouble zmax;
CODE:
  OGLM_GLEWINIT
  OGLM_CHECK_ERR(glDepthBoundsdNV, )
  OGLM_AVAIL_CHECK(__glewDepthBoundsdNV, glDepthBoundsdNV)
  glDepthBoundsdNV(zmin, zmax);
  OGLM_CHECK_ERR(glDepthBoundsdNV, )

void
glDepthFunc(func)
  GLenum func;
CODE:
  OGLM_GLEWINIT
  OGLM_CHECK_ERR(glDepthFunc, )
  glDepthFunc(func);
  OGLM_CHECK_ERR(glDepthFunc, )

void
glDepthMask(flag)
  GLboolean flag;
CODE:
  OGLM_GLEWINIT
  OGLM_CHECK_ERR(glDepthMask, )
  glDepthMask(flag);
  OGLM_CHECK_ERR(glDepthMask, )

void
glDepthRange(zNear, zFar)
  GLclampd zNear;
  GLclampd zFar;
CODE:
  OGLM_GLEWINIT
  OGLM_CHECK_ERR(glDepthRange, )
  glDepthRange(zNear, zFar);
  OGLM_CHECK_ERR(glDepthRange, )

void
glDepthRangeArrayfvNV_c(first, count, v)
  GLuint first;
  GLsizei count;
  const GLfloat * v;
CODE:
  OGLM_GLEWINIT
  OGLM_CHECK_ERR(glDepthRangeArrayfvNV, )
  OGLM_AVAIL_CHECK(__glewDepthRangeArrayfvNV, glDepthRangeArrayfvNV)
  glDepthRangeArrayfvNV(first, count, v);
  OGLM_CHECK_ERR(glDepthRangeArrayfvNV, )

void
glDepthRangeArrayv_c(first, count, v)
  GLuint first;
  GLsizei count;
  const GLclampd * v;
CODE:
  OGLM_GLEWINIT
  OGLM_CHECK_ERR(glDepthRangeArrayv, )
  OGLM_AVAIL_CHECK(__glewDepthRangeArrayv, glDepthRangeArrayv)
  glDepthRangeArrayv(first, count, v);
  OGLM_CHECK_ERR(glDepthRangeArrayv, )

void
glDepthRangeArrayv_p(first, ...)
  GLuint first;
CODE:
  OGLM_GLEWINIT
  OGLM_CHECK_ERR(glDepthRangeArrayv, )
  OGLM_AVAIL_CHECK(__glewDepthRangeArrayv, glDepthRangeArrayv)
  GLsizei count = items-1;
  GLclampd * v = OGLM_GET_VARARGS(v,1,GLclampd,NV,count);
  glDepthRangeArrayv((GLuint )first, (GLsizei )count, (const GLclampd * )v);
  OGLM_CHECK_ERR(glDepthRangeArrayv, free(v);)
  free(v);

void
glDepthRangeIndexed(index, n, f)
  GLuint index;
  GLclampd n;
  GLclampd f;
CODE:
  OGLM_GLEWINIT
  OGLM_CHECK_ERR(glDepthRangeIndexed, )
  OGLM_AVAIL_CHECK(__glewDepthRangeIndexed, glDepthRangeIndexed)
  glDepthRangeIndexed(index, n, f);
  OGLM_CHECK_ERR(glDepthRangeIndexed, )

void
glDepthRangeIndexedfNV(index, n, f)
  GLuint index;
  GLfloat n;
  GLfloat f;
CODE:
  OGLM_GLEWINIT
  OGLM_CHECK_ERR(glDepthRangeIndexedfNV, )
  OGLM_AVAIL_CHECK(__glewDepthRangeIndexedfNV, glDepthRangeIndexedfNV)
  glDepthRangeIndexedfNV(index, n, f);
  OGLM_CHECK_ERR(glDepthRangeIndexedfNV, )

void
glDepthRangedNV(zNear, zFar)
  GLdouble zNear;
  GLdouble zFar;
CODE:
  OGLM_GLEWINIT
  OGLM_CHECK_ERR(glDepthRangedNV, )
  OGLM_AVAIL_CHECK(__glewDepthRangedNV, glDepthRangedNV)
  glDepthRangedNV(zNear, zFar);
  OGLM_CHECK_ERR(glDepthRangedNV, )

void
glDepthRangef(n, f)
  GLclampf n;
  GLclampf f;
CODE:
  OGLM_GLEWINIT
  OGLM_CHECK_ERR(glDepthRangef, )
  OGLM_AVAIL_CHECK(__glewDepthRangef, glDepthRangef)
  glDepthRangef(n, f);
  OGLM_CHECK_ERR(glDepthRangef, )

void
glDepthRangefOES(n, f)
  GLclampf n;
  GLclampf f;
CODE:
  OGLM_GLEWINIT
  OGLM_CHECK_ERR(glDepthRangefOES, )
  OGLM_AVAIL_CHECK(__glewDepthRangefOES, glDepthRangefOES)
  glDepthRangefOES(n, f);
  OGLM_CHECK_ERR(glDepthRangefOES, )

void
glDepthRangex(zNear, zFar)
  GLclampx zNear;
  GLclampx zFar;
CODE:
  OGLM_GLEWINIT
  OGLM_CHECK_ERR(glDepthRangex, )
  OGLM_AVAIL_CHECK(__glewDepthRangex, glDepthRangex)
  glDepthRangex(zNear, zFar);
  OGLM_CHECK_ERR(glDepthRangex, )

void
glDetachObjectARB(containerObj, attachedObj)
  GLhandleARB containerObj;
  GLhandleARB attachedObj;
CODE:
  OGLM_GLEWINIT
  OGLM_CHECK_ERR(glDetachObjectARB, )
  OGLM_AVAIL_CHECK(__glewDetachObjectARB, glDetachObjectARB)
  glDetachObjectARB(containerObj, attachedObj);
  OGLM_CHECK_ERR(glDetachObjectARB, )

void
glDetachShader(program, shader)
  GLuint program;
  GLuint shader;
CODE:
  OGLM_GLEWINIT
  OGLM_CHECK_ERR(glDetachShader, )
  OGLM_AVAIL_CHECK(__glewDetachShader, glDetachShader)
  glDetachShader(program, shader);
  OGLM_CHECK_ERR(glDetachShader, )

void
glDetailTexFuncSGIS_c(target, n, points)
  GLenum target;
  GLsizei n;
  const GLfloat* points;
CODE:
  OGLM_GLEWINIT
  OGLM_CHECK_ERR(glDetailTexFuncSGIS, )
  OGLM_AVAIL_CHECK(__glewDetailTexFuncSGIS, glDetailTexFuncSGIS)
  glDetailTexFuncSGIS(target, n, points);
  OGLM_CHECK_ERR(glDetailTexFuncSGIS, )

void
glDetailTexFuncSGIS_p(target, n, ...)
  GLenum target;
  GLsizei n;
CODE:
  OGLM_GLEWINIT
  OGLM_CHECK_ERR(glDetailTexFuncSGIS, )
  OGLM_AVAIL_CHECK(__glewDetailTexFuncSGIS, glDetailTexFuncSGIS)
  GLfloat* points = OGLM_GET_VARARGS(points,2,GLfloat,NV,n*2);
  glDetailTexFuncSGIS((GLenum )target, (GLsizei )n, (const GLfloat* )points);
  OGLM_CHECK_ERR(glDetailTexFuncSGIS, free(points);)
  free(points);

void
glDisable(cap)
  GLenum cap;
CODE:
  OGLM_GLEWINIT
  OGLM_CHECK_ERR(glDisable, )
  glDisable(cap);
  OGLM_CHECK_ERR(glDisable, )

void
glDisableClientState(array)
  GLenum array;
CODE:
  OGLM_GLEWINIT
  OGLM_CHECK_ERR(glDisableClientState, )
  glDisableClientState(array);
  OGLM_CHECK_ERR(glDisableClientState, )

void
glDisableClientStateIndexedEXT(array, index)
  GLenum array;
  GLuint index;
CODE:
  OGLM_GLEWINIT
  OGLM_CHECK_ERR(glDisableClientStateIndexedEXT, )
  OGLM_AVAIL_CHECK(__glewDisableClientStateIndexedEXT, glDisableClientStateIndexedEXT)
  glDisableClientStateIndexedEXT(array, index);
  OGLM_CHECK_ERR(glDisableClientStateIndexedEXT, )

void
glDisableClientStateiEXT(array, index)
  GLenum array;
  GLuint index;
CODE:
  OGLM_GLEWINIT
  OGLM_CHECK_ERR(glDisableClientStateiEXT, )
  OGLM_AVAIL_CHECK(__glewDisableClientStateiEXT, glDisableClientStateiEXT)
  glDisableClientStateiEXT(array, index);
  OGLM_CHECK_ERR(glDisableClientStateiEXT, )

void
glDisableDriverControlQCOM(driverControl)
  GLuint driverControl;
CODE:
  OGLM_GLEWINIT
  OGLM_CHECK_ERR(glDisableDriverControlQCOM, )
  OGLM_AVAIL_CHECK(__glewDisableDriverControlQCOM, glDisableDriverControlQCOM)
  glDisableDriverControlQCOM(driverControl);
  OGLM_CHECK_ERR(glDisableDriverControlQCOM, )

void
glDisableVariantClientStateEXT(id)
  GLuint id;
CODE:
  OGLM_GLEWINIT
  OGLM_CHECK_ERR(glDisableVariantClientStateEXT, )
  OGLM_AVAIL_CHECK(__glewDisableVariantClientStateEXT, glDisableVariantClientStateEXT)
  glDisableVariantClientStateEXT(id);
  OGLM_CHECK_ERR(glDisableVariantClientStateEXT, )

void
glDisableVertexArrayAttrib(vaobj, index)
  GLuint vaobj;
  GLuint index;
CODE:
  OGLM_GLEWINIT
  OGLM_CHECK_ERR(glDisableVertexArrayAttrib, )
  OGLM_AVAIL_CHECK(__glewDisableVertexArrayAttrib, glDisableVertexArrayAttrib)
  glDisableVertexArrayAttrib(vaobj, index);
  OGLM_CHECK_ERR(glDisableVertexArrayAttrib, )

void
glDisableVertexArrayAttribEXT(vaobj, index)
  GLuint vaobj;
  GLuint index;
CODE:
  OGLM_GLEWINIT
  OGLM_CHECK_ERR(glDisableVertexArrayAttribEXT, )
  OGLM_AVAIL_CHECK(__glewDisableVertexArrayAttribEXT, glDisableVertexArrayAttribEXT)
  glDisableVertexArrayAttribEXT(vaobj, index);
  OGLM_CHECK_ERR(glDisableVertexArrayAttribEXT, )

void
glDisableVertexArrayEXT(vaobj, array)
  GLuint vaobj;
  GLenum array;
CODE:
  OGLM_GLEWINIT
  OGLM_CHECK_ERR(glDisableVertexArrayEXT, )
  OGLM_AVAIL_CHECK(__glewDisableVertexArrayEXT, glDisableVertexArrayEXT)
  glDisableVertexArrayEXT(vaobj, array);
  OGLM_CHECK_ERR(glDisableVertexArrayEXT, )

void
glDisableVertexAttribAPPLE(index, pname)
  GLuint index;
  GLenum pname;
CODE:
  OGLM_GLEWINIT
  OGLM_CHECK_ERR(glDisableVertexAttribAPPLE, )
  OGLM_AVAIL_CHECK(__glewDisableVertexAttribAPPLE, glDisableVertexAttribAPPLE)
  glDisableVertexAttribAPPLE(index, pname);
  OGLM_CHECK_ERR(glDisableVertexAttribAPPLE, )

void
glDisableVertexAttribArray(index)
  GLuint index;
ALIAS:
  glDisableVertexAttribArrayARB = 1
CODE:
  OGLM_GLEWINIT
  OGLM_CHECK_ERR(glDisableVertexAttribArray, )
  OGLM_AVAIL_CHECK(__glewDisableVertexAttribArray, glDisableVertexAttribArray)
  glDisableVertexAttribArray(index);
  OGLM_CHECK_ERR(glDisableVertexAttribArray, )

void
glDisablei(target, index)
  GLenum target;
  GLuint index;
ALIAS:
  glDisableIndexedEXT = 1
  glDisableiEXT = 2
  glDisableiNV = 3
CODE:
  OGLM_GLEWINIT
  OGLM_CHECK_ERR(glDisablei, )
  OGLM_AVAIL_CHECK(__glewDisablei, glDisablei)
  glDisablei(target, index);
  OGLM_CHECK_ERR(glDisablei, )

void
glDisableiOES(target, index)
  GLenum target;
  GLuint index;
CODE:
  OGLM_GLEWINIT
  OGLM_CHECK_ERR(glDisableiOES, )
  OGLM_AVAIL_CHECK(__glewDisableiOES, glDisableiOES)
  glDisableiOES(target, index);
  OGLM_CHECK_ERR(glDisableiOES, )

void
glDiscardFramebufferEXT_c(target, numAttachments, attachments)
  GLenum target;
  GLsizei numAttachments;
  const GLenum* attachments;
CODE:
  OGLM_GLEWINIT
  OGLM_CHECK_ERR(glDiscardFramebufferEXT, )
  OGLM_AVAIL_CHECK(__glewDiscardFramebufferEXT, glDiscardFramebufferEXT)
  glDiscardFramebufferEXT(target, numAttachments, attachments);
  OGLM_CHECK_ERR(glDiscardFramebufferEXT, )

void
glDiscardFramebufferEXT_p(target, ...)
  GLenum target;
CODE:
  OGLM_GLEWINIT
  OGLM_CHECK_ERR(glDiscardFramebufferEXT, )
  OGLM_AVAIL_CHECK(__glewDiscardFramebufferEXT, glDiscardFramebufferEXT)
  GLsizei numAttachments = items-1;
  GLenum* attachments = OGLM_GET_VARARGS(attachments,1,GLenum,IV,numAttachments);
  glDiscardFramebufferEXT((GLenum )target, (GLsizei )numAttachments, (const GLenum* )attachments);
  OGLM_CHECK_ERR(glDiscardFramebufferEXT, free(attachments);)
  free(attachments);

void
glDispatchCompute(num_groups_x, num_groups_y, num_groups_z)
  GLuint num_groups_x;
  GLuint num_groups_y;
  GLuint num_groups_z;
CODE:
  OGLM_GLEWINIT
  OGLM_CHECK_ERR(glDispatchCompute, )
  OGLM_AVAIL_CHECK(__glewDispatchCompute, glDispatchCompute)
  glDispatchCompute(num_groups_x, num_groups_y, num_groups_z);
  OGLM_CHECK_ERR(glDispatchCompute, )

void
glDispatchComputeGroupSizeARB(num_groups_x, num_groups_y, num_groups_z, group_size_x, group_size_y, group_size_z)
  GLuint num_groups_x;
  GLuint num_groups_y;
  GLuint num_groups_z;
  GLuint group_size_x;
  GLuint group_size_y;
  GLuint group_size_z;
CODE:
  OGLM_GLEWINIT
  OGLM_CHECK_ERR(glDispatchComputeGroupSizeARB, )
  OGLM_AVAIL_CHECK(__glewDispatchComputeGroupSizeARB, glDispatchComputeGroupSizeARB)
  glDispatchComputeGroupSizeARB(num_groups_x, num_groups_y, num_groups_z, group_size_x, group_size_y, group_size_z);
  OGLM_CHECK_ERR(glDispatchComputeGroupSizeARB, )

void
glDispatchComputeIndirect(indirect)
  GLintptr indirect;
CODE:
  OGLM_GLEWINIT
  OGLM_CHECK_ERR(glDispatchComputeIndirect, )
  OGLM_AVAIL_CHECK(__glewDispatchComputeIndirect, glDispatchComputeIndirect)
  glDispatchComputeIndirect(indirect);
  OGLM_CHECK_ERR(glDispatchComputeIndirect, )

void
glDrawArrays(mode, first, count)
  GLenum mode;
  GLint first;
  GLsizei count;
ALIAS:
  glDrawArraysEXT = 1
CODE:
  OGLM_GLEWINIT
  OGLM_CHECK_ERR(glDrawArrays, )
  glDrawArrays(mode, first, count);
  OGLM_CHECK_ERR(glDrawArrays, )

void
glDrawArraysIndirect_c(mode, indirect)
  GLenum mode;
  const void *indirect;
CODE:
  OGLM_GLEWINIT
  OGLM_CHECK_ERR(glDrawArraysIndirect, )
  OGLM_AVAIL_CHECK(__glewDrawArraysIndirect, glDrawArraysIndirect)
  glDrawArraysIndirect(mode, indirect);
  OGLM_CHECK_ERR(glDrawArraysIndirect, )

void
glDrawArraysInstanced(mode, first, count, instancecount)
  GLenum mode;
  GLint first;
  GLsizei count;
  GLsizei instancecount;
ALIAS:
  glDrawArraysInstancedANGLE = 1
  glDrawArraysInstancedARB = 2
  glDrawArraysInstancedEXT = 3
  glDrawArraysInstancedNV = 4
CODE:
  OGLM_GLEWINIT
  OGLM_CHECK_ERR(glDrawArraysInstanced, )
  OGLM_AVAIL_CHECK(__glewDrawArraysInstanced, glDrawArraysInstanced)
  glDrawArraysInstanced(mode, first, count, instancecount);
  OGLM_CHECK_ERR(glDrawArraysInstanced, )

void
glDrawArraysInstancedBaseInstance(mode, first, count, instancecount, baseinstance)
  GLenum mode;
  GLint first;
  GLsizei count;
  GLsizei instancecount;
  GLuint baseinstance;
ALIAS:
  glDrawArraysInstancedBaseInstanceEXT = 1
CODE:
  OGLM_GLEWINIT
  OGLM_CHECK_ERR(glDrawArraysInstancedBaseInstance, )
  OGLM_AVAIL_CHECK(__glewDrawArraysInstancedBaseInstance, glDrawArraysInstancedBaseInstance)
  glDrawArraysInstancedBaseInstance(mode, first, count, instancecount, baseinstance);
  OGLM_CHECK_ERR(glDrawArraysInstancedBaseInstance, )

void
glDrawBuffer(buf)
  GLenum buf;
CODE:
  OGLM_GLEWINIT
  OGLM_CHECK_ERR(glDrawBuffer, )
  glDrawBuffer(buf);
  OGLM_CHECK_ERR(glDrawBuffer, )

void
glDrawBufferRegion(region, x, y, width, height, xDest, yDest)
  GLuint region;
  GLint x;
  GLint y;
  GLsizei width;
  GLsizei height;
  GLint xDest;
  GLint yDest;
CODE:
  OGLM_GLEWINIT
  OGLM_CHECK_ERR(glDrawBufferRegion, )
  OGLM_AVAIL_CHECK(__glewDrawBufferRegion, glDrawBufferRegion)
  glDrawBufferRegion(region, x, y, width, height, xDest, yDest);
  OGLM_CHECK_ERR(glDrawBufferRegion, )

void
glDrawBuffers_c(n, bufs)
  GLsizei n;
  const GLenum* bufs;
ALIAS:
  glDrawBuffersARB_c = 1
  glDrawBuffersATI_c = 2
  glDrawBuffersEXT_c = 3
CODE:
  OGLM_GLEWINIT
  OGLM_CHECK_ERR(glDrawBuffers, )
  OGLM_AVAIL_CHECK(__glewDrawBuffers, glDrawBuffers)
  glDrawBuffers(n, bufs);
  OGLM_CHECK_ERR(glDrawBuffers, )

void
glDrawBuffers_p(...)
ALIAS:
  glDrawBuffersARB_p = 1
  glDrawBuffersATI_p = 2
  glDrawBuffersEXT_p = 3
CODE:
  OGLM_GLEWINIT
  OGLM_CHECK_ERR(glDrawBuffers, )
  OGLM_AVAIL_CHECK(__glewDrawBuffers, glDrawBuffers)
  GLsizei n = items;
  GLenum* bufs = OGLM_GET_VARARGS(bufs,0,GLenum,IV,n);
  glDrawBuffers((GLsizei )n, (const GLenum* )bufs);
  OGLM_CHECK_ERR(glDrawBuffers, free(bufs);)
  free(bufs);

void
glDrawBuffersIndexedEXT_c(n, location, indices)
  GLint n;
  const GLenum* location;
  const GLint *indices;
CODE:
  OGLM_GLEWINIT
  OGLM_CHECK_ERR(glDrawBuffersIndexedEXT, )
  OGLM_AVAIL_CHECK(__glewDrawBuffersIndexedEXT, glDrawBuffersIndexedEXT)
  glDrawBuffersIndexedEXT(n, location, indices);
  OGLM_CHECK_ERR(glDrawBuffersIndexedEXT, )

void
glDrawBuffersIndexedEXT_p(locationSV, indicesSV)
  SV *locationSV;
  SV *indicesSV;
CODE:
  OGLM_GLEWINIT
  OGLM_CHECK_ERR(glDrawBuffersIndexedEXT, )
  OGLM_AVAIL_CHECK(__glewDrawBuffersIndexedEXT, glDrawBuffersIndexedEXT)
  GLint n = OGLM_LEN_ARRAY(n, location);
  GLint *indices = OGLM_GET_ARRAY(indices, GLint, IV, n);
  GLenum* location = OGLM_GET_ARRAY(location, GLenum, IV, n);
  glDrawBuffersIndexedEXT((GLint )n, (const GLenum* )location, (const GLint *)indices);
  OGLM_CHECK_ERR(glDrawBuffersIndexedEXT, free(indices);free(location);)
  free(indices);free(location);

void
glDrawBuffersNV_c(n, bufs)
  GLsizei n;
  const GLenum* bufs;
CODE:
  OGLM_GLEWINIT
  OGLM_CHECK_ERR(glDrawBuffersNV, )
  OGLM_AVAIL_CHECK(__glewDrawBuffersNV, glDrawBuffersNV)
  glDrawBuffersNV(n, bufs);
  OGLM_CHECK_ERR(glDrawBuffersNV, )

void
glDrawBuffersNV_p(...)
CODE:
  OGLM_GLEWINIT
  OGLM_CHECK_ERR(glDrawBuffersNV, )
  OGLM_AVAIL_CHECK(__glewDrawBuffersNV, glDrawBuffersNV)
  GLsizei n = items;
  GLenum* bufs = OGLM_GET_VARARGS(bufs,0,GLenum,IV,n);
  glDrawBuffersNV((GLsizei )n, (const GLenum* )bufs);
  OGLM_CHECK_ERR(glDrawBuffersNV, free(bufs);)
  free(bufs);

void
glDrawCommandsAddressNV_c(primitiveMode, indirects, sizes, count)
  GLenum primitiveMode;
  const GLuint64* indirects;
  const GLsizei* sizes;
  GLuint count;
CODE:
  OGLM_GLEWINIT
  OGLM_CHECK_ERR(glDrawCommandsAddressNV, )
  OGLM_AVAIL_CHECK(__glewDrawCommandsAddressNV, glDrawCommandsAddressNV)
  glDrawCommandsAddressNV(primitiveMode, indirects, sizes, count);
  OGLM_CHECK_ERR(glDrawCommandsAddressNV, )

void
glDrawCommandsNV_c(primitiveMode, buffer, indirects, sizes, count)
  GLenum primitiveMode;
  GLuint buffer;
  const GLintptr* indirects;
  const GLsizei* sizes;
  GLuint count;
CODE:
  OGLM_GLEWINIT
  OGLM_CHECK_ERR(glDrawCommandsNV, )
  OGLM_AVAIL_CHECK(__glewDrawCommandsNV, glDrawCommandsNV)
  glDrawCommandsNV(primitiveMode, buffer, indirects, sizes, count);
  OGLM_CHECK_ERR(glDrawCommandsNV, )

void
glDrawCommandsStatesAddressNV_c(indirects, sizes, states, fbos, count)
  const GLuint64* indirects;
  const GLsizei* sizes;
  const GLuint* states;
  const GLuint* fbos;
  GLuint count;
CODE:
  OGLM_GLEWINIT
  OGLM_CHECK_ERR(glDrawCommandsStatesAddressNV, )
  OGLM_AVAIL_CHECK(__glewDrawCommandsStatesAddressNV, glDrawCommandsStatesAddressNV)
  glDrawCommandsStatesAddressNV(indirects, sizes, states, fbos, count);
  OGLM_CHECK_ERR(glDrawCommandsStatesAddressNV, )

void
glDrawCommandsStatesNV_c(buffer, indirects, sizes, states, fbos, count)
  GLuint buffer;
  const GLintptr* indirects;
  const GLsizei* sizes;
  const GLuint* states;
  const GLuint* fbos;
  GLuint count;
CODE:
  OGLM_GLEWINIT
  OGLM_CHECK_ERR(glDrawCommandsStatesNV, )
  OGLM_AVAIL_CHECK(__glewDrawCommandsStatesNV, glDrawCommandsStatesNV)
  glDrawCommandsStatesNV(buffer, indirects, sizes, states, fbos, count);
  OGLM_CHECK_ERR(glDrawCommandsStatesNV, )

void
glDrawElementArrayAPPLE(mode, first, count)
  GLenum mode;
  GLint first;
  GLsizei count;
CODE:
  OGLM_GLEWINIT
  OGLM_CHECK_ERR(glDrawElementArrayAPPLE, )
  OGLM_AVAIL_CHECK(__glewDrawElementArrayAPPLE, glDrawElementArrayAPPLE)
  glDrawElementArrayAPPLE(mode, first, count);
  OGLM_CHECK_ERR(glDrawElementArrayAPPLE, )

void
glDrawElementArrayATI(mode, count)
  GLenum mode;
  GLsizei count;
CODE:
  OGLM_GLEWINIT
  OGLM_CHECK_ERR(glDrawElementArrayATI, )
  OGLM_AVAIL_CHECK(__glewDrawElementArrayATI, glDrawElementArrayATI)
  glDrawElementArrayATI(mode, count);
  OGLM_CHECK_ERR(glDrawElementArrayATI, )

void
glDrawElements_c(mode, count, type, indices)
  GLenum mode;
  GLsizei count;
  GLenum type;
  const void *indices;
CODE:
  OGLM_GLEWINIT
  OGLM_CHECK_ERR(glDrawElements, )
  glDrawElements(mode, count, type, indices);
  OGLM_CHECK_ERR(glDrawElements, )

void
glDrawElementsBaseVertex_c(mode, count, type, indices, basevertex)
  GLenum mode;
  GLsizei count;
  GLenum type;
  const void *indices;
  GLint basevertex;
ALIAS:
  glDrawElementsBaseVertexEXT_c = 1
CODE:
  OGLM_GLEWINIT
  OGLM_CHECK_ERR(glDrawElementsBaseVertex, )
  OGLM_AVAIL_CHECK(__glewDrawElementsBaseVertex, glDrawElementsBaseVertex)
  glDrawElementsBaseVertex(mode, count, type, indices, basevertex);
  OGLM_CHECK_ERR(glDrawElementsBaseVertex, )

void
glDrawElementsIndirect_c(mode, type, indirect)
  GLenum mode;
  GLenum type;
  const void *indirect;
CODE:
  OGLM_GLEWINIT
  OGLM_CHECK_ERR(glDrawElementsIndirect, )
  OGLM_AVAIL_CHECK(__glewDrawElementsIndirect, glDrawElementsIndirect)
  glDrawElementsIndirect(mode, type, indirect);
  OGLM_CHECK_ERR(glDrawElementsIndirect, )

void
glDrawElementsInstanced_c(mode, count, type, indices, instancecount)
  GLenum mode;
  GLsizei count;
  GLenum type;
  const void* indices;
  GLsizei instancecount;
ALIAS:
  glDrawElementsInstancedANGLE_c = 1
  glDrawElementsInstancedARB_c = 2
  glDrawElementsInstancedEXT_c = 3
  glDrawElementsInstancedNV_c = 4
CODE:
  OGLM_GLEWINIT
  OGLM_CHECK_ERR(glDrawElementsInstanced, )
  OGLM_AVAIL_CHECK(__glewDrawElementsInstanced, glDrawElementsInstanced)
  glDrawElementsInstanced(mode, count, type, indices, instancecount);
  OGLM_CHECK_ERR(glDrawElementsInstanced, )

void
glDrawElementsInstancedBaseInstance_c(mode, count, type, indices, instancecount, baseinstance)
  GLenum mode;
  GLsizei count;
  GLenum type;
  const void *indices;
  GLsizei instancecount;
  GLuint baseinstance;
ALIAS:
  glDrawElementsInstancedBaseInstanceEXT_c = 1
CODE:
  OGLM_GLEWINIT
  OGLM_CHECK_ERR(glDrawElementsInstancedBaseInstance, )
  OGLM_AVAIL_CHECK(__glewDrawElementsInstancedBaseInstance, glDrawElementsInstancedBaseInstance)
  glDrawElementsInstancedBaseInstance(mode, count, type, indices, instancecount, baseinstance);
  OGLM_CHECK_ERR(glDrawElementsInstancedBaseInstance, )

void
glDrawElementsInstancedBaseVertex_c(mode, count, type, indices, instancecount, basevertex)
  GLenum mode;
  GLsizei count;
  GLenum type;
  const void *indices;
  GLsizei instancecount;
  GLint basevertex;
ALIAS:
  glDrawElementsInstancedBaseVertexEXT_c = 1
CODE:
  OGLM_GLEWINIT
  OGLM_CHECK_ERR(glDrawElementsInstancedBaseVertex, )
  OGLM_AVAIL_CHECK(__glewDrawElementsInstancedBaseVertex, glDrawElementsInstancedBaseVertex)
  glDrawElementsInstancedBaseVertex(mode, count, type, indices, instancecount, basevertex);
  OGLM_CHECK_ERR(glDrawElementsInstancedBaseVertex, )

void
glDrawElementsInstancedBaseVertexBaseInstance_c(mode, count, type, indices, instancecount, basevertex, baseinstance)
  GLenum mode;
  GLsizei count;
  GLenum type;
  const void *indices;
  GLsizei instancecount;
  GLint basevertex;
  GLuint baseinstance;
ALIAS:
  glDrawElementsInstancedBaseVertexBaseInstanceEXT_c = 1
CODE:
  OGLM_GLEWINIT
  OGLM_CHECK_ERR(glDrawElementsInstancedBaseVertexBaseInstance, )
  OGLM_AVAIL_CHECK(__glewDrawElementsInstancedBaseVertexBaseInstance, glDrawElementsInstancedBaseVertexBaseInstance)
  glDrawElementsInstancedBaseVertexBaseInstance(mode, count, type, indices, instancecount, basevertex, baseinstance);
  OGLM_CHECK_ERR(glDrawElementsInstancedBaseVertexBaseInstance, )

void
glDrawMeshTasksEXT(num_groups_x, num_groups_y, num_groups_z)
  GLuint num_groups_x;
  GLuint num_groups_y;
  GLuint num_groups_z;
CODE:
  OGLM_GLEWINIT
  OGLM_CHECK_ERR(glDrawMeshTasksEXT, )
  OGLM_AVAIL_CHECK(__glewDrawMeshTasksEXT, glDrawMeshTasksEXT)
  glDrawMeshTasksEXT(num_groups_x, num_groups_y, num_groups_z);
  OGLM_CHECK_ERR(glDrawMeshTasksEXT, )

void
glDrawMeshTasksIndirectEXT(indirect)
  GLintptr indirect;
CODE:
  OGLM_GLEWINIT
  OGLM_CHECK_ERR(glDrawMeshTasksIndirectEXT, )
  OGLM_AVAIL_CHECK(__glewDrawMeshTasksIndirectEXT, glDrawMeshTasksIndirectEXT)
  glDrawMeshTasksIndirectEXT(indirect);
  OGLM_CHECK_ERR(glDrawMeshTasksIndirectEXT, )

void
glDrawMeshTasksIndirectNV(indirect)
  GLintptr indirect;
CODE:
  OGLM_GLEWINIT
  OGLM_CHECK_ERR(glDrawMeshTasksIndirectNV, )
  OGLM_AVAIL_CHECK(__glewDrawMeshTasksIndirectNV, glDrawMeshTasksIndirectNV)
  glDrawMeshTasksIndirectNV(indirect);
  OGLM_CHECK_ERR(glDrawMeshTasksIndirectNV, )

void
glDrawMeshTasksNV(first, count)
  GLuint first;
  GLuint count;
CODE:
  OGLM_GLEWINIT
  OGLM_CHECK_ERR(glDrawMeshTasksNV, )
  OGLM_AVAIL_CHECK(__glewDrawMeshTasksNV, glDrawMeshTasksNV)
  glDrawMeshTasksNV(first, count);
  OGLM_CHECK_ERR(glDrawMeshTasksNV, )

void
glDrawPixels_c(width, height, format, type, pixels)
  GLsizei width;
  GLsizei height;
  GLenum format;
  GLenum type;
  const void *pixels;
CODE:
  OGLM_GLEWINIT
  OGLM_CHECK_ERR(glDrawPixels, )
  glDrawPixels(width, height, format, type, pixels);
  OGLM_CHECK_ERR(glDrawPixels, )

void
glDrawRangeElementArrayAPPLE(mode, start, end, first, count)
  GLenum mode;
  GLuint start;
  GLuint end;
  GLint first;
  GLsizei count;
CODE:
  OGLM_GLEWINIT
  OGLM_CHECK_ERR(glDrawRangeElementArrayAPPLE, )
  OGLM_AVAIL_CHECK(__glewDrawRangeElementArrayAPPLE, glDrawRangeElementArrayAPPLE)
  glDrawRangeElementArrayAPPLE(mode, start, end, first, count);
  OGLM_CHECK_ERR(glDrawRangeElementArrayAPPLE, )

void
glDrawRangeElementArrayATI(mode, start, end, count)
  GLenum mode;
  GLuint start;
  GLuint end;
  GLsizei count;
CODE:
  OGLM_GLEWINIT
  OGLM_CHECK_ERR(glDrawRangeElementArrayATI, )
  OGLM_AVAIL_CHECK(__glewDrawRangeElementArrayATI, glDrawRangeElementArrayATI)
  glDrawRangeElementArrayATI(mode, start, end, count);
  OGLM_CHECK_ERR(glDrawRangeElementArrayATI, )

void
glDrawRangeElements_c(mode, start, end, count, type, indices)
  GLenum mode;
  GLuint start;
  GLuint end;
  GLsizei count;
  GLenum type;
  const void *indices;
ALIAS:
  glDrawRangeElementsEXT_c = 1
CODE:
  OGLM_GLEWINIT
  OGLM_CHECK_ERR(glDrawRangeElements, )
  OGLM_AVAIL_CHECK(__glewDrawRangeElements, glDrawRangeElements)
  glDrawRangeElements(mode, start, end, count, type, indices);
  OGLM_CHECK_ERR(glDrawRangeElements, )

void
glDrawRangeElementsBaseVertex_c(mode, start, end, count, type, indices, basevertex)
  GLenum mode;
  GLuint start;
  GLuint end;
  GLsizei count;
  GLenum type;
  const void *indices;
  GLint basevertex;
ALIAS:
  glDrawRangeElementsBaseVertexEXT_c = 1
CODE:
  OGLM_GLEWINIT
  OGLM_CHECK_ERR(glDrawRangeElementsBaseVertex, )
  OGLM_AVAIL_CHECK(__glewDrawRangeElementsBaseVertex, glDrawRangeElementsBaseVertex)
  glDrawRangeElementsBaseVertex(mode, start, end, count, type, indices, basevertex);
  OGLM_CHECK_ERR(glDrawRangeElementsBaseVertex, )

void
glDrawTextureNV(texture, sampler, x0, y0, x1, y1, z, s0, t0, s1, t1)
  GLuint texture;
  GLuint sampler;
  GLfloat x0;
  GLfloat y0;
  GLfloat x1;
  GLfloat y1;
  GLfloat z;
  GLfloat s0;
  GLfloat t0;
  GLfloat s1;
  GLfloat t1;
CODE:
  OGLM_GLEWINIT
  OGLM_CHECK_ERR(glDrawTextureNV, )
  OGLM_AVAIL_CHECK(__glewDrawTextureNV, glDrawTextureNV)
  glDrawTextureNV(texture, sampler, x0, y0, x1, y1, z, s0, t0, s1, t1);
  OGLM_CHECK_ERR(glDrawTextureNV, )

void
glDrawTransformFeedback(mode, id)
  GLenum mode;
  GLuint id;
ALIAS:
  glDrawTransformFeedbackEXT = 1
  glDrawTransformFeedbackNV = 2
CODE:
  OGLM_GLEWINIT
  OGLM_CHECK_ERR(glDrawTransformFeedback, )
  OGLM_AVAIL_CHECK(__glewDrawTransformFeedback, glDrawTransformFeedback)
  glDrawTransformFeedback(mode, id);
  OGLM_CHECK_ERR(glDrawTransformFeedback, )

void
glDrawTransformFeedbackInstanced(mode, id, instancecount)
  GLenum mode;
  GLuint id;
  GLsizei instancecount;
ALIAS:
  glDrawTransformFeedbackInstancedEXT = 1
CODE:
  OGLM_GLEWINIT
  OGLM_CHECK_ERR(glDrawTransformFeedbackInstanced, )
  OGLM_AVAIL_CHECK(__glewDrawTransformFeedbackInstanced, glDrawTransformFeedbackInstanced)
  glDrawTransformFeedbackInstanced(mode, id, instancecount);
  OGLM_CHECK_ERR(glDrawTransformFeedbackInstanced, )

void
glDrawTransformFeedbackStream(mode, id, stream)
  GLenum mode;
  GLuint id;
  GLuint stream;
CODE:
  OGLM_GLEWINIT
  OGLM_CHECK_ERR(glDrawTransformFeedbackStream, )
  OGLM_AVAIL_CHECK(__glewDrawTransformFeedbackStream, glDrawTransformFeedbackStream)
  glDrawTransformFeedbackStream(mode, id, stream);
  OGLM_CHECK_ERR(glDrawTransformFeedbackStream, )

void
glDrawTransformFeedbackStreamInstanced(mode, id, stream, instancecount)
  GLenum mode;
  GLuint id;
  GLuint stream;
  GLsizei instancecount;
CODE:
  OGLM_GLEWINIT
  OGLM_CHECK_ERR(glDrawTransformFeedbackStreamInstanced, )
  OGLM_AVAIL_CHECK(__glewDrawTransformFeedbackStreamInstanced, glDrawTransformFeedbackStreamInstanced)
  glDrawTransformFeedbackStreamInstanced(mode, id, stream, instancecount);
  OGLM_CHECK_ERR(glDrawTransformFeedbackStreamInstanced, )

void
glDrawVkImageNV(vkImage, sampler, x0, y0, x1, y1, z, s0, t0, s1, t1)
  GLuint64 vkImage;
  GLuint sampler;
  GLfloat x0;
  GLfloat y0;
  GLfloat x1;
  GLfloat y1;
  GLfloat z;
  GLfloat s0;
  GLfloat t0;
  GLfloat s1;
  GLfloat t1;
CODE:
  OGLM_GLEWINIT
  OGLM_CHECK_ERR(glDrawVkImageNV, )
  OGLM_AVAIL_CHECK(__glewDrawVkImageNV, glDrawVkImageNV)
  glDrawVkImageNV(vkImage, sampler, x0, y0, x1, y1, z, s0, t0, s1, t1);
  OGLM_CHECK_ERR(glDrawVkImageNV, )

void
glEGLImageTargetRenderbufferStorageOES(target, image)
  GLenum target;
  GLeglImageOES image;
CODE:
  OGLM_GLEWINIT
  OGLM_CHECK_ERR(glEGLImageTargetRenderbufferStorageOES, )
  OGLM_AVAIL_CHECK(__glewEGLImageTargetRenderbufferStorageOES, glEGLImageTargetRenderbufferStorageOES)
  glEGLImageTargetRenderbufferStorageOES(target, image);
  OGLM_CHECK_ERR(glEGLImageTargetRenderbufferStorageOES, )

void
glEGLImageTargetTexStorageEXT_c(target, image, attrib_list)
  GLenum target;
  GLeglImageOES image;
  const GLint* attrib_list;
CODE:
  OGLM_GLEWINIT
  OGLM_CHECK_ERR(glEGLImageTargetTexStorageEXT, )
  OGLM_AVAIL_CHECK(__glewEGLImageTargetTexStorageEXT, glEGLImageTargetTexStorageEXT)
  glEGLImageTargetTexStorageEXT(target, image, attrib_list);
  OGLM_CHECK_ERR(glEGLImageTargetTexStorageEXT, )

void
glEGLImageTargetTexture2DOES(target, image)
  GLenum target;
  GLeglImageOES image;
CODE:
  OGLM_GLEWINIT
  OGLM_CHECK_ERR(glEGLImageTargetTexture2DOES, )
  OGLM_AVAIL_CHECK(__glewEGLImageTargetTexture2DOES, glEGLImageTargetTexture2DOES)
  glEGLImageTargetTexture2DOES(target, image);
  OGLM_CHECK_ERR(glEGLImageTargetTexture2DOES, )

void
glEGLImageTargetTextureStorageEXT_c(texture, image, attrib_list)
  GLuint texture;
  GLeglImageOES image;
  const GLint* attrib_list;
CODE:
  OGLM_GLEWINIT
  OGLM_CHECK_ERR(glEGLImageTargetTextureStorageEXT, )
  OGLM_AVAIL_CHECK(__glewEGLImageTargetTextureStorageEXT, glEGLImageTargetTextureStorageEXT)
  glEGLImageTargetTextureStorageEXT(texture, image, attrib_list);
  OGLM_CHECK_ERR(glEGLImageTargetTextureStorageEXT, )

void
glEdgeFlag(flag)
  GLboolean flag;
CODE:
  OGLM_GLEWINIT
  OGLM_CHECK_ERR(glEdgeFlag, )
  glEdgeFlag(flag);
  OGLM_CHECK_ERR(glEdgeFlag, )

void
glEdgeFlagFormatNV(stride)
  GLsizei stride;
CODE:
  OGLM_GLEWINIT
  OGLM_CHECK_ERR(glEdgeFlagFormatNV, )
  OGLM_AVAIL_CHECK(__glewEdgeFlagFormatNV, glEdgeFlagFormatNV)
  glEdgeFlagFormatNV(stride);
  OGLM_CHECK_ERR(glEdgeFlagFormatNV, )

void
glEdgeFlagPointer_c(stride, pointer)
  GLsizei stride;
  const void *pointer;
CODE:
  OGLM_GLEWINIT
  OGLM_CHECK_ERR(glEdgeFlagPointer, )
  glEdgeFlagPointer(stride, pointer);
  OGLM_CHECK_ERR(glEdgeFlagPointer, )

void
glEdgeFlagPointerEXT_c(stride, count, pointer)
  GLsizei stride;
  GLsizei count;
  const GLboolean* pointer;
CODE:
  OGLM_GLEWINIT
  OGLM_CHECK_ERR(glEdgeFlagPointerEXT, )
  OGLM_AVAIL_CHECK(__glewEdgeFlagPointerEXT, glEdgeFlagPointerEXT)
  glEdgeFlagPointerEXT(stride, count, pointer);
  OGLM_CHECK_ERR(glEdgeFlagPointerEXT, )

void
glEdgeFlagPointerListIBM_c(stride, pointer, ptrstride)
  GLint stride;
  const GLboolean ** pointer;
  GLint ptrstride;
CODE:
  OGLM_GLEWINIT
  OGLM_CHECK_ERR(glEdgeFlagPointerListIBM, )
  OGLM_AVAIL_CHECK(__glewEdgeFlagPointerListIBM, glEdgeFlagPointerListIBM)
  glEdgeFlagPointerListIBM(stride, pointer, ptrstride);
  OGLM_CHECK_ERR(glEdgeFlagPointerListIBM, )

void
glEdgeFlagv_c(flag)
  const GLboolean *flag;
CODE:
  OGLM_GLEWINIT
  OGLM_CHECK_ERR(glEdgeFlagv, )
  glEdgeFlagv(flag);
  OGLM_CHECK_ERR(glEdgeFlagv, )

void
glEdgeFlagv_p(...)
CODE:
  OGLM_GLEWINIT
  OGLM_CHECK_ERR(glEdgeFlagv, )
  GLboolean *flag = OGLM_GET_VARARGS(flag,0,GLboolean,IV,1);
  glEdgeFlagv((const GLboolean *)flag);
  OGLM_CHECK_ERR(glEdgeFlagv, free(flag);)
  free(flag);

void
glElementPointerAPPLE_c(type, pointer)
  GLenum type;
  const void *pointer;
CODE:
  OGLM_GLEWINIT
  OGLM_CHECK_ERR(glElementPointerAPPLE, )
  OGLM_AVAIL_CHECK(__glewElementPointerAPPLE, glElementPointerAPPLE)
  glElementPointerAPPLE(type, pointer);
  OGLM_CHECK_ERR(glElementPointerAPPLE, )

void
glElementPointerATI_c(type, pointer)
  GLenum type;
  const void *pointer;
CODE:
  OGLM_GLEWINIT
  OGLM_CHECK_ERR(glElementPointerATI, )
  OGLM_AVAIL_CHECK(__glewElementPointerATI, glElementPointerATI)
  glElementPointerATI(type, pointer);
  OGLM_CHECK_ERR(glElementPointerATI, )

void
glEnable(cap)
  GLenum cap;
CODE:
  OGLM_GLEWINIT
  OGLM_CHECK_ERR(glEnable, )
  glEnable(cap);
  OGLM_CHECK_ERR(glEnable, )

void
glEnableClientState(array)
  GLenum array;
CODE:
  OGLM_GLEWINIT
  OGLM_CHECK_ERR(glEnableClientState, )
  glEnableClientState(array);
  OGLM_CHECK_ERR(glEnableClientState, )

void
glEnableClientStateIndexedEXT(array, index)
  GLenum array;
  GLuint index;
CODE:
  OGLM_GLEWINIT
  OGLM_CHECK_ERR(glEnableClientStateIndexedEXT, )
  OGLM_AVAIL_CHECK(__glewEnableClientStateIndexedEXT, glEnableClientStateIndexedEXT)
  glEnableClientStateIndexedEXT(array, index);
  OGLM_CHECK_ERR(glEnableClientStateIndexedEXT, )

void
glEnableClientStateiEXT(array, index)
  GLenum array;
  GLuint index;
CODE:
  OGLM_GLEWINIT
  OGLM_CHECK_ERR(glEnableClientStateiEXT, )
  OGLM_AVAIL_CHECK(__glewEnableClientStateiEXT, glEnableClientStateiEXT)
  glEnableClientStateiEXT(array, index);
  OGLM_CHECK_ERR(glEnableClientStateiEXT, )

void
glEnableDriverControlQCOM(driverControl)
  GLuint driverControl;
CODE:
  OGLM_GLEWINIT
  OGLM_CHECK_ERR(glEnableDriverControlQCOM, )
  OGLM_AVAIL_CHECK(__glewEnableDriverControlQCOM, glEnableDriverControlQCOM)
  glEnableDriverControlQCOM(driverControl);
  OGLM_CHECK_ERR(glEnableDriverControlQCOM, )

void
glEnableVariantClientStateEXT(id)
  GLuint id;
CODE:
  OGLM_GLEWINIT
  OGLM_CHECK_ERR(glEnableVariantClientStateEXT, )
  OGLM_AVAIL_CHECK(__glewEnableVariantClientStateEXT, glEnableVariantClientStateEXT)
  glEnableVariantClientStateEXT(id);
  OGLM_CHECK_ERR(glEnableVariantClientStateEXT, )

void
glEnableVertexArrayAttrib(vaobj, index)
  GLuint vaobj;
  GLuint index;
CODE:
  OGLM_GLEWINIT
  OGLM_CHECK_ERR(glEnableVertexArrayAttrib, )
  OGLM_AVAIL_CHECK(__glewEnableVertexArrayAttrib, glEnableVertexArrayAttrib)
  glEnableVertexArrayAttrib(vaobj, index);
  OGLM_CHECK_ERR(glEnableVertexArrayAttrib, )

void
glEnableVertexArrayAttribEXT(vaobj, index)
  GLuint vaobj;
  GLuint index;
CODE:
  OGLM_GLEWINIT
  OGLM_CHECK_ERR(glEnableVertexArrayAttribEXT, )
  OGLM_AVAIL_CHECK(__glewEnableVertexArrayAttribEXT, glEnableVertexArrayAttribEXT)
  glEnableVertexArrayAttribEXT(vaobj, index);
  OGLM_CHECK_ERR(glEnableVertexArrayAttribEXT, )

void
glEnableVertexArrayEXT(vaobj, array)
  GLuint vaobj;
  GLenum array;
CODE:
  OGLM_GLEWINIT
  OGLM_CHECK_ERR(glEnableVertexArrayEXT, )
  OGLM_AVAIL_CHECK(__glewEnableVertexArrayEXT, glEnableVertexArrayEXT)
  glEnableVertexArrayEXT(vaobj, array);
  OGLM_CHECK_ERR(glEnableVertexArrayEXT, )

void
glEnableVertexAttribAPPLE(index, pname)
  GLuint index;
  GLenum pname;
CODE:
  OGLM_GLEWINIT
  OGLM_CHECK_ERR(glEnableVertexAttribAPPLE, )
  OGLM_AVAIL_CHECK(__glewEnableVertexAttribAPPLE, glEnableVertexAttribAPPLE)
  glEnableVertexAttribAPPLE(index, pname);
  OGLM_CHECK_ERR(glEnableVertexAttribAPPLE, )

void
glEnableVertexAttribArray(index)
  GLuint index;
ALIAS:
  glEnableVertexAttribArrayARB = 1
CODE:
  OGLM_GLEWINIT
  OGLM_CHECK_ERR(glEnableVertexAttribArray, )
  OGLM_AVAIL_CHECK(__glewEnableVertexAttribArray, glEnableVertexAttribArray)
  glEnableVertexAttribArray(index);
  OGLM_CHECK_ERR(glEnableVertexAttribArray, )

void
glEnablei(target, index)
  GLenum target;
  GLuint index;
ALIAS:
  glEnableIndexedEXT = 1
  glEnableiEXT = 2
  glEnableiNV = 3
CODE:
  OGLM_GLEWINIT
  OGLM_CHECK_ERR(glEnablei, )
  OGLM_AVAIL_CHECK(__glewEnablei, glEnablei)
  glEnablei(target, index);
  OGLM_CHECK_ERR(glEnablei, )

void
glEnableiOES(target, index)
  GLenum target;
  GLuint index;
CODE:
  OGLM_GLEWINIT
  OGLM_CHECK_ERR(glEnableiOES, )
  OGLM_AVAIL_CHECK(__glewEnableiOES, glEnableiOES)
  glEnableiOES(target, index);
  OGLM_CHECK_ERR(glEnableiOES, )

void
glEnd()
CODE:
  OGLM_GLEWINIT
  OGLM_CHECK_ERR(glEnd, )
  glEnd();
  OGLM_CHECK_ERR(glEnd, )

void
glEndConditionalRender()
ALIAS:
  glEndConditionalRenderNV = 1
  glEndConditionalRenderNVX = 2
CODE:
  OGLM_GLEWINIT
  OGLM_CHECK_ERR(glEndConditionalRender, )
  OGLM_AVAIL_CHECK(__glewEndConditionalRender, glEndConditionalRender)
  glEndConditionalRender();
  OGLM_CHECK_ERR(glEndConditionalRender, )

void
glEndFragmentShaderATI()
CODE:
  OGLM_GLEWINIT
  OGLM_CHECK_ERR(glEndFragmentShaderATI, )
  OGLM_AVAIL_CHECK(__glewEndFragmentShaderATI, glEndFragmentShaderATI)
  glEndFragmentShaderATI();
  OGLM_CHECK_ERR(glEndFragmentShaderATI, )

void
glEndList()
CODE:
  OGLM_GLEWINIT
  OGLM_CHECK_ERR(glEndList, )
  glEndList();
  OGLM_CHECK_ERR(glEndList, )

void
glEndOcclusionQueryNV()
CODE:
  OGLM_GLEWINIT
  OGLM_CHECK_ERR(glEndOcclusionQueryNV, )
  OGLM_AVAIL_CHECK(__glewEndOcclusionQueryNV, glEndOcclusionQueryNV)
  glEndOcclusionQueryNV();
  OGLM_CHECK_ERR(glEndOcclusionQueryNV, )

void
glEndPerfMonitorAMD(monitor)
  GLuint monitor;
CODE:
  OGLM_GLEWINIT
  OGLM_CHECK_ERR(glEndPerfMonitorAMD, )
  OGLM_AVAIL_CHECK(__glewEndPerfMonitorAMD, glEndPerfMonitorAMD)
  glEndPerfMonitorAMD(monitor);
  OGLM_CHECK_ERR(glEndPerfMonitorAMD, )

void
glEndPerfQueryINTEL(queryHandle)
  GLuint queryHandle;
CODE:
  OGLM_GLEWINIT
  OGLM_CHECK_ERR(glEndPerfQueryINTEL, )
  OGLM_AVAIL_CHECK(__glewEndPerfQueryINTEL, glEndPerfQueryINTEL)
  glEndPerfQueryINTEL(queryHandle);
  OGLM_CHECK_ERR(glEndPerfQueryINTEL, )

void
glEndQuery(target)
  GLenum target;
ALIAS:
  glEndQueryARB = 1
CODE:
  OGLM_GLEWINIT
  OGLM_CHECK_ERR(glEndQuery, )
  OGLM_AVAIL_CHECK(__glewEndQuery, glEndQuery)
  glEndQuery(target);
  OGLM_CHECK_ERR(glEndQuery, )

void
glEndQueryANGLE(target)
  GLenum target;
CODE:
  OGLM_GLEWINIT
  OGLM_CHECK_ERR(glEndQueryANGLE, )
  OGLM_AVAIL_CHECK(__glewEndQueryANGLE, glEndQueryANGLE)
  glEndQueryANGLE(target);
  OGLM_CHECK_ERR(glEndQueryANGLE, )

void
glEndQueryEXT(target)
  GLenum target;
CODE:
  OGLM_GLEWINIT
  OGLM_CHECK_ERR(glEndQueryEXT, )
  OGLM_AVAIL_CHECK(__glewEndQueryEXT, glEndQueryEXT)
  glEndQueryEXT(target);
  OGLM_CHECK_ERR(glEndQueryEXT, )

void
glEndQueryIndexed(target, index)
  GLenum target;
  GLuint index;
CODE:
  OGLM_GLEWINIT
  OGLM_CHECK_ERR(glEndQueryIndexed, )
  OGLM_AVAIL_CHECK(__glewEndQueryIndexed, glEndQueryIndexed)
  glEndQueryIndexed(target, index);
  OGLM_CHECK_ERR(glEndQueryIndexed, )

void
glEndSceneEXT()
CODE:
  OGLM_GLEWINIT
  OGLM_CHECK_ERR(glEndSceneEXT, )
  OGLM_AVAIL_CHECK(__glewEndSceneEXT, glEndSceneEXT)
  glEndSceneEXT();
  OGLM_CHECK_ERR(glEndSceneEXT, )

void
glEndTilingQCOM(preserveMask)
  GLbitfield preserveMask;
CODE:
  OGLM_GLEWINIT
  OGLM_CHECK_ERR(glEndTilingQCOM, )
  OGLM_AVAIL_CHECK(__glewEndTilingQCOM, glEndTilingQCOM)
  glEndTilingQCOM(preserveMask);
  OGLM_CHECK_ERR(glEndTilingQCOM, )

void
glEndTransformFeedback()
ALIAS:
  glEndTransformFeedbackEXT = 1
  glEndTransformFeedbackNV = 2
CODE:
  OGLM_GLEWINIT
  OGLM_CHECK_ERR(glEndTransformFeedback, )
  OGLM_AVAIL_CHECK(__glewEndTransformFeedback, glEndTransformFeedback)
  glEndTransformFeedback();
  OGLM_CHECK_ERR(glEndTransformFeedback, )

void
glEndVertexShaderEXT()
CODE:
  OGLM_GLEWINIT
  OGLM_CHECK_ERR(glEndVertexShaderEXT, )
  OGLM_AVAIL_CHECK(__glewEndVertexShaderEXT, glEndVertexShaderEXT)
  glEndVertexShaderEXT();
  OGLM_CHECK_ERR(glEndVertexShaderEXT, )

void
glEndVideoCaptureNV(video_capture_slot)
  GLuint video_capture_slot;
CODE:
  OGLM_GLEWINIT
  OGLM_CHECK_ERR(glEndVideoCaptureNV, )
  OGLM_AVAIL_CHECK(__glewEndVideoCaptureNV, glEndVideoCaptureNV)
  glEndVideoCaptureNV(video_capture_slot);
  OGLM_CHECK_ERR(glEndVideoCaptureNV, )

void
glEvalCoord1d(u)
  GLdouble u;
CODE:
  OGLM_GLEWINIT
  OGLM_CHECK_ERR(glEvalCoord1d, )
  glEvalCoord1d(u);
  OGLM_CHECK_ERR(glEvalCoord1d, )

void
glEvalCoord1dv_c(u)
  const GLdouble *u;
CODE:
  OGLM_GLEWINIT
  OGLM_CHECK_ERR(glEvalCoord1dv, )
  glEvalCoord1dv(u);
  OGLM_CHECK_ERR(glEvalCoord1dv, )

void
glEvalCoord1dv_p(...)
CODE:
  OGLM_GLEWINIT
  OGLM_CHECK_ERR(glEvalCoord1dv, )
  GLdouble *u = OGLM_GET_VARARGS(u,0,GLdouble,NV,1);
  glEvalCoord1dv((const GLdouble *)u);
  OGLM_CHECK_ERR(glEvalCoord1dv, free(u);)
  free(u);

void
glEvalCoord1f(u)
  GLfloat u;
CODE:
  OGLM_GLEWINIT
  OGLM_CHECK_ERR(glEvalCoord1f, )
  glEvalCoord1f(u);
  OGLM_CHECK_ERR(glEvalCoord1f, )

void
glEvalCoord1fv_c(u)
  const GLfloat *u;
CODE:
  OGLM_GLEWINIT
  OGLM_CHECK_ERR(glEvalCoord1fv, )
  glEvalCoord1fv(u);
  OGLM_CHECK_ERR(glEvalCoord1fv, )

void
glEvalCoord1fv_p(...)
CODE:
  OGLM_GLEWINIT
  OGLM_CHECK_ERR(glEvalCoord1fv, )
  GLfloat *u = OGLM_GET_VARARGS(u,0,GLfloat,NV,1);
  glEvalCoord1fv((const GLfloat *)u);
  OGLM_CHECK_ERR(glEvalCoord1fv, free(u);)
  free(u);

void
glEvalCoord2d(u, v)
  GLdouble u;
  GLdouble v;
CODE:
  OGLM_GLEWINIT
  OGLM_CHECK_ERR(glEvalCoord2d, )
  glEvalCoord2d(u, v);
  OGLM_CHECK_ERR(glEvalCoord2d, )

void
glEvalCoord2dv_c(u)
  const GLdouble *u;
CODE:
  OGLM_GLEWINIT
  OGLM_CHECK_ERR(glEvalCoord2dv, )
  glEvalCoord2dv(u);
  OGLM_CHECK_ERR(glEvalCoord2dv, )

void
glEvalCoord2dv_p(...)
CODE:
  OGLM_GLEWINIT
  OGLM_CHECK_ERR(glEvalCoord2dv, )
  GLdouble *u = OGLM_GET_VARARGS(u,0,GLdouble,NV,2);
  glEvalCoord2dv((const GLdouble *)u);
  OGLM_CHECK_ERR(glEvalCoord2dv, free(u);)
  free(u);

void
glEvalCoord2f(u, v)
  GLfloat u;
  GLfloat v;
CODE:
  OGLM_GLEWINIT
  OGLM_CHECK_ERR(glEvalCoord2f, )
  glEvalCoord2f(u, v);
  OGLM_CHECK_ERR(glEvalCoord2f, )

void
glEvalCoord2fv_c(u)
  const GLfloat *u;
CODE:
  OGLM_GLEWINIT
  OGLM_CHECK_ERR(glEvalCoord2fv, )
  glEvalCoord2fv(u);
  OGLM_CHECK_ERR(glEvalCoord2fv, )

void
glEvalCoord2fv_p(...)
CODE:
  OGLM_GLEWINIT
  OGLM_CHECK_ERR(glEvalCoord2fv, )
  GLfloat *u = OGLM_GET_VARARGS(u,0,GLfloat,NV,2);
  glEvalCoord2fv((const GLfloat *)u);
  OGLM_CHECK_ERR(glEvalCoord2fv, free(u);)
  free(u);

void
glEvalMapsNV(target, mode)
  GLenum target;
  GLenum mode;
CODE:
  OGLM_GLEWINIT
  OGLM_CHECK_ERR(glEvalMapsNV, )
  OGLM_AVAIL_CHECK(__glewEvalMapsNV, glEvalMapsNV)
  glEvalMapsNV(target, mode);
  OGLM_CHECK_ERR(glEvalMapsNV, )

void
glEvalMesh1(mode, i1, i2)
  GLenum mode;
  GLint i1;
  GLint i2;
CODE:
  OGLM_GLEWINIT
  OGLM_CHECK_ERR(glEvalMesh1, )
  glEvalMesh1(mode, i1, i2);
  OGLM_CHECK_ERR(glEvalMesh1, )

void
glEvalMesh2(mode, i1, i2, j1, j2)
  GLenum mode;
  GLint i1;
  GLint i2;
  GLint j1;
  GLint j2;
CODE:
  OGLM_GLEWINIT
  OGLM_CHECK_ERR(glEvalMesh2, )
  glEvalMesh2(mode, i1, i2, j1, j2);
  OGLM_CHECK_ERR(glEvalMesh2, )

void
glEvalPoint1(i)
  GLint i;
CODE:
  OGLM_GLEWINIT
  OGLM_CHECK_ERR(glEvalPoint1, )
  glEvalPoint1(i);
  OGLM_CHECK_ERR(glEvalPoint1, )

void
glEvalPoint2(i, j)
  GLint i;
  GLint j;
CODE:
  OGLM_GLEWINIT
  OGLM_CHECK_ERR(glEvalPoint2, )
  glEvalPoint2(i, j);
  OGLM_CHECK_ERR(glEvalPoint2, )

void
glEvaluateDepthValuesARB()
CODE:
  OGLM_GLEWINIT
  OGLM_CHECK_ERR(glEvaluateDepthValuesARB, )
  OGLM_AVAIL_CHECK(__glewEvaluateDepthValuesARB, glEvaluateDepthValuesARB)
  glEvaluateDepthValuesARB();
  OGLM_CHECK_ERR(glEvaluateDepthValuesARB, )

void
glExecuteProgramNV_c(target, id, params)
  GLenum target;
  GLuint id;
  const GLfloat* params;
CODE:
  OGLM_GLEWINIT
  OGLM_CHECK_ERR(glExecuteProgramNV, )
  OGLM_AVAIL_CHECK(__glewExecuteProgramNV, glExecuteProgramNV)
  glExecuteProgramNV(target, id, params);
  OGLM_CHECK_ERR(glExecuteProgramNV, )

void
glExecuteProgramNV_p(target, id, ...)
  GLenum target;
  GLuint id;
CODE:
  OGLM_GLEWINIT
  OGLM_CHECK_ERR(glExecuteProgramNV, )
  OGLM_AVAIL_CHECK(__glewExecuteProgramNV, glExecuteProgramNV)
  GLfloat* params = OGLM_GET_VARARGS(params,2,GLfloat,NV,4);
  glExecuteProgramNV((GLenum )target, (GLuint )id, (const GLfloat* )params);
  OGLM_CHECK_ERR(glExecuteProgramNV, free(params);)
  free(params);

void
glExtGetBufferPointervQCOM_c(target, params)
  GLenum target;
  void** params;
CODE:
  OGLM_GLEWINIT
  OGLM_CHECK_ERR(glExtGetBufferPointervQCOM, )
  OGLM_AVAIL_CHECK(__glewExtGetBufferPointervQCOM, glExtGetBufferPointervQCOM)
  glExtGetBufferPointervQCOM(target, params);
  OGLM_CHECK_ERR(glExtGetBufferPointervQCOM, )

void
glExtGetBuffersQCOM_c(buffers, maxBuffers, numBuffers)
  GLuint* buffers;
  GLint maxBuffers;
  GLint* numBuffers;
CODE:
  OGLM_GLEWINIT
  OGLM_CHECK_ERR(glExtGetBuffersQCOM, )
  OGLM_AVAIL_CHECK(__glewExtGetBuffersQCOM, glExtGetBuffersQCOM)
  glExtGetBuffersQCOM(buffers, maxBuffers, numBuffers);
  OGLM_CHECK_ERR(glExtGetBuffersQCOM, )

void
glExtGetBuffersQCOM_p(maxBuffers)
  GLint maxBuffers;
PPCODE:
  OGLM_GLEWINIT
  OGLM_CHECK_ERR(glExtGetBuffersQCOM, )
  OGLM_AVAIL_CHECK(__glewExtGetBuffersQCOM, glExtGetBuffersQCOM)
  GLuint* buffers = OGLM_ALLOC(maxBuffers,GLuint,buffers);
  GLint numBuffers[1];
  glExtGetBuffersQCOM(buffers, maxBuffers, numBuffers);
  OGLM_CHECK_ERR(glExtGetBuffersQCOM, free(buffers);)
  EXTEND(sp, 2);
  OGLM_PUSH_ARRAY(glExtGetBuffersQCOM, newSVuv, buffers, maxBuffers)
  mPUSHs(newSViv(numBuffers[0]));
  free(buffers);

void
glExtGetFramebuffersQCOM_c(framebuffers, maxFramebuffers, numFramebuffers)
  GLuint* framebuffers;
  GLint maxFramebuffers;
  GLint* numFramebuffers;
CODE:
  OGLM_GLEWINIT
  OGLM_CHECK_ERR(glExtGetFramebuffersQCOM, )
  OGLM_AVAIL_CHECK(__glewExtGetFramebuffersQCOM, glExtGetFramebuffersQCOM)
  glExtGetFramebuffersQCOM(framebuffers, maxFramebuffers, numFramebuffers);
  OGLM_CHECK_ERR(glExtGetFramebuffersQCOM, )

void
glExtGetFramebuffersQCOM_p(maxFramebuffers)
  GLint maxFramebuffers;
PPCODE:
  OGLM_GLEWINIT
  OGLM_CHECK_ERR(glExtGetFramebuffersQCOM, )
  OGLM_AVAIL_CHECK(__glewExtGetFramebuffersQCOM, glExtGetFramebuffersQCOM)
  GLuint* framebuffers = OGLM_ALLOC(maxFramebuffers,GLuint,framebuffers);
  GLint numFramebuffers[1];
  glExtGetFramebuffersQCOM(framebuffers, maxFramebuffers, numFramebuffers);
  OGLM_CHECK_ERR(glExtGetFramebuffersQCOM, free(framebuffers);)
  EXTEND(sp, 2);
  OGLM_PUSH_ARRAY(glExtGetFramebuffersQCOM, newSVuv, framebuffers, maxFramebuffers)
  mPUSHs(newSViv(numFramebuffers[0]));
  free(framebuffers);

void
glExtGetProgramBinarySourceQCOM_c(program, shadertype, source, length)
  GLuint program;
  GLenum shadertype;
  GLchar* source;
  GLint* length;
CODE:
  OGLM_GLEWINIT
  OGLM_CHECK_ERR(glExtGetProgramBinarySourceQCOM, )
  OGLM_AVAIL_CHECK(__glewExtGetProgramBinarySourceQCOM, glExtGetProgramBinarySourceQCOM)
  glExtGetProgramBinarySourceQCOM(program, shadertype, source, length);
  OGLM_CHECK_ERR(glExtGetProgramBinarySourceQCOM, )

void
glExtGetProgramsQCOM_c(programs, maxPrograms, numPrograms)
  GLuint* programs;
  GLint maxPrograms;
  GLint* numPrograms;
CODE:
  OGLM_GLEWINIT
  OGLM_CHECK_ERR(glExtGetProgramsQCOM, )
  OGLM_AVAIL_CHECK(__glewExtGetProgramsQCOM, glExtGetProgramsQCOM)
  glExtGetProgramsQCOM(programs, maxPrograms, numPrograms);
  OGLM_CHECK_ERR(glExtGetProgramsQCOM, )

void
glExtGetProgramsQCOM_p(maxPrograms)
  GLint maxPrograms;
PPCODE:
  OGLM_GLEWINIT
  OGLM_CHECK_ERR(glExtGetProgramsQCOM, )
  OGLM_AVAIL_CHECK(__glewExtGetProgramsQCOM, glExtGetProgramsQCOM)
  GLuint* programs = OGLM_ALLOC(maxPrograms,GLuint,programs);
  GLint numPrograms[1];
  glExtGetProgramsQCOM(programs, maxPrograms, numPrograms);
  OGLM_CHECK_ERR(glExtGetProgramsQCOM, free(programs);)
  EXTEND(sp, 2);
  OGLM_PUSH_ARRAY(glExtGetProgramsQCOM, newSVuv, programs, maxPrograms)
  mPUSHs(newSViv(numPrograms[0]));
  free(programs);

void
glExtGetRenderbuffersQCOM_c(renderbuffers, maxRenderbuffers, numRenderbuffers)
  GLuint* renderbuffers;
  GLint maxRenderbuffers;
  GLint* numRenderbuffers;
CODE:
  OGLM_GLEWINIT
  OGLM_CHECK_ERR(glExtGetRenderbuffersQCOM, )
  OGLM_AVAIL_CHECK(__glewExtGetRenderbuffersQCOM, glExtGetRenderbuffersQCOM)
  glExtGetRenderbuffersQCOM(renderbuffers, maxRenderbuffers, numRenderbuffers);
  OGLM_CHECK_ERR(glExtGetRenderbuffersQCOM, )

void
glExtGetRenderbuffersQCOM_p(maxRenderbuffers)
  GLint maxRenderbuffers;
PPCODE:
  OGLM_GLEWINIT
  OGLM_CHECK_ERR(glExtGetRenderbuffersQCOM, )
  OGLM_AVAIL_CHECK(__glewExtGetRenderbuffersQCOM, glExtGetRenderbuffersQCOM)
  GLuint* renderbuffers = OGLM_ALLOC(maxRenderbuffers,GLuint,renderbuffers);
  GLint numRenderbuffers[1];
  glExtGetRenderbuffersQCOM(renderbuffers, maxRenderbuffers, numRenderbuffers);
  OGLM_CHECK_ERR(glExtGetRenderbuffersQCOM, free(renderbuffers);)
  EXTEND(sp, 2);
  OGLM_PUSH_ARRAY(glExtGetRenderbuffersQCOM, newSVuv, renderbuffers, maxRenderbuffers)
  mPUSHs(newSViv(numRenderbuffers[0]));
  free(renderbuffers);

void
glExtGetShadersQCOM_c(shaders, maxShaders, numShaders)
  GLuint* shaders;
  GLint maxShaders;
  GLint* numShaders;
CODE:
  OGLM_GLEWINIT
  OGLM_CHECK_ERR(glExtGetShadersQCOM, )
  OGLM_AVAIL_CHECK(__glewExtGetShadersQCOM, glExtGetShadersQCOM)
  glExtGetShadersQCOM(shaders, maxShaders, numShaders);
  OGLM_CHECK_ERR(glExtGetShadersQCOM, )

void
glExtGetShadersQCOM_p(maxShaders)
  GLint maxShaders;
PPCODE:
  OGLM_GLEWINIT
  OGLM_CHECK_ERR(glExtGetShadersQCOM, )
  OGLM_AVAIL_CHECK(__glewExtGetShadersQCOM, glExtGetShadersQCOM)
  GLuint* shaders = OGLM_ALLOC(maxShaders,GLuint,shaders);
  GLint numShaders[1];
  glExtGetShadersQCOM(shaders, maxShaders, numShaders);
  OGLM_CHECK_ERR(glExtGetShadersQCOM, free(shaders);)
  EXTEND(sp, 2);
  OGLM_PUSH_ARRAY(glExtGetShadersQCOM, newSVuv, shaders, maxShaders)
  mPUSHs(newSViv(numShaders[0]));
  free(shaders);

void
glExtGetTexLevelParameterivQCOM_c(texture, face, level, pname, params)
  GLuint texture;
  GLenum face;
  GLint level;
  GLenum pname;
  GLint* params;
CODE:
  OGLM_GLEWINIT
  OGLM_CHECK_ERR(glExtGetTexLevelParameterivQCOM, )
  OGLM_AVAIL_CHECK(__glewExtGetTexLevelParameterivQCOM, glExtGetTexLevelParameterivQCOM)
  glExtGetTexLevelParameterivQCOM(texture, face, level, pname, params);
  OGLM_CHECK_ERR(glExtGetTexLevelParameterivQCOM, )

void
glExtGetTexSubImageQCOM_c(target, level, xoffset, yoffset, zoffset, width, height, depth, format, type, texels)
  GLenum target;
  GLint level;
  GLint xoffset;
  GLint yoffset;
  GLint zoffset;
  GLsizei width;
  GLsizei height;
  GLsizei depth;
  GLenum format;
  GLenum type;
  void *texels;
CODE:
  OGLM_GLEWINIT
  OGLM_CHECK_ERR(glExtGetTexSubImageQCOM, )
  OGLM_AVAIL_CHECK(__glewExtGetTexSubImageQCOM, glExtGetTexSubImageQCOM)
  glExtGetTexSubImageQCOM(target, level, xoffset, yoffset, zoffset, width, height, depth, format, type, texels);
  OGLM_CHECK_ERR(glExtGetTexSubImageQCOM, )

void
glExtGetTexturesQCOM_c(textures, maxTextures, numTextures)
  GLuint* textures;
  GLint maxTextures;
  GLint* numTextures;
CODE:
  OGLM_GLEWINIT
  OGLM_CHECK_ERR(glExtGetTexturesQCOM, )
  OGLM_AVAIL_CHECK(__glewExtGetTexturesQCOM, glExtGetTexturesQCOM)
  glExtGetTexturesQCOM(textures, maxTextures, numTextures);
  OGLM_CHECK_ERR(glExtGetTexturesQCOM, )

GLboolean
glExtIsProgramBinaryQCOM(program)
  GLuint program;
CODE:
  OGLM_GLEWINIT
  OGLM_CHECK_ERR(glExtIsProgramBinaryQCOM, )
  OGLM_AVAIL_CHECK(__glewExtIsProgramBinaryQCOM, glExtIsProgramBinaryQCOM)
  RETVAL = glExtIsProgramBinaryQCOM(program);
  OGLM_CHECK_ERR(glExtIsProgramBinaryQCOM, )
OUTPUT:
  RETVAL

void
glExtTexObjectStateOverrideiQCOM(target, pname, param)
  GLenum target;
  GLenum pname;
  GLint param;
CODE:
  OGLM_GLEWINIT
  OGLM_CHECK_ERR(glExtTexObjectStateOverrideiQCOM, )
  OGLM_AVAIL_CHECK(__glewExtTexObjectStateOverrideiQCOM, glExtTexObjectStateOverrideiQCOM)
  glExtTexObjectStateOverrideiQCOM(target, pname, param);
  OGLM_CHECK_ERR(glExtTexObjectStateOverrideiQCOM, )

void
glExtractComponentEXT(res, src, num)
  GLuint res;
  GLuint src;
  GLuint num;
CODE:
  OGLM_GLEWINIT
  OGLM_CHECK_ERR(glExtractComponentEXT, )
  OGLM_AVAIL_CHECK(__glewExtractComponentEXT, glExtractComponentEXT)
  glExtractComponentEXT(res, src, num);
  OGLM_CHECK_ERR(glExtractComponentEXT, )

void
glExtrapolateTex2DQCOM(src1, src2, output, scaleFactor)
  GLuint src1;
  GLuint src2;
  GLuint output;
  GLfloat scaleFactor;
CODE:
  OGLM_GLEWINIT
  OGLM_CHECK_ERR(glExtrapolateTex2DQCOM, )
  OGLM_AVAIL_CHECK(__glewExtrapolateTex2DQCOM, glExtrapolateTex2DQCOM)
  glExtrapolateTex2DQCOM(src1, src2, output, scaleFactor);
  OGLM_CHECK_ERR(glExtrapolateTex2DQCOM, )

void
glFeedbackBuffer_c(size, type, buffer)
  GLsizei size;
  GLenum type;
  GLfloat *buffer;
CODE:
  OGLM_GLEWINIT
  OGLM_CHECK_ERR(glFeedbackBuffer, )
  glFeedbackBuffer(size, type, buffer);
  OGLM_CHECK_ERR(glFeedbackBuffer, )

void
glFeedbackBuffer_p(size, type)
  GLsizei size;
  GLenum type;
PPCODE:
  OGLM_GLEWINIT
  OGLM_CHECK_ERR(glFeedbackBuffer, )
  GLfloat *buffer = OGLM_ALLOC(size,GLfloat,buffer);
  glFeedbackBuffer(size, type, buffer);
  OGLM_CHECK_ERR(glFeedbackBuffer, free(buffer);)
  OGLM_OUT_FINISH(buffer,size,newSVnv)
  free(buffer);

GLsync
glFenceSync(condition, flags)
  GLenum condition;
  GLbitfield flags;
ALIAS:
  glFenceSyncAPPLE = 1
CODE:
  OGLM_GLEWINIT
  OGLM_CHECK_ERR(glFenceSync, )
  OGLM_AVAIL_CHECK(__glewFenceSync, glFenceSync)
  RETVAL = glFenceSync(condition, flags);
  OGLM_CHECK_ERR(glFenceSync, )
OUTPUT:
  RETVAL

void
glFinalCombinerInputNV(variable, input, mapping, componentUsage)
  GLenum variable;
  GLenum input;
  GLenum mapping;
  GLenum componentUsage;
CODE:
  OGLM_GLEWINIT
  OGLM_CHECK_ERR(glFinalCombinerInputNV, )
  OGLM_AVAIL_CHECK(__glewFinalCombinerInputNV, glFinalCombinerInputNV)
  glFinalCombinerInputNV(variable, input, mapping, componentUsage);
  OGLM_CHECK_ERR(glFinalCombinerInputNV, )

void
glFinish()
CODE:
  OGLM_GLEWINIT
  OGLM_CHECK_ERR(glFinish, )
  glFinish();
  OGLM_CHECK_ERR(glFinish, )

GLint
glFinishAsyncSGIX_c(markerp)
  GLuint* markerp;
CODE:
  OGLM_GLEWINIT
  OGLM_CHECK_ERR(glFinishAsyncSGIX, )
  OGLM_AVAIL_CHECK(__glewFinishAsyncSGIX, glFinishAsyncSGIX)
  RETVAL = glFinishAsyncSGIX(markerp);
  OGLM_CHECK_ERR(glFinishAsyncSGIX, )
OUTPUT:
  RETVAL

GLint
glFinishAsyncSGIX_p()
PPCODE:
  OGLM_GLEWINIT
  OGLM_CHECK_ERR(glFinishAsyncSGIX, )
  OGLM_AVAIL_CHECK(__glewFinishAsyncSGIX, glFinishAsyncSGIX)
  GLuint markerp[1];
  RETVAL = glFinishAsyncSGIX(markerp);
  OGLM_CHECK_ERR(glFinishAsyncSGIX, )
  EXTEND(sp, 2);
  mPUSHs(newSViv(RETVAL));
  mPUSHs(newSVuv(markerp[0]));

void
glFinishFenceAPPLE(fence)
  GLuint fence;
CODE:
  OGLM_GLEWINIT
  OGLM_CHECK_ERR(glFinishFenceAPPLE, )
  OGLM_AVAIL_CHECK(__glewFinishFenceAPPLE, glFinishFenceAPPLE)
  glFinishFenceAPPLE(fence);
  OGLM_CHECK_ERR(glFinishFenceAPPLE, )

void
glFinishFenceNV(fence)
  GLuint fence;
CODE:
  OGLM_GLEWINIT
  OGLM_CHECK_ERR(glFinishFenceNV, )
  OGLM_AVAIL_CHECK(__glewFinishFenceNV, glFinishFenceNV)
  glFinishFenceNV(fence);
  OGLM_CHECK_ERR(glFinishFenceNV, )

void
glFinishObjectAPPLE(object, name)
  GLenum object;
  GLint name;
CODE:
  OGLM_GLEWINIT
  OGLM_CHECK_ERR(glFinishObjectAPPLE, )
  OGLM_AVAIL_CHECK(__glewFinishObjectAPPLE, glFinishObjectAPPLE)
  glFinishObjectAPPLE(object, name);
  OGLM_CHECK_ERR(glFinishObjectAPPLE, )

void
glFinishTextureSUNX()
CODE:
  OGLM_GLEWINIT
  OGLM_CHECK_ERR(glFinishTextureSUNX, )
  OGLM_AVAIL_CHECK(__glewFinishTextureSUNX, glFinishTextureSUNX)
  glFinishTextureSUNX();
  OGLM_CHECK_ERR(glFinishTextureSUNX, )

void
glFlush()
CODE:
  OGLM_GLEWINIT
  OGLM_CHECK_ERR(glFlush, )
  glFlush();
  OGLM_CHECK_ERR(glFlush, )

void
glFlushMappedBufferRange(target, offset, length)
  GLenum target;
  GLintptr offset;
  GLsizeiptr length;
ALIAS:
  glFlushMappedBufferRangeAPPLE = 1
  glFlushMappedBufferRangeEXT = 2
CODE:
  OGLM_GLEWINIT
  OGLM_CHECK_ERR(glFlushMappedBufferRange, )
  OGLM_AVAIL_CHECK(__glewFlushMappedBufferRange, glFlushMappedBufferRange)
  glFlushMappedBufferRange(target, offset, length);
  OGLM_CHECK_ERR(glFlushMappedBufferRange, )

void
glFlushMappedNamedBufferRange(buffer, offset, length)
  GLuint buffer;
  GLintptr offset;
  GLsizeiptr length;
CODE:
  OGLM_GLEWINIT
  OGLM_CHECK_ERR(glFlushMappedNamedBufferRange, )
  OGLM_AVAIL_CHECK(__glewFlushMappedNamedBufferRange, glFlushMappedNamedBufferRange)
  glFlushMappedNamedBufferRange(buffer, offset, length);
  OGLM_CHECK_ERR(glFlushMappedNamedBufferRange, )

void
glFlushMappedNamedBufferRangeEXT(buffer, offset, length)
  GLuint buffer;
  GLintptr offset;
  GLsizeiptr length;
CODE:
  OGLM_GLEWINIT
  OGLM_CHECK_ERR(glFlushMappedNamedBufferRangeEXT, )
  OGLM_AVAIL_CHECK(__glewFlushMappedNamedBufferRangeEXT, glFlushMappedNamedBufferRangeEXT)
  glFlushMappedNamedBufferRangeEXT(buffer, offset, length);
  OGLM_CHECK_ERR(glFlushMappedNamedBufferRangeEXT, )

void
glFlushPixelDataRangeNV(target)
  GLenum target;
CODE:
  OGLM_GLEWINIT
  OGLM_CHECK_ERR(glFlushPixelDataRangeNV, )
  OGLM_AVAIL_CHECK(__glewFlushPixelDataRangeNV, glFlushPixelDataRangeNV)
  glFlushPixelDataRangeNV(target);
  OGLM_CHECK_ERR(glFlushPixelDataRangeNV, )

void
glFlushRasterSGIX()
CODE:
  OGLM_GLEWINIT
  OGLM_CHECK_ERR(glFlushRasterSGIX, )
  OGLM_AVAIL_CHECK(__glewFlushRasterSGIX, glFlushRasterSGIX)
  glFlushRasterSGIX();
  OGLM_CHECK_ERR(glFlushRasterSGIX, )

void
glFlushVertexArrayRangeAPPLE_c(length, pointer)
  GLsizei length;
  void *pointer;
CODE:
  OGLM_GLEWINIT
  OGLM_CHECK_ERR(glFlushVertexArrayRangeAPPLE, )
  OGLM_AVAIL_CHECK(__glewFlushVertexArrayRangeAPPLE, glFlushVertexArrayRangeAPPLE)
  glFlushVertexArrayRangeAPPLE(length, pointer);
  OGLM_CHECK_ERR(glFlushVertexArrayRangeAPPLE, )

void
glFlushVertexArrayRangeNV()
CODE:
  OGLM_GLEWINIT
  OGLM_CHECK_ERR(glFlushVertexArrayRangeNV, )
  OGLM_AVAIL_CHECK(__glewFlushVertexArrayRangeNV, glFlushVertexArrayRangeNV)
  glFlushVertexArrayRangeNV();
  OGLM_CHECK_ERR(glFlushVertexArrayRangeNV, )

void
glFogCoordFormatNV(type, stride)
  GLenum type;
  GLsizei stride;
CODE:
  OGLM_GLEWINIT
  OGLM_CHECK_ERR(glFogCoordFormatNV, )
  OGLM_AVAIL_CHECK(__glewFogCoordFormatNV, glFogCoordFormatNV)
  glFogCoordFormatNV(type, stride);
  OGLM_CHECK_ERR(glFogCoordFormatNV, )

void
glFogCoordPointer_c(type, stride, pointer)
  GLenum type;
  GLsizei stride;
  const void *pointer;
ALIAS:
  glFogCoordPointerEXT_c = 1
CODE:
  OGLM_GLEWINIT
  OGLM_CHECK_ERR(glFogCoordPointer, )
  OGLM_AVAIL_CHECK(__glewFogCoordPointer, glFogCoordPointer)
  glFogCoordPointer(type, stride, pointer);
  OGLM_CHECK_ERR(glFogCoordPointer, )

void
glFogCoordPointerListIBM_c(type, stride, pointer, ptrstride)
  GLenum type;
  GLint stride;
  const void** pointer;
  GLint ptrstride;
CODE:
  OGLM_GLEWINIT
  OGLM_CHECK_ERR(glFogCoordPointerListIBM, )
  OGLM_AVAIL_CHECK(__glewFogCoordPointerListIBM, glFogCoordPointerListIBM)
  glFogCoordPointerListIBM(type, stride, pointer, ptrstride);
  OGLM_CHECK_ERR(glFogCoordPointerListIBM, )

void
glFogCoordd(coord)
  GLdouble coord;
ALIAS:
  glFogCoorddEXT = 1
CODE:
  OGLM_GLEWINIT
  OGLM_CHECK_ERR(glFogCoordd, )
  OGLM_AVAIL_CHECK(__glewFogCoordd, glFogCoordd)
  glFogCoordd(coord);
  OGLM_CHECK_ERR(glFogCoordd, )

void
glFogCoorddv_c(coord)
  const GLdouble *coord;
ALIAS:
  glFogCoorddvEXT_c = 1
CODE:
  OGLM_GLEWINIT
  OGLM_CHECK_ERR(glFogCoorddv, )
  OGLM_AVAIL_CHECK(__glewFogCoorddv, glFogCoorddv)
  glFogCoorddv(coord);
  OGLM_CHECK_ERR(glFogCoorddv, )

void
glFogCoorddv_p(...)
ALIAS:
  glFogCoorddvEXT_p = 1
CODE:
  OGLM_GLEWINIT
  OGLM_CHECK_ERR(glFogCoorddv, )
  OGLM_AVAIL_CHECK(__glewFogCoorddv, glFogCoorddv)
  GLdouble *coord = OGLM_GET_VARARGS(coord,0,GLdouble,NV,1);
  glFogCoorddv((const GLdouble *)coord);
  OGLM_CHECK_ERR(glFogCoorddv, free(coord);)
  free(coord);

void
glFogCoordf(coord)
  GLfloat coord;
ALIAS:
  glFogCoordfEXT = 1
CODE:
  OGLM_GLEWINIT
  OGLM_CHECK_ERR(glFogCoordf, )
  OGLM_AVAIL_CHECK(__glewFogCoordf, glFogCoordf)
  glFogCoordf(coord);
  OGLM_CHECK_ERR(glFogCoordf, )

void
glFogCoordfv_c(coord)
  const GLfloat *coord;
ALIAS:
  glFogCoordfvEXT_c = 1
CODE:
  OGLM_GLEWINIT
  OGLM_CHECK_ERR(glFogCoordfv, )
  OGLM_AVAIL_CHECK(__glewFogCoordfv, glFogCoordfv)
  glFogCoordfv(coord);
  OGLM_CHECK_ERR(glFogCoordfv, )

void
glFogCoordfv_p(...)
ALIAS:
  glFogCoordfvEXT_p = 1
CODE:
  OGLM_GLEWINIT
  OGLM_CHECK_ERR(glFogCoordfv, )
  OGLM_AVAIL_CHECK(__glewFogCoordfv, glFogCoordfv)
  GLfloat *coord = OGLM_GET_VARARGS(coord,0,GLfloat,NV,1);
  glFogCoordfv((const GLfloat *)coord);
  OGLM_CHECK_ERR(glFogCoordfv, free(coord);)
  free(coord);

void
glFogCoordhNV(fog)
  GLhalf fog;
CODE:
  OGLM_GLEWINIT
  OGLM_CHECK_ERR(glFogCoordhNV, )
  OGLM_AVAIL_CHECK(__glewFogCoordhNV, glFogCoordhNV)
  glFogCoordhNV(fog);
  OGLM_CHECK_ERR(glFogCoordhNV, )

void
glFogCoordhvNV_c(fog)
  const GLhalf* fog;
CODE:
  OGLM_GLEWINIT
  OGLM_CHECK_ERR(glFogCoordhvNV, )
  OGLM_AVAIL_CHECK(__glewFogCoordhvNV, glFogCoordhvNV)
  glFogCoordhvNV(fog);
  OGLM_CHECK_ERR(glFogCoordhvNV, )

void
glFogCoordhvNV_p(...)
CODE:
  OGLM_GLEWINIT
  OGLM_CHECK_ERR(glFogCoordhvNV, )
  OGLM_AVAIL_CHECK(__glewFogCoordhvNV, glFogCoordhvNV)
  GLhalf* fog = OGLM_GET_VARARGS(fog,0,GLhalf,NV,1);
  glFogCoordhvNV((const GLhalf* )fog);
  OGLM_CHECK_ERR(glFogCoordhvNV, free(fog);)
  free(fog);

void
glFogFuncSGIS_c(n, points)
  GLsizei n;
  const GLfloat* points;
CODE:
  OGLM_GLEWINIT
  OGLM_CHECK_ERR(glFogFuncSGIS, )
  OGLM_AVAIL_CHECK(__glewFogFuncSGIS, glFogFuncSGIS)
  glFogFuncSGIS(n, points);
  OGLM_CHECK_ERR(glFogFuncSGIS, )

void
glFogFuncSGIS_p(n, ...)
  GLsizei n;
CODE:
  OGLM_GLEWINIT
  OGLM_CHECK_ERR(glFogFuncSGIS, )
  OGLM_AVAIL_CHECK(__glewFogFuncSGIS, glFogFuncSGIS)
  GLfloat* points = OGLM_GET_VARARGS(points,1,GLfloat,NV,n*2);
  glFogFuncSGIS((GLsizei )n, (const GLfloat* )points);
  OGLM_CHECK_ERR(glFogFuncSGIS, free(points);)
  free(points);

void
glFogLayersSGIX_c(n, points)
  GLsizei n;
  const GLfloat* points;
CODE:
  OGLM_GLEWINIT
  OGLM_CHECK_ERR(glFogLayersSGIX, )
  OGLM_AVAIL_CHECK(__glewFogLayersSGIX, glFogLayersSGIX)
  glFogLayersSGIX(n, points);
  OGLM_CHECK_ERR(glFogLayersSGIX, )

void
glFogf(pname, param)
  GLenum pname;
  GLfloat param;
CODE:
  OGLM_GLEWINIT
  OGLM_CHECK_ERR(glFogf, )
  glFogf(pname, param);
  OGLM_CHECK_ERR(glFogf, )

void
glFogfv_c(pname, params)
  GLenum pname;
  const GLfloat *params;
CODE:
  OGLM_GLEWINIT
  OGLM_CHECK_ERR(glFogfv, )
  glFogfv(pname, params);
  OGLM_CHECK_ERR(glFogfv, )

void
glFogfv_p(pname, ...)
  GLenum pname;
CODE:
  OGLM_GLEWINIT
  OGLM_CHECK_ERR(glFogfv, )
  OGLM_SIZE_ENUM(FogParameter,pname,1)
  GLfloat *params = OGLM_GET_VARARGS(params,1,GLfloat,NV,pname_count);
  glFogfv((GLenum )pname, (const GLfloat *)params);
  OGLM_CHECK_ERR(glFogfv, free(params);)
  free(params);

void
glFogi(pname, param)
  GLenum pname;
  GLint param;
CODE:
  OGLM_GLEWINIT
  OGLM_CHECK_ERR(glFogi, )
  glFogi(pname, param);
  OGLM_CHECK_ERR(glFogi, )

void
glFogiv_c(pname, params)
  GLenum pname;
  const GLint *params;
CODE:
  OGLM_GLEWINIT
  OGLM_CHECK_ERR(glFogiv, )
  glFogiv(pname, params);
  OGLM_CHECK_ERR(glFogiv, )

void
glFogiv_p(pname, ...)
  GLenum pname;
CODE:
  OGLM_GLEWINIT
  OGLM_CHECK_ERR(glFogiv, )
  OGLM_SIZE_ENUM(FogParameter,pname,1)
  GLint *params = OGLM_GET_VARARGS(params,1,GLint,IV,pname_count);
  glFogiv((GLenum )pname, (const GLint *)params);
  OGLM_CHECK_ERR(glFogiv, free(params);)
  free(params);

void
glFogx(pname, param)
  GLenum pname;
  GLfixed param;
CODE:
  OGLM_GLEWINIT
  OGLM_CHECK_ERR(glFogx, )
  OGLM_AVAIL_CHECK(__glewFogx, glFogx)
  glFogx(pname, param);
  OGLM_CHECK_ERR(glFogx, )

void
glFogxv_c(pname, param)
  GLenum pname;
  const GLfixed* param;
CODE:
  OGLM_GLEWINIT
  OGLM_CHECK_ERR(glFogxv, )
  OGLM_AVAIL_CHECK(__glewFogxv, glFogxv)
  glFogxv(pname, param);
  OGLM_CHECK_ERR(glFogxv, )

void
glFogxv_p(pname, ...)
  GLenum pname;
CODE:
  OGLM_GLEWINIT
  OGLM_CHECK_ERR(glFogxv, )
  OGLM_AVAIL_CHECK(__glewFogxv, glFogxv)
  OGLM_SIZE_ENUM(FogPName,pname,1)
  GLfixed* param = OGLM_GET_VARARGS(param,1,GLfixed,IV,pname_count);
  glFogxv((GLenum )pname, (const GLfixed* )param);
  OGLM_CHECK_ERR(glFogxv, free(param);)
  free(param);

void
glFragmentColorMaterialEXT(face, mode)
  GLenum face;
  GLenum mode;
CODE:
  OGLM_GLEWINIT
  OGLM_CHECK_ERR(glFragmentColorMaterialEXT, )
  OGLM_AVAIL_CHECK(__glewFragmentColorMaterialEXT, glFragmentColorMaterialEXT)
  glFragmentColorMaterialEXT(face, mode);
  OGLM_CHECK_ERR(glFragmentColorMaterialEXT, )

void
glFragmentColorMaterialSGIX(face, mode)
  GLenum face;
  GLenum mode;
CODE:
  OGLM_GLEWINIT
  OGLM_CHECK_ERR(glFragmentColorMaterialSGIX, )
  OGLM_AVAIL_CHECK(__glewFragmentColorMaterialSGIX, glFragmentColorMaterialSGIX)
  glFragmentColorMaterialSGIX(face, mode);
  OGLM_CHECK_ERR(glFragmentColorMaterialSGIX, )

void
glFragmentCoverageColorNV(color)
  GLuint color;
CODE:
  OGLM_GLEWINIT
  OGLM_CHECK_ERR(glFragmentCoverageColorNV, )
  OGLM_AVAIL_CHECK(__glewFragmentCoverageColorNV, glFragmentCoverageColorNV)
  glFragmentCoverageColorNV(color);
  OGLM_CHECK_ERR(glFragmentCoverageColorNV, )

void
glFragmentLightModelfEXT(pname, param)
  GLenum pname;
  GLfloat param;
CODE:
  OGLM_GLEWINIT
  OGLM_CHECK_ERR(glFragmentLightModelfEXT, )
  OGLM_AVAIL_CHECK(__glewFragmentLightModelfEXT, glFragmentLightModelfEXT)
  glFragmentLightModelfEXT(pname, param);
  OGLM_CHECK_ERR(glFragmentLightModelfEXT, )

void
glFragmentLightModelfSGIX(pname, param)
  GLenum pname;
  GLfloat param;
CODE:
  OGLM_GLEWINIT
  OGLM_CHECK_ERR(glFragmentLightModelfSGIX, )
  OGLM_AVAIL_CHECK(__glewFragmentLightModelfSGIX, glFragmentLightModelfSGIX)
  glFragmentLightModelfSGIX(pname, param);
  OGLM_CHECK_ERR(glFragmentLightModelfSGIX, )

void
glFragmentLightModelfvEXT_c(pname, params)
  GLenum pname;
  GLfloat* params;
CODE:
  OGLM_GLEWINIT
  OGLM_CHECK_ERR(glFragmentLightModelfvEXT, )
  OGLM_AVAIL_CHECK(__glewFragmentLightModelfvEXT, glFragmentLightModelfvEXT)
  glFragmentLightModelfvEXT(pname, params);
  OGLM_CHECK_ERR(glFragmentLightModelfvEXT, )

void
glFragmentLightModelfvSGIX_c(pname, params)
  GLenum pname;
  GLfloat* params;
CODE:
  OGLM_GLEWINIT
  OGLM_CHECK_ERR(glFragmentLightModelfvSGIX, )
  OGLM_AVAIL_CHECK(__glewFragmentLightModelfvSGIX, glFragmentLightModelfvSGIX)
  glFragmentLightModelfvSGIX(pname, params);
  OGLM_CHECK_ERR(glFragmentLightModelfvSGIX, )

void
glFragmentLightModeliEXT(pname, param)
  GLenum pname;
  GLint param;
CODE:
  OGLM_GLEWINIT
  OGLM_CHECK_ERR(glFragmentLightModeliEXT, )
  OGLM_AVAIL_CHECK(__glewFragmentLightModeliEXT, glFragmentLightModeliEXT)
  glFragmentLightModeliEXT(pname, param);
  OGLM_CHECK_ERR(glFragmentLightModeliEXT, )

void
glFragmentLightModeliSGIX(pname, param)
  GLenum pname;
  GLint param;
CODE:
  OGLM_GLEWINIT
  OGLM_CHECK_ERR(glFragmentLightModeliSGIX, )
  OGLM_AVAIL_CHECK(__glewFragmentLightModeliSGIX, glFragmentLightModeliSGIX)
  glFragmentLightModeliSGIX(pname, param);
  OGLM_CHECK_ERR(glFragmentLightModeliSGIX, )

void
glFragmentLightModelivEXT_c(pname, params)
  GLenum pname;
  GLint* params;
CODE:
  OGLM_GLEWINIT
  OGLM_CHECK_ERR(glFragmentLightModelivEXT, )
  OGLM_AVAIL_CHECK(__glewFragmentLightModelivEXT, glFragmentLightModelivEXT)
  glFragmentLightModelivEXT(pname, params);
  OGLM_CHECK_ERR(glFragmentLightModelivEXT, )

void
glFragmentLightModelivSGIX_c(pname, params)
  GLenum pname;
  GLint* params;
CODE:
  OGLM_GLEWINIT
  OGLM_CHECK_ERR(glFragmentLightModelivSGIX, )
  OGLM_AVAIL_CHECK(__glewFragmentLightModelivSGIX, glFragmentLightModelivSGIX)
  glFragmentLightModelivSGIX(pname, params);
  OGLM_CHECK_ERR(glFragmentLightModelivSGIX, )

void
glFragmentLightfEXT(light, pname, param)
  GLenum light;
  GLenum pname;
  GLfloat param;
CODE:
  OGLM_GLEWINIT
  OGLM_CHECK_ERR(glFragmentLightfEXT, )
  OGLM_AVAIL_CHECK(__glewFragmentLightfEXT, glFragmentLightfEXT)
  glFragmentLightfEXT(light, pname, param);
  OGLM_CHECK_ERR(glFragmentLightfEXT, )

void
glFragmentLightfSGIX(light, pname, param)
  GLenum light;
  GLenum pname;
  GLfloat param;
CODE:
  OGLM_GLEWINIT
  OGLM_CHECK_ERR(glFragmentLightfSGIX, )
  OGLM_AVAIL_CHECK(__glewFragmentLightfSGIX, glFragmentLightfSGIX)
  glFragmentLightfSGIX(light, pname, param);
  OGLM_CHECK_ERR(glFragmentLightfSGIX, )

void
glFragmentLightfvEXT_c(light, pname, params)
  GLenum light;
  GLenum pname;
  GLfloat* params;
CODE:
  OGLM_GLEWINIT
  OGLM_CHECK_ERR(glFragmentLightfvEXT, )
  OGLM_AVAIL_CHECK(__glewFragmentLightfvEXT, glFragmentLightfvEXT)
  glFragmentLightfvEXT(light, pname, params);
  OGLM_CHECK_ERR(glFragmentLightfvEXT, )

void
glFragmentLightfvSGIX_c(light, pname, params)
  GLenum light;
  GLenum pname;
  GLfloat* params;
CODE:
  OGLM_GLEWINIT
  OGLM_CHECK_ERR(glFragmentLightfvSGIX, )
  OGLM_AVAIL_CHECK(__glewFragmentLightfvSGIX, glFragmentLightfvSGIX)
  glFragmentLightfvSGIX(light, pname, params);
  OGLM_CHECK_ERR(glFragmentLightfvSGIX, )

void
glFragmentLightfvSGIX_p(light, pname)
  GLenum light;
  GLenum pname;
PPCODE:
  OGLM_GLEWINIT
  OGLM_CHECK_ERR(glFragmentLightfvSGIX, )
  OGLM_AVAIL_CHECK(__glewFragmentLightfvSGIX, glFragmentLightfvSGIX)
  OGLM_SIZE_ENUM(FragmentLightParameterSGIX,pname,1)
  GLfloat* params = OGLM_ALLOC(pname_count,GLfloat,params);
  glFragmentLightfvSGIX(light, pname, params);
  OGLM_CHECK_ERR(glFragmentLightfvSGIX, free(params);)
  OGLM_OUT_FINISH(params,pname_count,newSVnv)
  free(params);

void
glFragmentLightiEXT(light, pname, param)
  GLenum light;
  GLenum pname;
  GLint param;
CODE:
  OGLM_GLEWINIT
  OGLM_CHECK_ERR(glFragmentLightiEXT, )
  OGLM_AVAIL_CHECK(__glewFragmentLightiEXT, glFragmentLightiEXT)
  glFragmentLightiEXT(light, pname, param);
  OGLM_CHECK_ERR(glFragmentLightiEXT, )

void
glFragmentLightiSGIX(light, pname, param)
  GLenum light;
  GLenum pname;
  GLint param;
CODE:
  OGLM_GLEWINIT
  OGLM_CHECK_ERR(glFragmentLightiSGIX, )
  OGLM_AVAIL_CHECK(__glewFragmentLightiSGIX, glFragmentLightiSGIX)
  glFragmentLightiSGIX(light, pname, param);
  OGLM_CHECK_ERR(glFragmentLightiSGIX, )

void
glFragmentLightivEXT_c(light, pname, params)
  GLenum light;
  GLenum pname;
  GLint* params;
CODE:
  OGLM_GLEWINIT
  OGLM_CHECK_ERR(glFragmentLightivEXT, )
  OGLM_AVAIL_CHECK(__glewFragmentLightivEXT, glFragmentLightivEXT)
  glFragmentLightivEXT(light, pname, params);
  OGLM_CHECK_ERR(glFragmentLightivEXT, )

void
glFragmentLightivSGIX_c(light, pname, params)
  GLenum light;
  GLenum pname;
  GLint* params;
CODE:
  OGLM_GLEWINIT
  OGLM_CHECK_ERR(glFragmentLightivSGIX, )
  OGLM_AVAIL_CHECK(__glewFragmentLightivSGIX, glFragmentLightivSGIX)
  glFragmentLightivSGIX(light, pname, params);
  OGLM_CHECK_ERR(glFragmentLightivSGIX, )

void
glFragmentLightivSGIX_p(light, pname)
  GLenum light;
  GLenum pname;
PPCODE:
  OGLM_GLEWINIT
  OGLM_CHECK_ERR(glFragmentLightivSGIX, )
  OGLM_AVAIL_CHECK(__glewFragmentLightivSGIX, glFragmentLightivSGIX)
  OGLM_SIZE_ENUM(FragmentLightParameterSGIX,pname,1)
  GLint* params = OGLM_ALLOC(pname_count,GLint,params);
  glFragmentLightivSGIX(light, pname, params);
  OGLM_CHECK_ERR(glFragmentLightivSGIX, free(params);)
  OGLM_OUT_FINISH(params,pname_count,newSViv)
  free(params);

void
glFragmentMaterialfEXT(face, pname, param)
  GLenum face;
  GLenum pname;
  const GLfloat param;
CODE:
  OGLM_GLEWINIT
  OGLM_CHECK_ERR(glFragmentMaterialfEXT, )
  OGLM_AVAIL_CHECK(__glewFragmentMaterialfEXT, glFragmentMaterialfEXT)
  glFragmentMaterialfEXT(face, pname, param);
  OGLM_CHECK_ERR(glFragmentMaterialfEXT, )

void
glFragmentMaterialfSGIX(face, pname, param)
  GLenum face;
  GLenum pname;
  const GLfloat param;
CODE:
  OGLM_GLEWINIT
  OGLM_CHECK_ERR(glFragmentMaterialfSGIX, )
  OGLM_AVAIL_CHECK(__glewFragmentMaterialfSGIX, glFragmentMaterialfSGIX)
  glFragmentMaterialfSGIX(face, pname, param);
  OGLM_CHECK_ERR(glFragmentMaterialfSGIX, )

void
glFragmentMaterialfvEXT_c(face, pname, params)
  GLenum face;
  GLenum pname;
  const GLfloat* params;
CODE:
  OGLM_GLEWINIT
  OGLM_CHECK_ERR(glFragmentMaterialfvEXT, )
  OGLM_AVAIL_CHECK(__glewFragmentMaterialfvEXT, glFragmentMaterialfvEXT)
  glFragmentMaterialfvEXT(face, pname, params);
  OGLM_CHECK_ERR(glFragmentMaterialfvEXT, )

void
glFragmentMaterialfvSGIX_c(face, pname, params)
  GLenum face;
  GLenum pname;
  const GLfloat* params;
CODE:
  OGLM_GLEWINIT
  OGLM_CHECK_ERR(glFragmentMaterialfvSGIX, )
  OGLM_AVAIL_CHECK(__glewFragmentMaterialfvSGIX, glFragmentMaterialfvSGIX)
  glFragmentMaterialfvSGIX(face, pname, params);
  OGLM_CHECK_ERR(glFragmentMaterialfvSGIX, )

void
glFragmentMaterialfvSGIX_p(face, pname, ...)
  GLenum face;
  GLenum pname;
CODE:
  OGLM_GLEWINIT
  OGLM_CHECK_ERR(glFragmentMaterialfvSGIX, )
  OGLM_AVAIL_CHECK(__glewFragmentMaterialfvSGIX, glFragmentMaterialfvSGIX)
  OGLM_SIZE_ENUM(MaterialParameter,pname,1)
  GLfloat* params = OGLM_GET_VARARGS(params,2,GLfloat,NV,pname_count);
  glFragmentMaterialfvSGIX((GLenum )face, (GLenum )pname, (const GLfloat* )params);
  OGLM_CHECK_ERR(glFragmentMaterialfvSGIX, free(params);)
  free(params);

void
glFragmentMaterialiEXT(face, pname, param)
  GLenum face;
  GLenum pname;
  const GLint param;
CODE:
  OGLM_GLEWINIT
  OGLM_CHECK_ERR(glFragmentMaterialiEXT, )
  OGLM_AVAIL_CHECK(__glewFragmentMaterialiEXT, glFragmentMaterialiEXT)
  glFragmentMaterialiEXT(face, pname, param);
  OGLM_CHECK_ERR(glFragmentMaterialiEXT, )

void
glFragmentMaterialiSGIX(face, pname, param)
  GLenum face;
  GLenum pname;
  const GLint param;
CODE:
  OGLM_GLEWINIT
  OGLM_CHECK_ERR(glFragmentMaterialiSGIX, )
  OGLM_AVAIL_CHECK(__glewFragmentMaterialiSGIX, glFragmentMaterialiSGIX)
  glFragmentMaterialiSGIX(face, pname, param);
  OGLM_CHECK_ERR(glFragmentMaterialiSGIX, )

void
glFragmentMaterialivEXT_c(face, pname, params)
  GLenum face;
  GLenum pname;
  const GLint* params;
CODE:
  OGLM_GLEWINIT
  OGLM_CHECK_ERR(glFragmentMaterialivEXT, )
  OGLM_AVAIL_CHECK(__glewFragmentMaterialivEXT, glFragmentMaterialivEXT)
  glFragmentMaterialivEXT(face, pname, params);
  OGLM_CHECK_ERR(glFragmentMaterialivEXT, )

void
glFragmentMaterialivSGIX_c(face, pname, params)
  GLenum face;
  GLenum pname;
  const GLint* params;
CODE:
  OGLM_GLEWINIT
  OGLM_CHECK_ERR(glFragmentMaterialivSGIX, )
  OGLM_AVAIL_CHECK(__glewFragmentMaterialivSGIX, glFragmentMaterialivSGIX)
  glFragmentMaterialivSGIX(face, pname, params);
  OGLM_CHECK_ERR(glFragmentMaterialivSGIX, )

void
glFragmentMaterialivSGIX_p(face, pname, ...)
  GLenum face;
  GLenum pname;
CODE:
  OGLM_GLEWINIT
  OGLM_CHECK_ERR(glFragmentMaterialivSGIX, )
  OGLM_AVAIL_CHECK(__glewFragmentMaterialivSGIX, glFragmentMaterialivSGIX)
  OGLM_SIZE_ENUM(MaterialParameter,pname,1)
  GLint* params = OGLM_GET_VARARGS(params,2,GLint,IV,pname_count);
  glFragmentMaterialivSGIX((GLenum )face, (GLenum )pname, (const GLint* )params);
  OGLM_CHECK_ERR(glFragmentMaterialivSGIX, free(params);)
  free(params);

void
glFrameTerminatorGREMEDY()
CODE:
  OGLM_GLEWINIT
  OGLM_CHECK_ERR(glFrameTerminatorGREMEDY, )
  OGLM_AVAIL_CHECK(__glewFrameTerminatorGREMEDY, glFrameTerminatorGREMEDY)
  glFrameTerminatorGREMEDY();
  OGLM_CHECK_ERR(glFrameTerminatorGREMEDY, )

void
glFrameZoomSGIX(factor)
  GLint factor;
CODE:
  OGLM_GLEWINIT
  OGLM_CHECK_ERR(glFrameZoomSGIX, )
  OGLM_AVAIL_CHECK(__glewFrameZoomSGIX, glFrameZoomSGIX)
  glFrameZoomSGIX(factor);
  OGLM_CHECK_ERR(glFrameZoomSGIX, )

void
glFramebufferDrawBufferEXT(framebuffer, mode)
  GLuint framebuffer;
  GLenum mode;
CODE:
  OGLM_GLEWINIT
  OGLM_CHECK_ERR(glFramebufferDrawBufferEXT, )
  OGLM_AVAIL_CHECK(__glewFramebufferDrawBufferEXT, glFramebufferDrawBufferEXT)
  glFramebufferDrawBufferEXT(framebuffer, mode);
  OGLM_CHECK_ERR(glFramebufferDrawBufferEXT, )

void
glFramebufferDrawBuffersEXT_c(framebuffer, n, bufs)
  GLuint framebuffer;
  GLsizei n;
  const GLenum* bufs;
CODE:
  OGLM_GLEWINIT
  OGLM_CHECK_ERR(glFramebufferDrawBuffersEXT, )
  OGLM_AVAIL_CHECK(__glewFramebufferDrawBuffersEXT, glFramebufferDrawBuffersEXT)
  glFramebufferDrawBuffersEXT(framebuffer, n, bufs);
  OGLM_CHECK_ERR(glFramebufferDrawBuffersEXT, )

void
glFramebufferDrawBuffersEXT_p(framebuffer, ...)
  GLuint framebuffer;
CODE:
  OGLM_GLEWINIT
  OGLM_CHECK_ERR(glFramebufferDrawBuffersEXT, )
  OGLM_AVAIL_CHECK(__glewFramebufferDrawBuffersEXT, glFramebufferDrawBuffersEXT)
  GLsizei n = items-1;
  GLenum* bufs = OGLM_GET_VARARGS(bufs,1,GLenum,IV,n);
  glFramebufferDrawBuffersEXT((GLuint )framebuffer, (GLsizei )n, (const GLenum* )bufs);
  OGLM_CHECK_ERR(glFramebufferDrawBuffersEXT, free(bufs);)
  free(bufs);

void
glFramebufferFetchBarrierEXT()
CODE:
  OGLM_GLEWINIT
  OGLM_CHECK_ERR(glFramebufferFetchBarrierEXT, )
  OGLM_AVAIL_CHECK(__glewFramebufferFetchBarrierEXT, glFramebufferFetchBarrierEXT)
  glFramebufferFetchBarrierEXT();
  OGLM_CHECK_ERR(glFramebufferFetchBarrierEXT, )

void
glFramebufferFetchBarrierQCOM()
CODE:
  OGLM_GLEWINIT
  OGLM_CHECK_ERR(glFramebufferFetchBarrierQCOM, )
  OGLM_AVAIL_CHECK(__glewFramebufferFetchBarrierQCOM, glFramebufferFetchBarrierQCOM)
  glFramebufferFetchBarrierQCOM();
  OGLM_CHECK_ERR(glFramebufferFetchBarrierQCOM, )

void
glFramebufferFoveationConfigQCOM_c(framebuffer, numLayers, focalPointsPerLayer, requestedFeatures, providedFeatures)
  GLuint framebuffer;
  GLuint numLayers;
  GLuint focalPointsPerLayer;
  GLuint requestedFeatures;
  GLuint* providedFeatures;
CODE:
  OGLM_GLEWINIT
  OGLM_CHECK_ERR(glFramebufferFoveationConfigQCOM, )
  OGLM_AVAIL_CHECK(__glewFramebufferFoveationConfigQCOM, glFramebufferFoveationConfigQCOM)
  glFramebufferFoveationConfigQCOM(framebuffer, numLayers, focalPointsPerLayer, requestedFeatures, providedFeatures);
  OGLM_CHECK_ERR(glFramebufferFoveationConfigQCOM, )

GLuint
glFramebufferFoveationConfigQCOM_p(framebuffer, numLayers, focalPointsPerLayer, requestedFeatures)
  GLuint framebuffer;
  GLuint numLayers;
  GLuint focalPointsPerLayer;
  GLuint requestedFeatures;
CODE:
  OGLM_GLEWINIT
  OGLM_CHECK_ERR(glFramebufferFoveationConfigQCOM, )
  OGLM_AVAIL_CHECK(__glewFramebufferFoveationConfigQCOM, glFramebufferFoveationConfigQCOM)
  GLuint providedFeatures[1];
  glFramebufferFoveationConfigQCOM(framebuffer, numLayers, focalPointsPerLayer, requestedFeatures, providedFeatures);
  OGLM_CHECK_ERR(glFramebufferFoveationConfigQCOM, )
  RETVAL = providedFeatures[0];
OUTPUT:
  RETVAL

void
glFramebufferFoveationParametersQCOM(fbo, layer, focalPoint, focalX, focalY, gainX, gainY, foveaArea)
  GLuint fbo;
  GLuint layer;
  GLuint focalPoint;
  GLfloat focalX;
  GLfloat focalY;
  GLfloat gainX;
  GLfloat gainY;
  GLfloat foveaArea;
CODE:
  OGLM_GLEWINIT
  OGLM_CHECK_ERR(glFramebufferFoveationParametersQCOM, )
  OGLM_AVAIL_CHECK(__glewFramebufferFoveationParametersQCOM, glFramebufferFoveationParametersQCOM)
  glFramebufferFoveationParametersQCOM(fbo, layer, focalPoint, focalX, focalY, gainX, gainY, foveaArea);
  OGLM_CHECK_ERR(glFramebufferFoveationParametersQCOM, )

void
glFramebufferParameteri(target, pname, param)
  GLenum target;
  GLenum pname;
  GLint param;
CODE:
  OGLM_GLEWINIT
  OGLM_CHECK_ERR(glFramebufferParameteri, )
  OGLM_AVAIL_CHECK(__glewFramebufferParameteri, glFramebufferParameteri)
  glFramebufferParameteri(target, pname, param);
  OGLM_CHECK_ERR(glFramebufferParameteri, )

void
glFramebufferParameteriMESA(target, pname, param)
  GLenum target;
  GLenum pname;
  GLint param;
CODE:
  OGLM_GLEWINIT
  OGLM_CHECK_ERR(glFramebufferParameteriMESA, )
  OGLM_AVAIL_CHECK(__glewFramebufferParameteriMESA, glFramebufferParameteriMESA)
  glFramebufferParameteriMESA(target, pname, param);
  OGLM_CHECK_ERR(glFramebufferParameteriMESA, )

void
glFramebufferPixelLocalStorageSizeEXT(target, size)
  GLuint target;
  GLsizei size;
CODE:
  OGLM_GLEWINIT
  OGLM_CHECK_ERR(glFramebufferPixelLocalStorageSizeEXT, )
  OGLM_AVAIL_CHECK(__glewFramebufferPixelLocalStorageSizeEXT, glFramebufferPixelLocalStorageSizeEXT)
  glFramebufferPixelLocalStorageSizeEXT(target, size);
  OGLM_CHECK_ERR(glFramebufferPixelLocalStorageSizeEXT, )

void
glFramebufferReadBufferEXT(framebuffer, mode)
  GLuint framebuffer;
  GLenum mode;
CODE:
  OGLM_GLEWINIT
  OGLM_CHECK_ERR(glFramebufferReadBufferEXT, )
  OGLM_AVAIL_CHECK(__glewFramebufferReadBufferEXT, glFramebufferReadBufferEXT)
  glFramebufferReadBufferEXT(framebuffer, mode);
  OGLM_CHECK_ERR(glFramebufferReadBufferEXT, )

void
glFramebufferRenderbuffer(target, attachment, renderbuffertarget, renderbuffer)
  GLenum target;
  GLenum attachment;
  GLenum renderbuffertarget;
  GLuint renderbuffer;
ALIAS:
  glFramebufferRenderbufferEXT = 1
CODE:
  OGLM_GLEWINIT
  OGLM_CHECK_ERR(glFramebufferRenderbuffer, )
  OGLM_AVAIL_CHECK(__glewFramebufferRenderbuffer, glFramebufferRenderbuffer)
  glFramebufferRenderbuffer(target, attachment, renderbuffertarget, renderbuffer);
  OGLM_CHECK_ERR(glFramebufferRenderbuffer, )

void
glFramebufferRenderbufferOES(target, attachment, renderbuffertarget, renderbuffer)
  GLenum target;
  GLenum attachment;
  GLenum renderbuffertarget;
  GLuint renderbuffer;
CODE:
  OGLM_GLEWINIT
  OGLM_CHECK_ERR(glFramebufferRenderbufferOES, )
  OGLM_AVAIL_CHECK(__glewFramebufferRenderbufferOES, glFramebufferRenderbufferOES)
  glFramebufferRenderbufferOES(target, attachment, renderbuffertarget, renderbuffer);
  OGLM_CHECK_ERR(glFramebufferRenderbufferOES, )

void
glFramebufferSampleLocationsfvARB_c(target, start, count, v)
  GLenum target;
  GLuint start;
  GLsizei count;
  const GLfloat* v;
CODE:
  OGLM_GLEWINIT
  OGLM_CHECK_ERR(glFramebufferSampleLocationsfvARB, )
  OGLM_AVAIL_CHECK(__glewFramebufferSampleLocationsfvARB, glFramebufferSampleLocationsfvARB)
  glFramebufferSampleLocationsfvARB(target, start, count, v);
  OGLM_CHECK_ERR(glFramebufferSampleLocationsfvARB, )

void
glFramebufferSampleLocationsfvNV_c(target, start, count, v)
  GLenum target;
  GLuint start;
  GLsizei count;
  const GLfloat* v;
CODE:
  OGLM_GLEWINIT
  OGLM_CHECK_ERR(glFramebufferSampleLocationsfvNV, )
  OGLM_AVAIL_CHECK(__glewFramebufferSampleLocationsfvNV, glFramebufferSampleLocationsfvNV)
  glFramebufferSampleLocationsfvNV(target, start, count, v);
  OGLM_CHECK_ERR(glFramebufferSampleLocationsfvNV, )

void
glFramebufferSamplePositionsfvAMD_c(target, numsamples, pixelindex, values)
  GLenum target;
  GLuint numsamples;
  GLuint pixelindex;
  const GLfloat* values;
CODE:
  OGLM_GLEWINIT
  OGLM_CHECK_ERR(glFramebufferSamplePositionsfvAMD, )
  OGLM_AVAIL_CHECK(__glewFramebufferSamplePositionsfvAMD, glFramebufferSamplePositionsfvAMD)
  glFramebufferSamplePositionsfvAMD(target, numsamples, pixelindex, values);
  OGLM_CHECK_ERR(glFramebufferSamplePositionsfvAMD, )

void
glFramebufferShadingRateEXT(target, attachment, texture, baseLayer, numLayers, texelWidth, texelHeight)
  GLenum target;
  GLenum attachment;
  GLuint texture;
  GLint baseLayer;
  GLsizei numLayers;
  GLsizei texelWidth;
  GLsizei texelHeight;
CODE:
  OGLM_GLEWINIT
  OGLM_CHECK_ERR(glFramebufferShadingRateEXT, )
  OGLM_AVAIL_CHECK(__glewFramebufferShadingRateEXT, glFramebufferShadingRateEXT)
  glFramebufferShadingRateEXT(target, attachment, texture, baseLayer, numLayers, texelWidth, texelHeight);
  OGLM_CHECK_ERR(glFramebufferShadingRateEXT, )

void
glFramebufferTexture(target, attachment, texture, level)
  GLenum target;
  GLenum attachment;
  GLuint texture;
  GLint level;
ALIAS:
  glFramebufferTextureARB = 1
  glFramebufferTextureEXT = 2
CODE:
  OGLM_GLEWINIT
  OGLM_CHECK_ERR(glFramebufferTexture, )
  OGLM_AVAIL_CHECK(__glewFramebufferTexture, glFramebufferTexture)
  glFramebufferTexture(target, attachment, texture, level);
  OGLM_CHECK_ERR(glFramebufferTexture, )

void
glFramebufferTexture1D(target, attachment, textarget, texture, level)
  GLenum target;
  GLenum attachment;
  GLenum textarget;
  GLuint texture;
  GLint level;
ALIAS:
  glFramebufferTexture1DEXT = 1
CODE:
  OGLM_GLEWINIT
  OGLM_CHECK_ERR(glFramebufferTexture1D, )
  OGLM_AVAIL_CHECK(__glewFramebufferTexture1D, glFramebufferTexture1D)
  glFramebufferTexture1D(target, attachment, textarget, texture, level);
  OGLM_CHECK_ERR(glFramebufferTexture1D, )

void
glFramebufferTexture2D(target, attachment, textarget, texture, level)
  GLenum target;
  GLenum attachment;
  GLenum textarget;
  GLuint texture;
  GLint level;
ALIAS:
  glFramebufferTexture2DEXT = 1
CODE:
  OGLM_GLEWINIT
  OGLM_CHECK_ERR(glFramebufferTexture2D, )
  OGLM_AVAIL_CHECK(__glewFramebufferTexture2D, glFramebufferTexture2D)
  glFramebufferTexture2D(target, attachment, textarget, texture, level);
  OGLM_CHECK_ERR(glFramebufferTexture2D, )

void
glFramebufferTexture2DDownsampleIMG(target, attachment, textarget, texture, level, xscale, yscale)
  GLenum target;
  GLenum attachment;
  GLenum textarget;
  GLuint texture;
  GLint level;
  GLint xscale;
  GLint yscale;
CODE:
  OGLM_GLEWINIT
  OGLM_CHECK_ERR(glFramebufferTexture2DDownsampleIMG, )
  OGLM_AVAIL_CHECK(__glewFramebufferTexture2DDownsampleIMG, glFramebufferTexture2DDownsampleIMG)
  glFramebufferTexture2DDownsampleIMG(target, attachment, textarget, texture, level, xscale, yscale);
  OGLM_CHECK_ERR(glFramebufferTexture2DDownsampleIMG, )

void
glFramebufferTexture2DMultisampleEXT(target, attachment, textarget, texture, level, samples)
  GLenum target;
  GLenum attachment;
  GLenum textarget;
  GLuint texture;
  GLint level;
  GLsizei samples;
CODE:
  OGLM_GLEWINIT
  OGLM_CHECK_ERR(glFramebufferTexture2DMultisampleEXT, )
  OGLM_AVAIL_CHECK(__glewFramebufferTexture2DMultisampleEXT, glFramebufferTexture2DMultisampleEXT)
  glFramebufferTexture2DMultisampleEXT(target, attachment, textarget, texture, level, samples);
  OGLM_CHECK_ERR(glFramebufferTexture2DMultisampleEXT, )

void
glFramebufferTexture2DMultisampleIMG(target, attachment, textarget, texture, level, samples)
  GLenum target;
  GLenum attachment;
  GLenum textarget;
  GLuint texture;
  GLint level;
  GLsizei samples;
CODE:
  OGLM_GLEWINIT
  OGLM_CHECK_ERR(glFramebufferTexture2DMultisampleIMG, )
  OGLM_AVAIL_CHECK(__glewFramebufferTexture2DMultisampleIMG, glFramebufferTexture2DMultisampleIMG)
  glFramebufferTexture2DMultisampleIMG(target, attachment, textarget, texture, level, samples);
  OGLM_CHECK_ERR(glFramebufferTexture2DMultisampleIMG, )

void
glFramebufferTexture2DOES(target, attachment, textarget, texture, level)
  GLenum target;
  GLenum attachment;
  GLenum textarget;
  GLuint texture;
  GLint level;
CODE:
  OGLM_GLEWINIT
  OGLM_CHECK_ERR(glFramebufferTexture2DOES, )
  OGLM_AVAIL_CHECK(__glewFramebufferTexture2DOES, glFramebufferTexture2DOES)
  glFramebufferTexture2DOES(target, attachment, textarget, texture, level);
  OGLM_CHECK_ERR(glFramebufferTexture2DOES, )

void
glFramebufferTexture3D(target, attachment, textarget, texture, level, zoffset)
  GLenum target;
  GLenum attachment;
  GLenum textarget;
  GLuint texture;
  GLint level;
  GLint zoffset;
ALIAS:
  glFramebufferTexture3DEXT = 1
CODE:
  OGLM_GLEWINIT
  OGLM_CHECK_ERR(glFramebufferTexture3D, )
  OGLM_AVAIL_CHECK(__glewFramebufferTexture3D, glFramebufferTexture3D)
  glFramebufferTexture3D(target, attachment, textarget, texture, level, zoffset);
  OGLM_CHECK_ERR(glFramebufferTexture3D, )

void
glFramebufferTexture3DOES(target, attachment, textarget, texture, level, zoffset)
  GLenum target;
  GLenum attachment;
  GLenum textarget;
  GLuint texture;
  GLint level;
  GLint zoffset;
CODE:
  OGLM_GLEWINIT
  OGLM_CHECK_ERR(glFramebufferTexture3DOES, )
  OGLM_AVAIL_CHECK(__glewFramebufferTexture3DOES, glFramebufferTexture3DOES)
  glFramebufferTexture3DOES(target, attachment, textarget, texture, level, zoffset);
  OGLM_CHECK_ERR(glFramebufferTexture3DOES, )

void
glFramebufferTextureFaceARB(target, attachment, texture, level, face)
  GLenum target;
  GLenum attachment;
  GLuint texture;
  GLint level;
  GLenum face;
ALIAS:
  glFramebufferTextureFaceEXT = 1
CODE:
  OGLM_GLEWINIT
  OGLM_CHECK_ERR(glFramebufferTextureFaceARB, )
  OGLM_AVAIL_CHECK(__glewFramebufferTextureFaceARB, glFramebufferTextureFaceARB)
  glFramebufferTextureFaceARB(target, attachment, texture, level, face);
  OGLM_CHECK_ERR(glFramebufferTextureFaceARB, )

void
glFramebufferTextureLayer(target, attachment, texture, level, layer)
  GLenum target;
  GLenum attachment;
  GLuint texture;
  GLint level;
  GLint layer;
ALIAS:
  glFramebufferTextureLayerARB = 1
  glFramebufferTextureLayerEXT = 2
CODE:
  OGLM_GLEWINIT
  OGLM_CHECK_ERR(glFramebufferTextureLayer, )
  OGLM_AVAIL_CHECK(__glewFramebufferTextureLayer, glFramebufferTextureLayer)
  glFramebufferTextureLayer(target, attachment, texture, level, layer);
  OGLM_CHECK_ERR(glFramebufferTextureLayer, )

void
glFramebufferTextureLayerDownsampleIMG(target, attachment, texture, level, layer, xscale, yscale)
  GLenum target;
  GLenum attachment;
  GLuint texture;
  GLint level;
  GLint layer;
  GLint xscale;
  GLint yscale;
CODE:
  OGLM_GLEWINIT
  OGLM_CHECK_ERR(glFramebufferTextureLayerDownsampleIMG, )
  OGLM_AVAIL_CHECK(__glewFramebufferTextureLayerDownsampleIMG, glFramebufferTextureLayerDownsampleIMG)
  glFramebufferTextureLayerDownsampleIMG(target, attachment, texture, level, layer, xscale, yscale);
  OGLM_CHECK_ERR(glFramebufferTextureLayerDownsampleIMG, )

void
glFramebufferTextureLayerNV(target, attachment, texture, level, layer)
  GLenum target;
  GLenum attachment;
  GLuint texture;
  GLint level;
  GLint layer;
CODE:
  OGLM_GLEWINIT
  OGLM_CHECK_ERR(glFramebufferTextureLayerNV, )
  OGLM_AVAIL_CHECK(__glewFramebufferTextureLayerNV, glFramebufferTextureLayerNV)
  glFramebufferTextureLayerNV(target, attachment, texture, level, layer);
  OGLM_CHECK_ERR(glFramebufferTextureLayerNV, )

void
glFramebufferTextureMultisampleMultiviewOVR(target, attachment, texture, level, samples, baseViewIndex, numViews)
  GLenum target;
  GLenum attachment;
  GLuint texture;
  GLint level;
  GLsizei samples;
  GLint baseViewIndex;
  GLsizei numViews;
CODE:
  OGLM_GLEWINIT
  OGLM_CHECK_ERR(glFramebufferTextureMultisampleMultiviewOVR, )
  OGLM_AVAIL_CHECK(__glewFramebufferTextureMultisampleMultiviewOVR, glFramebufferTextureMultisampleMultiviewOVR)
  glFramebufferTextureMultisampleMultiviewOVR(target, attachment, texture, level, samples, baseViewIndex, numViews);
  OGLM_CHECK_ERR(glFramebufferTextureMultisampleMultiviewOVR, )

void
glFramebufferTextureMultiviewOVR(target, attachment, texture, level, baseViewIndex, numViews)
  GLenum target;
  GLenum attachment;
  GLuint texture;
  GLint level;
  GLint baseViewIndex;
  GLsizei numViews;
CODE:
  OGLM_GLEWINIT
  OGLM_CHECK_ERR(glFramebufferTextureMultiviewOVR, )
  OGLM_AVAIL_CHECK(__glewFramebufferTextureMultiviewOVR, glFramebufferTextureMultiviewOVR)
  glFramebufferTextureMultiviewOVR(target, attachment, texture, level, baseViewIndex, numViews);
  OGLM_CHECK_ERR(glFramebufferTextureMultiviewOVR, )

void
glFreeObjectBufferATI(buffer)
  GLuint buffer;
CODE:
  OGLM_GLEWINIT
  OGLM_CHECK_ERR(glFreeObjectBufferATI, )
  OGLM_AVAIL_CHECK(__glewFreeObjectBufferATI, glFreeObjectBufferATI)
  glFreeObjectBufferATI(buffer);
  OGLM_CHECK_ERR(glFreeObjectBufferATI, )

void
glFrontFace(mode)
  GLenum mode;
CODE:
  OGLM_GLEWINIT
  OGLM_CHECK_ERR(glFrontFace, )
  glFrontFace(mode);
  OGLM_CHECK_ERR(glFrontFace, )

void
glFrustum(left, right, bottom, top, zNear, zFar)
  GLdouble left;
  GLdouble right;
  GLdouble bottom;
  GLdouble top;
  GLdouble zNear;
  GLdouble zFar;
CODE:
  OGLM_GLEWINIT
  OGLM_CHECK_ERR(glFrustum, )
  glFrustum(left, right, bottom, top, zNear, zFar);
  OGLM_CHECK_ERR(glFrustum, )

void
glFrustumf(left, right, bottom, top, zNear, zFar)
  GLfloat left;
  GLfloat right;
  GLfloat bottom;
  GLfloat top;
  GLfloat zNear;
  GLfloat zFar;
CODE:
  OGLM_GLEWINIT
  OGLM_CHECK_ERR(glFrustumf, )
  OGLM_AVAIL_CHECK(__glewFrustumf, glFrustumf)
  glFrustumf(left, right, bottom, top, zNear, zFar);
  OGLM_CHECK_ERR(glFrustumf, )

void
glFrustumfOES(l, r, b, t, n, f)
  GLfloat l;
  GLfloat r;
  GLfloat b;
  GLfloat t;
  GLfloat n;
  GLfloat f;
CODE:
  OGLM_GLEWINIT
  OGLM_CHECK_ERR(glFrustumfOES, )
  OGLM_AVAIL_CHECK(__glewFrustumfOES, glFrustumfOES)
  glFrustumfOES(l, r, b, t, n, f);
  OGLM_CHECK_ERR(glFrustumfOES, )

void
glFrustumx(left, right, bottom, top, zNear, zFar)
  GLfixed left;
  GLfixed right;
  GLfixed bottom;
  GLfixed top;
  GLfixed zNear;
  GLfixed zFar;
CODE:
  OGLM_GLEWINIT
  OGLM_CHECK_ERR(glFrustumx, )
  OGLM_AVAIL_CHECK(__glewFrustumx, glFrustumx)
  glFrustumx(left, right, bottom, top, zNear, zFar);
  OGLM_CHECK_ERR(glFrustumx, )

GLuint
glGenAsyncMarkersSGIX(range)
  GLsizei range;
CODE:
  OGLM_GLEWINIT
  OGLM_CHECK_ERR(glGenAsyncMarkersSGIX, )
  OGLM_AVAIL_CHECK(__glewGenAsyncMarkersSGIX, glGenAsyncMarkersSGIX)
  RETVAL = glGenAsyncMarkersSGIX(range);
  OGLM_CHECK_ERR(glGenAsyncMarkersSGIX, )
OUTPUT:
  RETVAL

void
glGenBuffers_c(n, buffers)
  GLsizei n;
  GLuint* buffers;
ALIAS:
  glGenBuffersARB_c = 1
CODE:
  OGLM_GLEWINIT
  OGLM_CHECK_ERR(glGenBuffers, )
  OGLM_AVAIL_CHECK(__glewGenBuffers, glGenBuffers)
  glGenBuffers(n, buffers);
  OGLM_CHECK_ERR(glGenBuffers, )

void
glGenBuffers_p(n)
  GLsizei n;
ALIAS:
  glGenBuffersARB_p = 1
PPCODE:
  OGLM_GLEWINIT
  OGLM_CHECK_ERR(glGenBuffers, )
  OGLM_AVAIL_CHECK(__glewGenBuffers, glGenBuffers)
  GLuint* buffers = OGLM_ALLOC(n,GLuint,buffers);
  glGenBuffers(n, buffers);
  OGLM_CHECK_ERR(glGenBuffers, free(buffers);)
  OGLM_OUT_FINISH(buffers,n,newSVuv)
  free(buffers);

void
glGenFencesAPPLE_c(n, fences)
  GLsizei n;
  GLuint* fences;
CODE:
  OGLM_GLEWINIT
  OGLM_CHECK_ERR(glGenFencesAPPLE, )
  OGLM_AVAIL_CHECK(__glewGenFencesAPPLE, glGenFencesAPPLE)
  glGenFencesAPPLE(n, fences);
  OGLM_CHECK_ERR(glGenFencesAPPLE, )

void
glGenFencesAPPLE_p(n)
  GLsizei n;
PPCODE:
  OGLM_GLEWINIT
  OGLM_CHECK_ERR(glGenFencesAPPLE, )
  OGLM_AVAIL_CHECK(__glewGenFencesAPPLE, glGenFencesAPPLE)
  GLuint* fences = OGLM_ALLOC(n,GLuint,fences);
  glGenFencesAPPLE(n, fences);
  OGLM_CHECK_ERR(glGenFencesAPPLE, free(fences);)
  OGLM_OUT_FINISH(fences,n,newSVuv)
  free(fences);

void
glGenFencesNV_c(n, fences)
  GLsizei n;
  GLuint* fences;
CODE:
  OGLM_GLEWINIT
  OGLM_CHECK_ERR(glGenFencesNV, )
  OGLM_AVAIL_CHECK(__glewGenFencesNV, glGenFencesNV)
  glGenFencesNV(n, fences);
  OGLM_CHECK_ERR(glGenFencesNV, )

void
glGenFencesNV_p(n)
  GLsizei n;
PPCODE:
  OGLM_GLEWINIT
  OGLM_CHECK_ERR(glGenFencesNV, )
  OGLM_AVAIL_CHECK(__glewGenFencesNV, glGenFencesNV)
  GLuint* fences = OGLM_ALLOC(n,GLuint,fences);
  glGenFencesNV(n, fences);
  OGLM_CHECK_ERR(glGenFencesNV, free(fences);)
  OGLM_OUT_FINISH(fences,n,newSVuv)
  free(fences);

GLuint
glGenFragmentShadersATI(range)
  GLuint range;
CODE:
  OGLM_GLEWINIT
  OGLM_CHECK_ERR(glGenFragmentShadersATI, )
  OGLM_AVAIL_CHECK(__glewGenFragmentShadersATI, glGenFragmentShadersATI)
  RETVAL = glGenFragmentShadersATI(range);
  OGLM_CHECK_ERR(glGenFragmentShadersATI, )
OUTPUT:
  RETVAL

void
glGenFramebuffers_c(n, framebuffers)
  GLsizei n;
  GLuint* framebuffers;
ALIAS:
  glGenFramebuffersEXT_c = 1
CODE:
  OGLM_GLEWINIT
  OGLM_CHECK_ERR(glGenFramebuffers, )
  OGLM_AVAIL_CHECK(__glewGenFramebuffers, glGenFramebuffers)
  glGenFramebuffers(n, framebuffers);
  OGLM_CHECK_ERR(glGenFramebuffers, )

void
glGenFramebuffers_p(n)
  GLsizei n;
ALIAS:
  glGenFramebuffersEXT_p = 1
PPCODE:
  OGLM_GLEWINIT
  OGLM_CHECK_ERR(glGenFramebuffers, )
  OGLM_AVAIL_CHECK(__glewGenFramebuffers, glGenFramebuffers)
  GLuint* framebuffers = OGLM_ALLOC(n,GLuint,framebuffers);
  glGenFramebuffers(n, framebuffers);
  OGLM_CHECK_ERR(glGenFramebuffers, free(framebuffers);)
  OGLM_OUT_FINISH(framebuffers,n,newSVuv)
  free(framebuffers);

void
glGenFramebuffersOES_c(n, framebuffers)
  GLsizei n;
  GLuint* framebuffers;
CODE:
  OGLM_GLEWINIT
  OGLM_CHECK_ERR(glGenFramebuffersOES, )
  OGLM_AVAIL_CHECK(__glewGenFramebuffersOES, glGenFramebuffersOES)
  glGenFramebuffersOES(n, framebuffers);
  OGLM_CHECK_ERR(glGenFramebuffersOES, )

GLuint
glGenLists(range)
  GLsizei range;
CODE:
  OGLM_GLEWINIT
  OGLM_CHECK_ERR(glGenLists, )
  RETVAL = glGenLists(range);
  OGLM_CHECK_ERR(glGenLists, )
OUTPUT:
  RETVAL

void
glGenMPEGPredictorsSGIX_c(n, predictors)
  GLsizei n;
  GLuint* predictors;
CODE:
  OGLM_GLEWINIT
  OGLM_CHECK_ERR(glGenMPEGPredictorsSGIX, )
  OGLM_AVAIL_CHECK(__glewGenMPEGPredictorsSGIX, glGenMPEGPredictorsSGIX)
  glGenMPEGPredictorsSGIX(n, predictors);
  OGLM_CHECK_ERR(glGenMPEGPredictorsSGIX, )

void
glGenNamesAMD_c(identifier, num, names)
  GLenum identifier;
  GLuint num;
  GLuint* names;
CODE:
  OGLM_GLEWINIT
  OGLM_CHECK_ERR(glGenNamesAMD, )
  OGLM_AVAIL_CHECK(__glewGenNamesAMD, glGenNamesAMD)
  glGenNamesAMD(identifier, num, names);
  OGLM_CHECK_ERR(glGenNamesAMD, )

void
glGenNamesAMD_p(identifier, num)
  GLenum identifier;
  GLuint num;
PPCODE:
  OGLM_GLEWINIT
  OGLM_CHECK_ERR(glGenNamesAMD, )
  OGLM_AVAIL_CHECK(__glewGenNamesAMD, glGenNamesAMD)
  GLuint* names = OGLM_ALLOC(num,GLuint,names);
  glGenNamesAMD(identifier, num, names);
  OGLM_CHECK_ERR(glGenNamesAMD, free(names);)
  OGLM_OUT_FINISH(names,num,newSVuv)
  free(names);

void
glGenOcclusionQueriesNV_c(n, ids)
  GLsizei n;
  GLuint* ids;
CODE:
  OGLM_GLEWINIT
  OGLM_CHECK_ERR(glGenOcclusionQueriesNV, )
  OGLM_AVAIL_CHECK(__glewGenOcclusionQueriesNV, glGenOcclusionQueriesNV)
  glGenOcclusionQueriesNV(n, ids);
  OGLM_CHECK_ERR(glGenOcclusionQueriesNV, )

void
glGenOcclusionQueriesNV_p(n)
  GLsizei n;
PPCODE:
  OGLM_GLEWINIT
  OGLM_CHECK_ERR(glGenOcclusionQueriesNV, )
  OGLM_AVAIL_CHECK(__glewGenOcclusionQueriesNV, glGenOcclusionQueriesNV)
  GLuint* ids = OGLM_ALLOC(n,GLuint,ids);
  glGenOcclusionQueriesNV(n, ids);
  OGLM_CHECK_ERR(glGenOcclusionQueriesNV, free(ids);)
  OGLM_OUT_FINISH(ids,n,newSVuv)
  free(ids);

GLuint
glGenPathsNV(range)
  GLsizei range;
CODE:
  OGLM_GLEWINIT
  OGLM_CHECK_ERR(glGenPathsNV, )
  OGLM_AVAIL_CHECK(__glewGenPathsNV, glGenPathsNV)
  RETVAL = glGenPathsNV(range);
  OGLM_CHECK_ERR(glGenPathsNV, )
OUTPUT:
  RETVAL

void
glGenPerfMonitorsAMD_c(n, monitors)
  GLsizei n;
  GLuint* monitors;
CODE:
  OGLM_GLEWINIT
  OGLM_CHECK_ERR(glGenPerfMonitorsAMD, )
  OGLM_AVAIL_CHECK(__glewGenPerfMonitorsAMD, glGenPerfMonitorsAMD)
  glGenPerfMonitorsAMD(n, monitors);
  OGLM_CHECK_ERR(glGenPerfMonitorsAMD, )

void
glGenPerfMonitorsAMD_p(n)
  GLsizei n;
PPCODE:
  OGLM_GLEWINIT
  OGLM_CHECK_ERR(glGenPerfMonitorsAMD, )
  OGLM_AVAIL_CHECK(__glewGenPerfMonitorsAMD, glGenPerfMonitorsAMD)
  GLuint* monitors = OGLM_ALLOC(n,GLuint,monitors);
  glGenPerfMonitorsAMD(n, monitors);
  OGLM_CHECK_ERR(glGenPerfMonitorsAMD, free(monitors);)
  OGLM_OUT_FINISH(monitors,n,newSVuv)
  free(monitors);

void
glGenProgramPipelines_c(n, pipelines)
  GLsizei n;
  GLuint* pipelines;
CODE:
  OGLM_GLEWINIT
  OGLM_CHECK_ERR(glGenProgramPipelines, )
  OGLM_AVAIL_CHECK(__glewGenProgramPipelines, glGenProgramPipelines)
  glGenProgramPipelines(n, pipelines);
  OGLM_CHECK_ERR(glGenProgramPipelines, )

void
glGenProgramPipelines_p(n)
  GLsizei n;
PPCODE:
  OGLM_GLEWINIT
  OGLM_CHECK_ERR(glGenProgramPipelines, )
  OGLM_AVAIL_CHECK(__glewGenProgramPipelines, glGenProgramPipelines)
  GLuint* pipelines = OGLM_ALLOC(n,GLuint,pipelines);
  glGenProgramPipelines(n, pipelines);
  OGLM_CHECK_ERR(glGenProgramPipelines, free(pipelines);)
  OGLM_OUT_FINISH(pipelines,n,newSVuv)
  free(pipelines);

void
glGenProgramsARB_c(n, programs)
  GLsizei n;
  GLuint* programs;
ALIAS:
  glGenProgramsNV_c = 1
CODE:
  OGLM_GLEWINIT
  OGLM_CHECK_ERR(glGenProgramsARB, )
  OGLM_AVAIL_CHECK(__glewGenProgramsARB, glGenProgramsARB)
  glGenProgramsARB(n, programs);
  OGLM_CHECK_ERR(glGenProgramsARB, )

void
glGenProgramsARB_p(n)
  GLsizei n;
ALIAS:
  glGenProgramsNV_p = 1
PPCODE:
  OGLM_GLEWINIT
  OGLM_CHECK_ERR(glGenProgramsARB, )
  OGLM_AVAIL_CHECK(__glewGenProgramsARB, glGenProgramsARB)
  GLuint* programs = OGLM_ALLOC(n,GLuint,programs);
  glGenProgramsARB(n, programs);
  OGLM_CHECK_ERR(glGenProgramsARB, free(programs);)
  OGLM_OUT_FINISH(programs,n,newSVuv)
  free(programs);

void
glGenQueries_c(n, ids)
  GLsizei n;
  GLuint* ids;
ALIAS:
  glGenQueriesARB_c = 1
CODE:
  OGLM_GLEWINIT
  OGLM_CHECK_ERR(glGenQueries, )
  OGLM_AVAIL_CHECK(__glewGenQueries, glGenQueries)
  glGenQueries(n, ids);
  OGLM_CHECK_ERR(glGenQueries, )

void
glGenQueries_p(n)
  GLsizei n;
ALIAS:
  glGenQueriesARB_p = 1
PPCODE:
  OGLM_GLEWINIT
  OGLM_CHECK_ERR(glGenQueries, )
  OGLM_AVAIL_CHECK(__glewGenQueries, glGenQueries)
  GLuint* ids = OGLM_ALLOC(n,GLuint,ids);
  glGenQueries(n, ids);
  OGLM_CHECK_ERR(glGenQueries, free(ids);)
  OGLM_OUT_FINISH(ids,n,newSVuv)
  free(ids);

void
glGenQueriesANGLE_c(n, ids)
  GLsizei n;
  GLuint* ids;
CODE:
  OGLM_GLEWINIT
  OGLM_CHECK_ERR(glGenQueriesANGLE, )
  OGLM_AVAIL_CHECK(__glewGenQueriesANGLE, glGenQueriesANGLE)
  glGenQueriesANGLE(n, ids);
  OGLM_CHECK_ERR(glGenQueriesANGLE, )

void
glGenQueriesEXT_c(n, ids)
  GLsizei n;
  GLuint* ids;
CODE:
  OGLM_GLEWINIT
  OGLM_CHECK_ERR(glGenQueriesEXT, )
  OGLM_AVAIL_CHECK(__glewGenQueriesEXT, glGenQueriesEXT)
  glGenQueriesEXT(n, ids);
  OGLM_CHECK_ERR(glGenQueriesEXT, )

void
glGenQueriesEXT_p(n)
  GLsizei n;
PPCODE:
  OGLM_GLEWINIT
  OGLM_CHECK_ERR(glGenQueriesEXT, )
  OGLM_AVAIL_CHECK(__glewGenQueriesEXT, glGenQueriesEXT)
  GLuint* ids = OGLM_ALLOC(n,GLuint,ids);
  glGenQueriesEXT(n, ids);
  OGLM_CHECK_ERR(glGenQueriesEXT, free(ids);)
  OGLM_OUT_FINISH(ids,n,newSVuv)
  free(ids);

void
glGenRenderbuffers_c(n, renderbuffers)
  GLsizei n;
  GLuint* renderbuffers;
ALIAS:
  glGenRenderbuffersEXT_c = 1
CODE:
  OGLM_GLEWINIT
  OGLM_CHECK_ERR(glGenRenderbuffers, )
  OGLM_AVAIL_CHECK(__glewGenRenderbuffers, glGenRenderbuffers)
  glGenRenderbuffers(n, renderbuffers);
  OGLM_CHECK_ERR(glGenRenderbuffers, )

void
glGenRenderbuffers_p(n)
  GLsizei n;
ALIAS:
  glGenRenderbuffersEXT_p = 1
PPCODE:
  OGLM_GLEWINIT
  OGLM_CHECK_ERR(glGenRenderbuffers, )
  OGLM_AVAIL_CHECK(__glewGenRenderbuffers, glGenRenderbuffers)
  GLuint* renderbuffers = OGLM_ALLOC(n,GLuint,renderbuffers);
  glGenRenderbuffers(n, renderbuffers);
  OGLM_CHECK_ERR(glGenRenderbuffers, free(renderbuffers);)
  OGLM_OUT_FINISH(renderbuffers,n,newSVuv)
  free(renderbuffers);

void
glGenRenderbuffersOES_c(n, renderbuffers)
  GLsizei n;
  GLuint* renderbuffers;
CODE:
  OGLM_GLEWINIT
  OGLM_CHECK_ERR(glGenRenderbuffersOES, )
  OGLM_AVAIL_CHECK(__glewGenRenderbuffersOES, glGenRenderbuffersOES)
  glGenRenderbuffersOES(n, renderbuffers);
  OGLM_CHECK_ERR(glGenRenderbuffersOES, )

void
glGenSamplers_c(count, samplers)
  GLsizei count;
  GLuint* samplers;
CODE:
  OGLM_GLEWINIT
  OGLM_CHECK_ERR(glGenSamplers, )
  OGLM_AVAIL_CHECK(__glewGenSamplers, glGenSamplers)
  glGenSamplers(count, samplers);
  OGLM_CHECK_ERR(glGenSamplers, )

void
glGenSamplers_p(count)
  GLsizei count;
PPCODE:
  OGLM_GLEWINIT
  OGLM_CHECK_ERR(glGenSamplers, )
  OGLM_AVAIL_CHECK(__glewGenSamplers, glGenSamplers)
  GLuint* samplers = OGLM_ALLOC(count,GLuint,samplers);
  glGenSamplers(count, samplers);
  OGLM_CHECK_ERR(glGenSamplers, free(samplers);)
  OGLM_OUT_FINISH(samplers,count,newSVuv)
  free(samplers);

void
glGenSemaphoresEXT_c(n, semaphores)
  GLsizei n;
  GLuint* semaphores;
CODE:
  OGLM_GLEWINIT
  OGLM_CHECK_ERR(glGenSemaphoresEXT, )
  OGLM_AVAIL_CHECK(__glewGenSemaphoresEXT, glGenSemaphoresEXT)
  glGenSemaphoresEXT(n, semaphores);
  OGLM_CHECK_ERR(glGenSemaphoresEXT, )

void
glGenSemaphoresEXT_p(n)
  GLsizei n;
PPCODE:
  OGLM_GLEWINIT
  OGLM_CHECK_ERR(glGenSemaphoresEXT, )
  OGLM_AVAIL_CHECK(__glewGenSemaphoresEXT, glGenSemaphoresEXT)
  GLuint* semaphores = OGLM_ALLOC(n,GLuint,semaphores);
  glGenSemaphoresEXT(n, semaphores);
  OGLM_CHECK_ERR(glGenSemaphoresEXT, free(semaphores);)
  OGLM_OUT_FINISH(semaphores,n,newSVuv)
  free(semaphores);

GLuint
glGenSymbolsEXT(datatype, storagetype, range, components)
  GLenum datatype;
  GLenum storagetype;
  GLenum range;
  GLuint components;
CODE:
  OGLM_GLEWINIT
  OGLM_CHECK_ERR(glGenSymbolsEXT, )
  OGLM_AVAIL_CHECK(__glewGenSymbolsEXT, glGenSymbolsEXT)
  RETVAL = glGenSymbolsEXT(datatype, storagetype, range, components);
  OGLM_CHECK_ERR(glGenSymbolsEXT, )
OUTPUT:
  RETVAL

void
glGenTextures_c(n, textures)
  GLsizei n;
  GLuint *textures;
CODE:
  OGLM_GLEWINIT
  OGLM_CHECK_ERR(glGenTextures, )
  glGenTextures(n, textures);
  OGLM_CHECK_ERR(glGenTextures, )

void
glGenTextures_p(n)
  GLsizei n;
PPCODE:
  OGLM_GLEWINIT
  OGLM_CHECK_ERR(glGenTextures, )
  GLuint *textures = OGLM_ALLOC(n,GLuint,textures);
  glGenTextures(n, textures);
  OGLM_CHECK_ERR(glGenTextures, free(textures);)
  OGLM_OUT_FINISH(textures,n,newSVuv)
  free(textures);

void
glGenTexturesEXT_c(n, textures)
  GLsizei n;
  GLuint* textures;
CODE:
  OGLM_GLEWINIT
  OGLM_CHECK_ERR(glGenTexturesEXT, )
  OGLM_AVAIL_CHECK(__glewGenTexturesEXT, glGenTexturesEXT)
  glGenTexturesEXT(n, textures);
  OGLM_CHECK_ERR(glGenTexturesEXT, )

void
glGenTexturesEXT_p(n)
  GLsizei n;
PPCODE:
  OGLM_GLEWINIT
  OGLM_CHECK_ERR(glGenTexturesEXT, )
  OGLM_AVAIL_CHECK(__glewGenTexturesEXT, glGenTexturesEXT)
  GLuint* textures = OGLM_ALLOC(n,GLuint,textures);
  glGenTexturesEXT(n, textures);
  OGLM_CHECK_ERR(glGenTexturesEXT, free(textures);)
  OGLM_OUT_FINISH(textures,n,newSVuv)
  free(textures);

void
glGenTransformFeedbacks_c(n, ids)
  GLsizei n;
  GLuint* ids;
ALIAS:
  glGenTransformFeedbacksNV_c = 1
CODE:
  OGLM_GLEWINIT
  OGLM_CHECK_ERR(glGenTransformFeedbacks, )
  OGLM_AVAIL_CHECK(__glewGenTransformFeedbacks, glGenTransformFeedbacks)
  glGenTransformFeedbacks(n, ids);
  OGLM_CHECK_ERR(glGenTransformFeedbacks, )

void
glGenTransformFeedbacks_p(n)
  GLsizei n;
ALIAS:
  glGenTransformFeedbacksNV_p = 1
PPCODE:
  OGLM_GLEWINIT
  OGLM_CHECK_ERR(glGenTransformFeedbacks, )
  OGLM_AVAIL_CHECK(__glewGenTransformFeedbacks, glGenTransformFeedbacks)
  GLuint* ids = OGLM_ALLOC(n,GLuint,ids);
  glGenTransformFeedbacks(n, ids);
  OGLM_CHECK_ERR(glGenTransformFeedbacks, free(ids);)
  OGLM_OUT_FINISH(ids,n,newSVuv)
  free(ids);

void
glGenVertexArrays_c(n, arrays)
  GLsizei n;
  GLuint* arrays;
ALIAS:
  glGenVertexArraysAPPLE_c = 1
CODE:
  OGLM_GLEWINIT
  OGLM_CHECK_ERR(glGenVertexArrays, )
  OGLM_AVAIL_CHECK(__glewGenVertexArrays, glGenVertexArrays)
  glGenVertexArrays(n, arrays);
  OGLM_CHECK_ERR(glGenVertexArrays, )

void
glGenVertexArrays_p(n)
  GLsizei n;
ALIAS:
  glGenVertexArraysAPPLE_p = 1
PPCODE:
  OGLM_GLEWINIT
  OGLM_CHECK_ERR(glGenVertexArrays, )
  OGLM_AVAIL_CHECK(__glewGenVertexArrays, glGenVertexArrays)
  GLuint* arrays = OGLM_ALLOC(n,GLuint,arrays);
  glGenVertexArrays(n, arrays);
  OGLM_CHECK_ERR(glGenVertexArrays, free(arrays);)
  OGLM_OUT_FINISH(arrays,n,newSVuv)
  free(arrays);

void
glGenVertexArraysOES_c(n, arrays)
  GLsizei n;
  GLuint* arrays;
CODE:
  OGLM_GLEWINIT
  OGLM_CHECK_ERR(glGenVertexArraysOES, )
  OGLM_AVAIL_CHECK(__glewGenVertexArraysOES, glGenVertexArraysOES)
  glGenVertexArraysOES(n, arrays);
  OGLM_CHECK_ERR(glGenVertexArraysOES, )

void
glGenVertexArraysSGIX_c(n, arrays)
  GLsizei n;
  GLuint* arrays;
CODE:
  OGLM_GLEWINIT
  OGLM_CHECK_ERR(glGenVertexArraysSGIX, )
  OGLM_AVAIL_CHECK(__glewGenVertexArraysSGIX, glGenVertexArraysSGIX)
  glGenVertexArraysSGIX(n, arrays);
  OGLM_CHECK_ERR(glGenVertexArraysSGIX, )

GLuint
glGenVertexShadersEXT(range)
  GLuint range;
CODE:
  OGLM_GLEWINIT
  OGLM_CHECK_ERR(glGenVertexShadersEXT, )
  OGLM_AVAIL_CHECK(__glewGenVertexShadersEXT, glGenVertexShadersEXT)
  RETVAL = glGenVertexShadersEXT(range);
  OGLM_CHECK_ERR(glGenVertexShadersEXT, )
OUTPUT:
  RETVAL

void
glGenerateMipmap(target)
  GLenum target;
ALIAS:
  glGenerateMipmapEXT = 1
CODE:
  OGLM_GLEWINIT
  OGLM_CHECK_ERR(glGenerateMipmap, )
  OGLM_AVAIL_CHECK(__glewGenerateMipmap, glGenerateMipmap)
  glGenerateMipmap(target);
  OGLM_CHECK_ERR(glGenerateMipmap, )

void
glGenerateMipmapOES(target)
  GLenum target;
CODE:
  OGLM_GLEWINIT
  OGLM_CHECK_ERR(glGenerateMipmapOES, )
  OGLM_AVAIL_CHECK(__glewGenerateMipmapOES, glGenerateMipmapOES)
  glGenerateMipmapOES(target);
  OGLM_CHECK_ERR(glGenerateMipmapOES, )

void
glGenerateMultiTexMipmapEXT(texunit, target)
  GLenum texunit;
  GLenum target;
CODE:
  OGLM_GLEWINIT
  OGLM_CHECK_ERR(glGenerateMultiTexMipmapEXT, )
  OGLM_AVAIL_CHECK(__glewGenerateMultiTexMipmapEXT, glGenerateMultiTexMipmapEXT)
  glGenerateMultiTexMipmapEXT(texunit, target);
  OGLM_CHECK_ERR(glGenerateMultiTexMipmapEXT, )

void
glGenerateTextureMipmap(texture)
  GLuint texture;
CODE:
  OGLM_GLEWINIT
  OGLM_CHECK_ERR(glGenerateTextureMipmap, )
  OGLM_AVAIL_CHECK(__glewGenerateTextureMipmap, glGenerateTextureMipmap)
  glGenerateTextureMipmap(texture);
  OGLM_CHECK_ERR(glGenerateTextureMipmap, )

void
glGenerateTextureMipmapEXT(texture, target)
  GLuint texture;
  GLenum target;
CODE:
  OGLM_GLEWINIT
  OGLM_CHECK_ERR(glGenerateTextureMipmapEXT, )
  OGLM_AVAIL_CHECK(__glewGenerateTextureMipmapEXT, glGenerateTextureMipmapEXT)
  glGenerateTextureMipmapEXT(texture, target);
  OGLM_CHECK_ERR(glGenerateTextureMipmapEXT, )

void
glGetActiveAtomicCounterBufferiv_c(program, bufferIndex, pname, params)
  GLuint program;
  GLuint bufferIndex;
  GLenum pname;
  GLint* params;
CODE:
  OGLM_GLEWINIT
  OGLM_CHECK_ERR(glGetActiveAtomicCounterBufferiv, )
  OGLM_AVAIL_CHECK(__glewGetActiveAtomicCounterBufferiv, glGetActiveAtomicCounterBufferiv)
  glGetActiveAtomicCounterBufferiv(program, bufferIndex, pname, params);
  OGLM_CHECK_ERR(glGetActiveAtomicCounterBufferiv, )

void
glGetActiveAtomicCounterBufferiv_p(program, bufferIndex, pname)
  GLuint program;
  GLuint bufferIndex;
  GLenum pname;
PPCODE:
  OGLM_GLEWINIT
  OGLM_CHECK_ERR(glGetActiveAtomicCounterBufferiv, )
  OGLM_AVAIL_CHECK(__glewGetActiveAtomicCounterBufferiv, glGetActiveAtomicCounterBufferiv)
  OGLM_SIZE_ENUM(AtomicCounterBufferPName,pname,1)
  GLint* params = OGLM_ALLOC(pname_count,GLint,params);
  glGetActiveAtomicCounterBufferiv(program, bufferIndex, pname, params);
  OGLM_CHECK_ERR(glGetActiveAtomicCounterBufferiv, free(params);)
  OGLM_OUT_FINISH(params,pname_count,newSViv)
  free(params);

void
glGetActiveAttrib_c(program, index, bufSize, length, size, type, name)
  GLuint program;
  GLuint index;
  GLsizei bufSize;
  GLsizei* length;
  GLint* size;
  GLenum* type;
  GLchar* name;
CODE:
  OGLM_GLEWINIT
  OGLM_CHECK_ERR(glGetActiveAttrib, )
  OGLM_AVAIL_CHECK(__glewGetActiveAttrib, glGetActiveAttrib)
  glGetActiveAttrib(program, index, bufSize, length, size, type, name);
  OGLM_CHECK_ERR(glGetActiveAttrib, )

void
glGetActiveAttrib_p(program, index)
  GLuint program;
  GLuint index;
PPCODE:
  OGLM_GLEWINIT
  OGLM_CHECK_ERR(glGetActiveAttrib, )
  OGLM_AVAIL_CHECK(__glewGetActiveAttrib, glGetActiveAttrib)
  OGLM_AVAIL_CHECK(__glewGetProgramiv, glGetProgramiv)
  GLsizei bufSize;
  glGetProgramiv(program,GL_ACTIVE_ATTRIBUTE_MAX_LENGTH,&bufSize);
  GLsizei length[1];
  GLchar name[bufSize];
  GLint size[1];
  GLenum type[1];
  glGetActiveAttrib(program, index, bufSize, length, size, type, name);
  OGLM_CHECK_ERR(glGetActiveAttrib, )
  EXTEND(sp, 3);
  mPUSHs(newSViv(size[0]));
  mPUSHs(newSViv(type[0]));
  mPUSHs(newSVpv(name,0));

void
glGetActiveAttribARB_c(program, index, bufSize, length, size, type, name)
  GLhandleARB program;
  GLuint index;
  GLsizei bufSize;
  GLsizei* length;
  GLint *size;
  GLenum *type;
  GLcharARB *name;
CODE:
  OGLM_GLEWINIT
  OGLM_CHECK_ERR(glGetActiveAttribARB, )
  OGLM_AVAIL_CHECK(__glewGetActiveAttribARB, glGetActiveAttribARB)
  glGetActiveAttribARB(program, index, bufSize, length, size, type, name);
  OGLM_CHECK_ERR(glGetActiveAttribARB, )

void
glGetActiveAttribARB_p(program, index)
  GLhandleARB program;
  GLuint index;
PPCODE:
  OGLM_GLEWINIT
  OGLM_CHECK_ERR(glGetActiveAttribARB, )
  OGLM_AVAIL_CHECK(__glewGetActiveAttribARB, glGetActiveAttribARB)
  OGLM_AVAIL_CHECK(__glewGetProgramiv, glGetProgramiv)
  GLsizei bufSize;
  glGetProgramiv(program,GL_ACTIVE_ATTRIBUTE_MAX_LENGTH,&bufSize);
  GLsizei length[1];
  GLcharARB name[bufSize];
  GLint size[1];
  GLenum type[1];
  glGetActiveAttribARB(program, index, bufSize, length, size, type, name);
  OGLM_CHECK_ERR(glGetActiveAttribARB, )
  EXTEND(sp, 3);
  mPUSHs(newSViv(size[0]));
  mPUSHs(newSViv(type[0]));
  mPUSHs(newSVpv(name,0));

void
glGetActiveSubroutineName_c(program, shadertype, index, bufSize, length, name)
  GLuint program;
  GLenum shadertype;
  GLuint index;
  GLsizei bufSize;
  GLsizei* length;
  GLchar *name;
CODE:
  OGLM_GLEWINIT
  OGLM_CHECK_ERR(glGetActiveSubroutineName, )
  OGLM_AVAIL_CHECK(__glewGetActiveSubroutineName, glGetActiveSubroutineName)
  glGetActiveSubroutineName(program, shadertype, index, bufSize, length, name);
  OGLM_CHECK_ERR(glGetActiveSubroutineName, )

GLchar *
glGetActiveSubroutineName_p(program, shadertype, index)
  GLuint program;
  GLenum shadertype;
  GLuint index;
CODE:
  OGLM_GLEWINIT
  OGLM_CHECK_ERR(glGetActiveSubroutineName, )
  OGLM_AVAIL_CHECK(__glewGetActiveSubroutineName, glGetActiveSubroutineName)
  OGLM_AVAIL_CHECK(__glewGetProgramStageiv, glGetProgramStageiv)
  GLsizei bufSize;
  glGetProgramStageiv(program,shadertype,GL_ACTIVE_SUBROUTINE_UNIFORM_MAX_LENGTH,&bufSize);
  GLsizei length[1];
  GLchar name[bufSize];
  glGetActiveSubroutineName(program, shadertype, index, bufSize, length, name);
  OGLM_CHECK_ERR(glGetActiveSubroutineName, )
  RETVAL = name;
OUTPUT:
  RETVAL

void
glGetActiveSubroutineUniformName_c(program, shadertype, index, bufSize, length, name)
  GLuint program;
  GLenum shadertype;
  GLuint index;
  GLsizei bufSize;
  GLsizei* length;
  GLchar *name;
CODE:
  OGLM_GLEWINIT
  OGLM_CHECK_ERR(glGetActiveSubroutineUniformName, )
  OGLM_AVAIL_CHECK(__glewGetActiveSubroutineUniformName, glGetActiveSubroutineUniformName)
  glGetActiveSubroutineUniformName(program, shadertype, index, bufSize, length, name);
  OGLM_CHECK_ERR(glGetActiveSubroutineUniformName, )

GLchar *
glGetActiveSubroutineUniformName_p(program, shadertype, index)
  GLuint program;
  GLenum shadertype;
  GLuint index;
CODE:
  OGLM_GLEWINIT
  OGLM_CHECK_ERR(glGetActiveSubroutineUniformName, )
  OGLM_AVAIL_CHECK(__glewGetActiveSubroutineUniformName, glGetActiveSubroutineUniformName)
  OGLM_AVAIL_CHECK(__glewGetActiveSubroutineUniformiv, glGetActiveSubroutineUniformiv)
  GLsizei bufSize;
  glGetActiveSubroutineUniformiv(program,shadertype,index,GL_UNIFORM_NAME_LENGTH,&bufSize);
  GLsizei* length = NULL;
  GLchar name[bufSize];
  glGetActiveSubroutineUniformName(program, shadertype, index, bufSize, length, name);
  OGLM_CHECK_ERR(glGetActiveSubroutineUniformName, )
  RETVAL = name;
OUTPUT:
  RETVAL

void
glGetActiveSubroutineUniformiv_c(program, shadertype, index, pname, values)
  GLuint program;
  GLenum shadertype;
  GLuint index;
  GLenum pname;
  GLint* values;
CODE:
  OGLM_GLEWINIT
  OGLM_CHECK_ERR(glGetActiveSubroutineUniformiv, )
  OGLM_AVAIL_CHECK(__glewGetActiveSubroutineUniformiv, glGetActiveSubroutineUniformiv)
  glGetActiveSubroutineUniformiv(program, shadertype, index, pname, values);
  OGLM_CHECK_ERR(glGetActiveSubroutineUniformiv, )

void
glGetActiveSubroutineUniformiv_p(program, shadertype, index, pname)
  GLuint program;
  GLenum shadertype;
  GLuint index;
  GLenum pname;
PPCODE:
  OGLM_GLEWINIT
  OGLM_CHECK_ERR(glGetActiveSubroutineUniformiv, )
  OGLM_AVAIL_CHECK(__glewGetActiveSubroutineUniformiv, glGetActiveSubroutineUniformiv)
  OGLM_SIZE_ENUM(SubroutineParameterName,pname,1)
  GLint* values = OGLM_ALLOC(pname_count,GLint,values);
  glGetActiveSubroutineUniformiv(program, shadertype, index, pname, values);
  OGLM_CHECK_ERR(glGetActiveSubroutineUniformiv, free(values);)
  OGLM_OUT_FINISH(values,pname_count,newSViv)
  free(values);

void
glGetActiveUniform_c(program, index, bufSize, length, size, type, name)
  GLuint program;
  GLuint index;
  GLsizei bufSize;
  GLsizei* length;
  GLint* size;
  GLenum* type;
  GLchar* name;
CODE:
  OGLM_GLEWINIT
  OGLM_CHECK_ERR(glGetActiveUniform, )
  OGLM_AVAIL_CHECK(__glewGetActiveUniform, glGetActiveUniform)
  glGetActiveUniform(program, index, bufSize, length, size, type, name);
  OGLM_CHECK_ERR(glGetActiveUniform, )

void
glGetActiveUniform_p(program, index)
  GLuint program;
  GLuint index;
PPCODE:
  OGLM_GLEWINIT
  OGLM_CHECK_ERR(glGetActiveUniform, )
  OGLM_AVAIL_CHECK(__glewGetActiveUniform, glGetActiveUniform)
  OGLM_AVAIL_CHECK(__glewGetProgramiv, glGetProgramiv)
  GLsizei bufSize;
  glGetProgramiv(program,GL_ACTIVE_UNIFORM_MAX_LENGTH,&bufSize);
  GLsizei* length = NULL;
  GLchar name[bufSize];
  GLint size[1];
  GLenum type[1];
  glGetActiveUniform(program, index, bufSize, length, size, type, name);
  OGLM_CHECK_ERR(glGetActiveUniform, )
  EXTEND(sp, 3);
  mPUSHs(newSViv(size[0]));
  mPUSHs(newSViv(type[0]));
  mPUSHs(newSVpv(name,0));

void
glGetActiveUniformARB_c(program, index, bufSize, length, size, type, name)
  GLhandleARB program;
  GLuint index;
  GLsizei bufSize;
  GLsizei* length;
  GLint *size;
  GLenum *type;
  GLcharARB *name;
CODE:
  OGLM_GLEWINIT
  OGLM_CHECK_ERR(glGetActiveUniformARB, )
  OGLM_AVAIL_CHECK(__glewGetActiveUniformARB, glGetActiveUniformARB)
  glGetActiveUniformARB(program, index, bufSize, length, size, type, name);
  OGLM_CHECK_ERR(glGetActiveUniformARB, )

void
glGetActiveUniformARB_p(program, index)
  GLhandleARB program;
  GLuint index;
PPCODE:
  OGLM_GLEWINIT
  OGLM_CHECK_ERR(glGetActiveUniformARB, )
  OGLM_AVAIL_CHECK(__glewGetActiveUniformARB, glGetActiveUniformARB)
  OGLM_AVAIL_CHECK(__glewGetProgramiv, glGetProgramiv)
  GLsizei bufSize;
  glGetProgramiv(program,GL_ACTIVE_UNIFORM_MAX_LENGTH,&bufSize);
  GLsizei* length = NULL;
  GLcharARB name[bufSize];
  GLint size[1];
  GLenum type[1];
  glGetActiveUniformARB(program, index, bufSize, length, size, type, name);
  OGLM_CHECK_ERR(glGetActiveUniformARB, )
  EXTEND(sp, 3);
  mPUSHs(newSViv(size[0]));
  mPUSHs(newSViv(type[0]));
  mPUSHs(newSVpv(name,0));

void
glGetActiveUniformBlockName_c(program, uniformBlockIndex, bufSize, length, uniformBlockName)
  GLuint program;
  GLuint uniformBlockIndex;
  GLsizei bufSize;
  GLsizei* length;
  GLchar* uniformBlockName;
CODE:
  OGLM_GLEWINIT
  OGLM_CHECK_ERR(glGetActiveUniformBlockName, )
  OGLM_AVAIL_CHECK(__glewGetActiveUniformBlockName, glGetActiveUniformBlockName)
  glGetActiveUniformBlockName(program, uniformBlockIndex, bufSize, length, uniformBlockName);
  OGLM_CHECK_ERR(glGetActiveUniformBlockName, )

GLchar* 
glGetActiveUniformBlockName_p(program, uniformBlockIndex)
  GLuint program;
  GLuint uniformBlockIndex;
CODE:
  OGLM_GLEWINIT
  OGLM_CHECK_ERR(glGetActiveUniformBlockName, )
  OGLM_AVAIL_CHECK(__glewGetActiveUniformBlockName, glGetActiveUniformBlockName)
  OGLM_AVAIL_CHECK(__glewGetActiveUniformBlockiv, glGetActiveUniformBlockiv)
  GLsizei bufSize;
  glGetActiveUniformBlockiv(program,uniformBlockIndex,GL_UNIFORM_BLOCK_NAME_LENGTH,&bufSize);
  GLsizei* length = NULL;
  GLchar uniformBlockName[bufSize];
  glGetActiveUniformBlockName(program, uniformBlockIndex, bufSize, length, uniformBlockName);
  OGLM_CHECK_ERR(glGetActiveUniformBlockName, )
  RETVAL = uniformBlockName;
OUTPUT:
  RETVAL

void
glGetActiveUniformBlockiv_c(program, uniformBlockIndex, pname, params)
  GLuint program;
  GLuint uniformBlockIndex;
  GLenum pname;
  GLint* params;
CODE:
  OGLM_GLEWINIT
  OGLM_CHECK_ERR(glGetActiveUniformBlockiv, )
  OGLM_AVAIL_CHECK(__glewGetActiveUniformBlockiv, glGetActiveUniformBlockiv)
  glGetActiveUniformBlockiv(program, uniformBlockIndex, pname, params);
  OGLM_CHECK_ERR(glGetActiveUniformBlockiv, )

void
glGetActiveUniformName_c(program, uniformIndex, bufSize, length, uniformName)
  GLuint program;
  GLuint uniformIndex;
  GLsizei bufSize;
  GLsizei* length;
  GLchar* uniformName;
CODE:
  OGLM_GLEWINIT
  OGLM_CHECK_ERR(glGetActiveUniformName, )
  OGLM_AVAIL_CHECK(__glewGetActiveUniformName, glGetActiveUniformName)
  glGetActiveUniformName(program, uniformIndex, bufSize, length, uniformName);
  OGLM_CHECK_ERR(glGetActiveUniformName, )

GLchar* 
glGetActiveUniformName_p(program, uniformIndex)
  GLuint program;
  GLuint uniformIndex;
CODE:
  OGLM_GLEWINIT
  OGLM_CHECK_ERR(glGetActiveUniformName, )
  OGLM_AVAIL_CHECK(__glewGetActiveUniformName, glGetActiveUniformName)
  OGLM_AVAIL_CHECK(__glewGetProgramiv, glGetProgramiv)
  GLsizei bufSize;
  glGetProgramiv(program,GL_ACTIVE_UNIFORM_MAX_LENGTH,&bufSize);
  GLsizei* length = NULL;
  GLchar uniformName[bufSize];
  glGetActiveUniformName(program, uniformIndex, bufSize, length, uniformName);
  OGLM_CHECK_ERR(glGetActiveUniformName, )
  RETVAL = uniformName;
OUTPUT:
  RETVAL

void
glGetActiveUniformsiv_c(program, uniformCount, uniformIndices, pname, params)
  GLuint program;
  GLsizei uniformCount;
  const GLuint* uniformIndices;
  GLenum pname;
  GLint* params;
CODE:
  OGLM_GLEWINIT
  OGLM_CHECK_ERR(glGetActiveUniformsiv, )
  OGLM_AVAIL_CHECK(__glewGetActiveUniformsiv, glGetActiveUniformsiv)
  glGetActiveUniformsiv(program, uniformCount, uniformIndices, pname, params);
  OGLM_CHECK_ERR(glGetActiveUniformsiv, )

void
glGetActiveUniformsiv_p(program, pname, ...)
  GLuint program;
  GLenum pname;
PPCODE:
  OGLM_GLEWINIT
  OGLM_CHECK_ERR(glGetActiveUniformsiv, )
  OGLM_AVAIL_CHECK(__glewGetActiveUniformsiv, glGetActiveUniformsiv)
  GLsizei uniformCount = items-2;
  OGLM_SIZE_ENUM(UniformPName,pname,uniformCount)
  GLint* params = OGLM_ALLOC(pname_count,GLint,params);
  GLuint* uniformIndices = OGLM_GET_VARARGS(uniformIndices,2,GLuint,UV,uniformCount);
  glGetActiveUniformsiv((GLuint )program, (GLsizei )uniformCount, (const GLuint* )uniformIndices, (GLenum )pname, (GLint* )params);
  OGLM_CHECK_ERR(glGetActiveUniformsiv, free(params);free(uniformIndices);)
  OGLM_OUT_FINISH(params,pname_count,newSViv)
  free(params);free(uniformIndices);

void
glGetActiveVaryingNV_c(program, index, bufSize, length, size, type, name)
  GLuint program;
  GLuint index;
  GLsizei bufSize;
  GLsizei *length;
  GLsizei *size;
  GLenum *type;
  GLchar *name;
CODE:
  OGLM_GLEWINIT
  OGLM_CHECK_ERR(glGetActiveVaryingNV, )
  OGLM_AVAIL_CHECK(__glewGetActiveVaryingNV, glGetActiveVaryingNV)
  glGetActiveVaryingNV(program, index, bufSize, length, size, type, name);
  OGLM_CHECK_ERR(glGetActiveVaryingNV, )

void
glGetActiveVaryingNV_p(program, index, bufSize)
  GLuint program;
  GLuint index;
  GLsizei bufSize;
PPCODE:
  OGLM_GLEWINIT
  OGLM_CHECK_ERR(glGetActiveVaryingNV, )
  OGLM_AVAIL_CHECK(__glewGetActiveVaryingNV, glGetActiveVaryingNV)
  GLsizei length[1];
  GLchar name[bufSize];
  GLsizei size[1];
  GLenum type[1];
  glGetActiveVaryingNV(program, index, bufSize, length, size, type, name);
  OGLM_CHECK_ERR(glGetActiveVaryingNV, )
  EXTEND(sp, 4);
  mPUSHs(newSViv(length[0]));
  mPUSHs(newSViv(size[0]));
  mPUSHs(newSViv(type[0]));
  mPUSHs(newSVpv(name,0));

void
glGetArrayObjectfvATI_c(array, pname, params)
  GLenum array;
  GLenum pname;
  GLfloat* params;
CODE:
  OGLM_GLEWINIT
  OGLM_CHECK_ERR(glGetArrayObjectfvATI, )
  OGLM_AVAIL_CHECK(__glewGetArrayObjectfvATI, glGetArrayObjectfvATI)
  glGetArrayObjectfvATI(array, pname, params);
  OGLM_CHECK_ERR(glGetArrayObjectfvATI, )

GLfloat
glGetArrayObjectfvATI_p(array, pname)
  GLenum array;
  GLenum pname;
CODE:
  OGLM_GLEWINIT
  OGLM_CHECK_ERR(glGetArrayObjectfvATI, )
  OGLM_AVAIL_CHECK(__glewGetArrayObjectfvATI, glGetArrayObjectfvATI)
  GLfloat params[1];
  glGetArrayObjectfvATI(array, pname, params);
  OGLM_CHECK_ERR(glGetArrayObjectfvATI, )
  RETVAL = params[0];
OUTPUT:
  RETVAL

void
glGetArrayObjectivATI_c(array, pname, params)
  GLenum array;
  GLenum pname;
  GLint* params;
CODE:
  OGLM_GLEWINIT
  OGLM_CHECK_ERR(glGetArrayObjectivATI, )
  OGLM_AVAIL_CHECK(__glewGetArrayObjectivATI, glGetArrayObjectivATI)
  glGetArrayObjectivATI(array, pname, params);
  OGLM_CHECK_ERR(glGetArrayObjectivATI, )

GLint
glGetArrayObjectivATI_p(array, pname)
  GLenum array;
  GLenum pname;
CODE:
  OGLM_GLEWINIT
  OGLM_CHECK_ERR(glGetArrayObjectivATI, )
  OGLM_AVAIL_CHECK(__glewGetArrayObjectivATI, glGetArrayObjectivATI)
  GLint params[1];
  glGetArrayObjectivATI(array, pname, params);
  OGLM_CHECK_ERR(glGetArrayObjectivATI, )
  RETVAL = params[0];
OUTPUT:
  RETVAL

void
glGetAttachedObjectsARB_c(containerObj, maxCount, count, obj)
  GLhandleARB containerObj;
  GLsizei maxCount;
  GLsizei* count;
  GLhandleARB *obj;
CODE:
  OGLM_GLEWINIT
  OGLM_CHECK_ERR(glGetAttachedObjectsARB, )
  OGLM_AVAIL_CHECK(__glewGetAttachedObjectsARB, glGetAttachedObjectsARB)
  glGetAttachedObjectsARB(containerObj, maxCount, count, obj);
  OGLM_CHECK_ERR(glGetAttachedObjectsARB, )

void
glGetAttachedShaders_c(program, maxCount, count, shaders)
  GLuint program;
  GLsizei maxCount;
  GLsizei* count;
  GLuint* shaders;
CODE:
  OGLM_GLEWINIT
  OGLM_CHECK_ERR(glGetAttachedShaders, )
  OGLM_AVAIL_CHECK(__glewGetAttachedShaders, glGetAttachedShaders)
  glGetAttachedShaders(program, maxCount, count, shaders);
  OGLM_CHECK_ERR(glGetAttachedShaders, )

void
glGetAttachedShaders_p(program)
  GLuint program;
PPCODE:
  OGLM_GLEWINIT
  OGLM_CHECK_ERR(glGetAttachedShaders, )
  OGLM_AVAIL_CHECK(__glewGetAttachedShaders, glGetAttachedShaders)
  OGLM_AVAIL_CHECK(__glewGetProgramiv, glGetProgramiv)
  GLsizei maxCount;
  glGetProgramiv(program,GL_ATTACHED_SHADERS,&maxCount);
  GLuint* shaders = OGLM_ALLOC(maxCount,GLuint,shaders);
  GLsizei count[1];
  glGetAttachedShaders(program, maxCount, count, shaders);
  OGLM_CHECK_ERR(glGetAttachedShaders, free(shaders);)
  OGLM_OUT_FINISH(shaders,maxCount,newSVuv)
  free(shaders);

GLint
glGetAttribLocation(program, name)
  GLuint program;
  const GLchar* name;
CODE:
  OGLM_GLEWINIT
  OGLM_CHECK_ERR(glGetAttribLocation, )
  OGLM_AVAIL_CHECK(__glewGetAttribLocation, glGetAttribLocation)
  RETVAL = glGetAttribLocation(program, name);
  OGLM_CHECK_ERR(glGetAttribLocation, )
OUTPUT:
  RETVAL

GLint
glGetAttribLocationARB(programObj, name)
  GLhandleARB programObj;
  const GLcharARB* name;
CODE:
  OGLM_GLEWINIT
  OGLM_CHECK_ERR(glGetAttribLocationARB, )
  OGLM_AVAIL_CHECK(__glewGetAttribLocationARB, glGetAttribLocationARB)
  RETVAL = glGetAttribLocationARB(programObj, name);
  OGLM_CHECK_ERR(glGetAttribLocationARB, )
OUTPUT:
  RETVAL

void
glGetBooleani_v_c(target, index, data)
  GLenum target;
  GLuint index;
  GLboolean* data;
ALIAS:
  glGetBooleanIndexedvEXT_c = 1
CODE:
  OGLM_GLEWINIT
  OGLM_CHECK_ERR(glGetBooleani_v, )
  OGLM_AVAIL_CHECK(__glewGetBooleani_v, glGetBooleani_v)
  glGetBooleani_v(target, index, data);
  OGLM_CHECK_ERR(glGetBooleani_v, )

void
glGetBooleani_v_p(target, index)
  GLenum target;
  GLuint index;
ALIAS:
  glGetBooleanIndexedvEXT_p = 1
PPCODE:
  OGLM_GLEWINIT
  OGLM_CHECK_ERR(glGetBooleani_v, )
  OGLM_AVAIL_CHECK(__glewGetBooleani_v, glGetBooleani_v)
  OGLM_SIZE_ENUM(BufferTargetARB,target,1)
  GLboolean* data = OGLM_ALLOC(target_count,GLboolean,data);
  glGetBooleani_v(target, index, data);
  OGLM_CHECK_ERR(glGetBooleani_v, free(data);)
  OGLM_OUT_FINISH(data,target_count,newSViv)
  free(data);

void
glGetBooleanv_c(pname, data)
  GLenum pname;
  GLboolean *data;
CODE:
  OGLM_GLEWINIT
  OGLM_CHECK_ERR(glGetBooleanv, )
  glGetBooleanv(pname, data);
  OGLM_CHECK_ERR(glGetBooleanv, )

void
glGetBooleanv_p(pname)
  GLenum pname;
PPCODE:
  OGLM_GLEWINIT
  OGLM_CHECK_ERR(glGetBooleanv, )
  OGLM_SIZE_ENUM(GetPName,pname,1)
  GLboolean *data = OGLM_ALLOC(pname_count,GLboolean,data);
  glGetBooleanv(pname, data);
  OGLM_CHECK_ERR(glGetBooleanv, free(data);)
  OGLM_OUT_FINISH(data,pname_count,newSViv)
  free(data);

void
glGetBufferParameteri64v_c(target, pname, params)
  GLenum target;
  GLenum pname;
  GLint64 * params;
CODE:
  OGLM_GLEWINIT
  OGLM_CHECK_ERR(glGetBufferParameteri64v, )
  OGLM_AVAIL_CHECK(__glewGetBufferParameteri64v, glGetBufferParameteri64v)
  glGetBufferParameteri64v(target, pname, params);
  OGLM_CHECK_ERR(glGetBufferParameteri64v, )

void
glGetBufferParameteri64v_p(target, pname)
  GLenum target;
  GLenum pname;
PPCODE:
  OGLM_GLEWINIT
  OGLM_CHECK_ERR(glGetBufferParameteri64v, )
  OGLM_AVAIL_CHECK(__glewGetBufferParameteri64v, glGetBufferParameteri64v)
  OGLM_SIZE_ENUM(BufferPNameARB,pname,1)
  GLint64 * params = OGLM_ALLOC(pname_count,GLint64,params);
  glGetBufferParameteri64v(target, pname, params);
  OGLM_CHECK_ERR(glGetBufferParameteri64v, free(params);)
  OGLM_OUT_FINISH(params,pname_count,newSViv)
  free(params);

void
glGetBufferParameteriv_c(target, pname, params)
  GLenum target;
  GLenum pname;
  GLint* params;
ALIAS:
  glGetBufferParameterivARB_c = 1
CODE:
  OGLM_GLEWINIT
  OGLM_CHECK_ERR(glGetBufferParameteriv, )
  OGLM_AVAIL_CHECK(__glewGetBufferParameteriv, glGetBufferParameteriv)
  glGetBufferParameteriv(target, pname, params);
  OGLM_CHECK_ERR(glGetBufferParameteriv, )

void
glGetBufferParameteriv_p(target, pname)
  GLenum target;
  GLenum pname;
ALIAS:
  glGetBufferParameterivARB_p = 1
PPCODE:
  OGLM_GLEWINIT
  OGLM_CHECK_ERR(glGetBufferParameteriv, )
  OGLM_AVAIL_CHECK(__glewGetBufferParameteriv, glGetBufferParameteriv)
  OGLM_SIZE_ENUM(BufferPNameARB,pname,1)
  GLint* params = OGLM_ALLOC(pname_count,GLint,params);
  glGetBufferParameteriv(target, pname, params);
  OGLM_CHECK_ERR(glGetBufferParameteriv, free(params);)
  OGLM_OUT_FINISH(params,pname_count,newSViv)
  free(params);

void
glGetBufferParameterui64vNV_c(target, pname, params)
  GLenum target;
  GLenum pname;
  GLuint64EXT* params;
CODE:
  OGLM_GLEWINIT
  OGLM_CHECK_ERR(glGetBufferParameterui64vNV, )
  OGLM_AVAIL_CHECK(__glewGetBufferParameterui64vNV, glGetBufferParameterui64vNV)
  glGetBufferParameterui64vNV(target, pname, params);
  OGLM_CHECK_ERR(glGetBufferParameterui64vNV, )

void
glGetBufferPointerv_c(target, pname, params)
  GLenum target;
  GLenum pname;
  void** params;
ALIAS:
  glGetBufferPointervARB_c = 1
CODE:
  OGLM_GLEWINIT
  OGLM_CHECK_ERR(glGetBufferPointerv, )
  OGLM_AVAIL_CHECK(__glewGetBufferPointerv, glGetBufferPointerv)
  glGetBufferPointerv(target, pname, params);
  OGLM_CHECK_ERR(glGetBufferPointerv, )

void
glGetBufferPointervOES_c(target, pname, params)
  GLenum target;
  GLenum pname;
  void** params;
CODE:
  OGLM_GLEWINIT
  OGLM_CHECK_ERR(glGetBufferPointervOES, )
  OGLM_AVAIL_CHECK(__glewGetBufferPointervOES, glGetBufferPointervOES)
  glGetBufferPointervOES(target, pname, params);
  OGLM_CHECK_ERR(glGetBufferPointervOES, )

void
glGetBufferSubData_c(target, offset, size, data)
  GLenum target;
  GLintptr offset;
  GLsizeiptr size;
  void* data;
ALIAS:
  glGetBufferSubDataARB_c = 1
CODE:
  OGLM_GLEWINIT
  OGLM_CHECK_ERR(glGetBufferSubData, )
  OGLM_AVAIL_CHECK(__glewGetBufferSubData, glGetBufferSubData)
  glGetBufferSubData(target, offset, size, data);
  OGLM_CHECK_ERR(glGetBufferSubData, )

void
glGetClipPlane_c(plane, equation)
  GLenum plane;
  GLdouble *equation;
CODE:
  OGLM_GLEWINIT
  OGLM_CHECK_ERR(glGetClipPlane, )
  glGetClipPlane(plane, equation);
  OGLM_CHECK_ERR(glGetClipPlane, )

void
glGetClipPlane_p(plane)
  GLenum plane;
PPCODE:
  OGLM_GLEWINIT
  OGLM_CHECK_ERR(glGetClipPlane, )
  GLdouble *equation = OGLM_ALLOC(4,GLdouble,equation);
  glGetClipPlane(plane, equation);
  OGLM_CHECK_ERR(glGetClipPlane, free(equation);)
  OGLM_OUT_FINISH(equation,4,newSVnv)
  free(equation);

void
glGetClipPlanef_c(plane, equation)
  GLenum plane;
  GLfloat * equation;
CODE:
  OGLM_GLEWINIT
  OGLM_CHECK_ERR(glGetClipPlanef, )
  OGLM_AVAIL_CHECK(__glewGetClipPlanef, glGetClipPlanef)
  glGetClipPlanef(plane, equation);
  OGLM_CHECK_ERR(glGetClipPlanef, )

void
glGetClipPlanef_p(plane)
  GLenum plane;
PPCODE:
  OGLM_GLEWINIT
  OGLM_CHECK_ERR(glGetClipPlanef, )
  OGLM_AVAIL_CHECK(__glewGetClipPlanef, glGetClipPlanef)
  GLfloat * equation = OGLM_ALLOC(4,GLfloat,equation);
  glGetClipPlanef(plane, equation);
  OGLM_CHECK_ERR(glGetClipPlanef, free(equation);)
  OGLM_OUT_FINISH(equation,4,newSVnv)
  free(equation);

void
glGetClipPlanefOES_c(plane, equation)
  GLenum plane;
  GLfloat* equation;
CODE:
  OGLM_GLEWINIT
  OGLM_CHECK_ERR(glGetClipPlanefOES, )
  OGLM_AVAIL_CHECK(__glewGetClipPlanefOES, glGetClipPlanefOES)
  glGetClipPlanefOES(plane, equation);
  OGLM_CHECK_ERR(glGetClipPlanefOES, )

void
glGetClipPlanex_c(plane, equation)
  GLenum plane;
  GLfixed * equation;
CODE:
  OGLM_GLEWINIT
  OGLM_CHECK_ERR(glGetClipPlanex, )
  OGLM_AVAIL_CHECK(__glewGetClipPlanex, glGetClipPlanex)
  glGetClipPlanex(plane, equation);
  OGLM_CHECK_ERR(glGetClipPlanex, )

void
glGetClipPlanex_p(plane)
  GLenum plane;
PPCODE:
  OGLM_GLEWINIT
  OGLM_CHECK_ERR(glGetClipPlanex, )
  OGLM_AVAIL_CHECK(__glewGetClipPlanex, glGetClipPlanex)
  GLfixed * equation = OGLM_ALLOC(4,GLfixed,equation);
  glGetClipPlanex(plane, equation);
  OGLM_CHECK_ERR(glGetClipPlanex, free(equation);)
  OGLM_OUT_FINISH(equation,4,newSViv)
  free(equation);

void
glGetColorTable_c(target, format, type, table)
  GLenum target;
  GLenum format;
  GLenum type;
  void *table;
ALIAS:
  glGetColorTableEXT_c = 1
CODE:
  OGLM_GLEWINIT
  OGLM_CHECK_ERR(glGetColorTable, )
  OGLM_AVAIL_CHECK(__glewGetColorTable, glGetColorTable)
  glGetColorTable(target, format, type, table);
  OGLM_CHECK_ERR(glGetColorTable, )

void
glGetColorTableParameterfv_c(target, pname, params)
  GLenum target;
  GLenum pname;
  GLfloat *params;
ALIAS:
  glGetColorTableParameterfvEXT_c = 1
CODE:
  OGLM_GLEWINIT
  OGLM_CHECK_ERR(glGetColorTableParameterfv, )
  OGLM_AVAIL_CHECK(__glewGetColorTableParameterfv, glGetColorTableParameterfv)
  glGetColorTableParameterfv(target, pname, params);
  OGLM_CHECK_ERR(glGetColorTableParameterfv, )

void
glGetColorTableParameterfv_p(target, pname)
  GLenum target;
  GLenum pname;
ALIAS:
  glGetColorTableParameterfvEXT_p = 1
PPCODE:
  OGLM_GLEWINIT
  OGLM_CHECK_ERR(glGetColorTableParameterfv, )
  OGLM_AVAIL_CHECK(__glewGetColorTableParameterfv, glGetColorTableParameterfv)
  OGLM_SIZE_ENUM(ColorTableParameterPName,pname,1)
  GLfloat *params = OGLM_ALLOC(pname_count,GLfloat,params);
  glGetColorTableParameterfv(target, pname, params);
  OGLM_CHECK_ERR(glGetColorTableParameterfv, free(params);)
  OGLM_OUT_FINISH(params,pname_count,newSVnv)
  free(params);

void
glGetColorTableParameterfvSGI_c(target, pname, params)
  GLenum target;
  GLenum pname;
  GLfloat* params;
CODE:
  OGLM_GLEWINIT
  OGLM_CHECK_ERR(glGetColorTableParameterfvSGI, )
  OGLM_AVAIL_CHECK(__glewGetColorTableParameterfvSGI, glGetColorTableParameterfvSGI)
  glGetColorTableParameterfvSGI(target, pname, params);
  OGLM_CHECK_ERR(glGetColorTableParameterfvSGI, )

void
glGetColorTableParameterfvSGI_p(target, pname)
  GLenum target;
  GLenum pname;
PPCODE:
  OGLM_GLEWINIT
  OGLM_CHECK_ERR(glGetColorTableParameterfvSGI, )
  OGLM_AVAIL_CHECK(__glewGetColorTableParameterfvSGI, glGetColorTableParameterfvSGI)
  OGLM_SIZE_ENUM(ColorTableParameterPName,pname,1)
  GLfloat* params = OGLM_ALLOC(pname_count,GLfloat,params);
  glGetColorTableParameterfvSGI(target, pname, params);
  OGLM_CHECK_ERR(glGetColorTableParameterfvSGI, free(params);)
  OGLM_OUT_FINISH(params,pname_count,newSVnv)
  free(params);

void
glGetColorTableParameteriv_c(target, pname, params)
  GLenum target;
  GLenum pname;
  GLint *params;
ALIAS:
  glGetColorTableParameterivEXT_c = 1
CODE:
  OGLM_GLEWINIT
  OGLM_CHECK_ERR(glGetColorTableParameteriv, )
  OGLM_AVAIL_CHECK(__glewGetColorTableParameteriv, glGetColorTableParameteriv)
  glGetColorTableParameteriv(target, pname, params);
  OGLM_CHECK_ERR(glGetColorTableParameteriv, )

void
glGetColorTableParameteriv_p(target, pname)
  GLenum target;
  GLenum pname;
ALIAS:
  glGetColorTableParameterivEXT_p = 1
PPCODE:
  OGLM_GLEWINIT
  OGLM_CHECK_ERR(glGetColorTableParameteriv, )
  OGLM_AVAIL_CHECK(__glewGetColorTableParameteriv, glGetColorTableParameteriv)
  OGLM_SIZE_ENUM(ColorTableParameterPName,pname,1)
  GLint *params = OGLM_ALLOC(pname_count,GLint,params);
  glGetColorTableParameteriv(target, pname, params);
  OGLM_CHECK_ERR(glGetColorTableParameteriv, free(params);)
  OGLM_OUT_FINISH(params,pname_count,newSViv)
  free(params);

void
glGetColorTableParameterivSGI_c(target, pname, params)
  GLenum target;
  GLenum pname;
  GLint* params;
CODE:
  OGLM_GLEWINIT
  OGLM_CHECK_ERR(glGetColorTableParameterivSGI, )
  OGLM_AVAIL_CHECK(__glewGetColorTableParameterivSGI, glGetColorTableParameterivSGI)
  glGetColorTableParameterivSGI(target, pname, params);
  OGLM_CHECK_ERR(glGetColorTableParameterivSGI, )

void
glGetColorTableParameterivSGI_p(target, pname)
  GLenum target;
  GLenum pname;
PPCODE:
  OGLM_GLEWINIT
  OGLM_CHECK_ERR(glGetColorTableParameterivSGI, )
  OGLM_AVAIL_CHECK(__glewGetColorTableParameterivSGI, glGetColorTableParameterivSGI)
  OGLM_SIZE_ENUM(ColorTableParameterPName,pname,1)
  GLint* params = OGLM_ALLOC(pname_count,GLint,params);
  glGetColorTableParameterivSGI(target, pname, params);
  OGLM_CHECK_ERR(glGetColorTableParameterivSGI, free(params);)
  OGLM_OUT_FINISH(params,pname_count,newSViv)
  free(params);

void
glGetColorTableSGI_c(target, format, type, table)
  GLenum target;
  GLenum format;
  GLenum type;
  void *table;
CODE:
  OGLM_GLEWINIT
  OGLM_CHECK_ERR(glGetColorTableSGI, )
  OGLM_AVAIL_CHECK(__glewGetColorTableSGI, glGetColorTableSGI)
  glGetColorTableSGI(target, format, type, table);
  OGLM_CHECK_ERR(glGetColorTableSGI, )

void
glGetCombinerInputParameterfvNV_c(stage, portion, variable, pname, params)
  GLenum stage;
  GLenum portion;
  GLenum variable;
  GLenum pname;
  GLfloat* params;
CODE:
  OGLM_GLEWINIT
  OGLM_CHECK_ERR(glGetCombinerInputParameterfvNV, )
  OGLM_AVAIL_CHECK(__glewGetCombinerInputParameterfvNV, glGetCombinerInputParameterfvNV)
  glGetCombinerInputParameterfvNV(stage, portion, variable, pname, params);
  OGLM_CHECK_ERR(glGetCombinerInputParameterfvNV, )

void
glGetCombinerInputParameterivNV_c(stage, portion, variable, pname, params)
  GLenum stage;
  GLenum portion;
  GLenum variable;
  GLenum pname;
  GLint* params;
CODE:
  OGLM_GLEWINIT
  OGLM_CHECK_ERR(glGetCombinerInputParameterivNV, )
  OGLM_AVAIL_CHECK(__glewGetCombinerInputParameterivNV, glGetCombinerInputParameterivNV)
  glGetCombinerInputParameterivNV(stage, portion, variable, pname, params);
  OGLM_CHECK_ERR(glGetCombinerInputParameterivNV, )

void
glGetCombinerOutputParameterfvNV_c(stage, portion, pname, params)
  GLenum stage;
  GLenum portion;
  GLenum pname;
  GLfloat* params;
CODE:
  OGLM_GLEWINIT
  OGLM_CHECK_ERR(glGetCombinerOutputParameterfvNV, )
  OGLM_AVAIL_CHECK(__glewGetCombinerOutputParameterfvNV, glGetCombinerOutputParameterfvNV)
  glGetCombinerOutputParameterfvNV(stage, portion, pname, params);
  OGLM_CHECK_ERR(glGetCombinerOutputParameterfvNV, )

void
glGetCombinerOutputParameterivNV_c(stage, portion, pname, params)
  GLenum stage;
  GLenum portion;
  GLenum pname;
  GLint* params;
CODE:
  OGLM_GLEWINIT
  OGLM_CHECK_ERR(glGetCombinerOutputParameterivNV, )
  OGLM_AVAIL_CHECK(__glewGetCombinerOutputParameterivNV, glGetCombinerOutputParameterivNV)
  glGetCombinerOutputParameterivNV(stage, portion, pname, params);
  OGLM_CHECK_ERR(glGetCombinerOutputParameterivNV, )

void
glGetCombinerStageParameterfvNV_c(stage, pname, params)
  GLenum stage;
  GLenum pname;
  GLfloat* params;
CODE:
  OGLM_GLEWINIT
  OGLM_CHECK_ERR(glGetCombinerStageParameterfvNV, )
  OGLM_AVAIL_CHECK(__glewGetCombinerStageParameterfvNV, glGetCombinerStageParameterfvNV)
  glGetCombinerStageParameterfvNV(stage, pname, params);
  OGLM_CHECK_ERR(glGetCombinerStageParameterfvNV, )

GLuint
glGetCommandHeaderNV(tokenID, size)
  GLenum tokenID;
  GLuint size;
CODE:
  OGLM_GLEWINIT
  OGLM_CHECK_ERR(glGetCommandHeaderNV, )
  OGLM_AVAIL_CHECK(__glewGetCommandHeaderNV, glGetCommandHeaderNV)
  RETVAL = glGetCommandHeaderNV(tokenID, size);
  OGLM_CHECK_ERR(glGetCommandHeaderNV, )
OUTPUT:
  RETVAL

void
glGetCompressedMultiTexImageEXT_c(texunit, target, lod, img)
  GLenum texunit;
  GLenum target;
  GLint lod;
  void *img;
CODE:
  OGLM_GLEWINIT
  OGLM_CHECK_ERR(glGetCompressedMultiTexImageEXT, )
  OGLM_AVAIL_CHECK(__glewGetCompressedMultiTexImageEXT, glGetCompressedMultiTexImageEXT)
  glGetCompressedMultiTexImageEXT(texunit, target, lod, img);
  OGLM_CHECK_ERR(glGetCompressedMultiTexImageEXT, )

void
glGetCompressedTexImage_c(target, level, img)
  GLenum target;
  GLint level;
  void *img;
ALIAS:
  glGetCompressedTexImageARB_c = 1
CODE:
  OGLM_GLEWINIT
  OGLM_CHECK_ERR(glGetCompressedTexImage, )
  OGLM_AVAIL_CHECK(__glewGetCompressedTexImage, glGetCompressedTexImage)
  glGetCompressedTexImage(target, level, img);
  OGLM_CHECK_ERR(glGetCompressedTexImage, )

void
glGetCompressedTextureImage_c(texture, level, bufSize, pixels)
  GLuint texture;
  GLint level;
  GLsizei bufSize;
  void *pixels;
CODE:
  OGLM_GLEWINIT
  OGLM_CHECK_ERR(glGetCompressedTextureImage, )
  OGLM_AVAIL_CHECK(__glewGetCompressedTextureImage, glGetCompressedTextureImage)
  glGetCompressedTextureImage(texture, level, bufSize, pixels);
  OGLM_CHECK_ERR(glGetCompressedTextureImage, )

void
glGetCompressedTextureImageEXT_c(texture, target, lod, img)
  GLuint texture;
  GLenum target;
  GLint lod;
  void *img;
CODE:
  OGLM_GLEWINIT
  OGLM_CHECK_ERR(glGetCompressedTextureImageEXT, )
  OGLM_AVAIL_CHECK(__glewGetCompressedTextureImageEXT, glGetCompressedTextureImageEXT)
  glGetCompressedTextureImageEXT(texture, target, lod, img);
  OGLM_CHECK_ERR(glGetCompressedTextureImageEXT, )

void
glGetCompressedTextureSubImage_c(texture, level, xoffset, yoffset, zoffset, width, height, depth, bufSize, pixels)
  GLuint texture;
  GLint level;
  GLint xoffset;
  GLint yoffset;
  GLint zoffset;
  GLsizei width;
  GLsizei height;
  GLsizei depth;
  GLsizei bufSize;
  void *pixels;
CODE:
  OGLM_GLEWINIT
  OGLM_CHECK_ERR(glGetCompressedTextureSubImage, )
  OGLM_AVAIL_CHECK(__glewGetCompressedTextureSubImage, glGetCompressedTextureSubImage)
  glGetCompressedTextureSubImage(texture, level, xoffset, yoffset, zoffset, width, height, depth, bufSize, pixels);
  OGLM_CHECK_ERR(glGetCompressedTextureSubImage, )

void
glGetConvolutionFilter_c(target, format, type, image)
  GLenum target;
  GLenum format;
  GLenum type;
  void *image;
CODE:
  OGLM_GLEWINIT
  OGLM_CHECK_ERR(glGetConvolutionFilter, )
  OGLM_AVAIL_CHECK(__glewGetConvolutionFilter, glGetConvolutionFilter)
  glGetConvolutionFilter(target, format, type, image);
  OGLM_CHECK_ERR(glGetConvolutionFilter, )

void
glGetConvolutionFilterEXT_c(target, format, type, image)
  GLenum target;
  GLenum format;
  GLenum type;
  void *image;
CODE:
  OGLM_GLEWINIT
  OGLM_CHECK_ERR(glGetConvolutionFilterEXT, )
  OGLM_AVAIL_CHECK(__glewGetConvolutionFilterEXT, glGetConvolutionFilterEXT)
  glGetConvolutionFilterEXT(target, format, type, image);
  OGLM_CHECK_ERR(glGetConvolutionFilterEXT, )

void
glGetConvolutionParameterfv_c(target, pname, params)
  GLenum target;
  GLenum pname;
  GLfloat *params;
CODE:
  OGLM_GLEWINIT
  OGLM_CHECK_ERR(glGetConvolutionParameterfv, )
  OGLM_AVAIL_CHECK(__glewGetConvolutionParameterfv, glGetConvolutionParameterfv)
  glGetConvolutionParameterfv(target, pname, params);
  OGLM_CHECK_ERR(glGetConvolutionParameterfv, )

void
glGetConvolutionParameterfv_p(target, pname)
  GLenum target;
  GLenum pname;
PPCODE:
  OGLM_GLEWINIT
  OGLM_CHECK_ERR(glGetConvolutionParameterfv, )
  OGLM_AVAIL_CHECK(__glewGetConvolutionParameterfv, glGetConvolutionParameterfv)
  OGLM_SIZE_ENUM(ConvolutionParameter,pname,1)
  GLfloat *params = OGLM_ALLOC(pname_count,GLfloat,params);
  glGetConvolutionParameterfv(target, pname, params);
  OGLM_CHECK_ERR(glGetConvolutionParameterfv, free(params);)
  OGLM_OUT_FINISH(params,pname_count,newSVnv)
  free(params);

void
glGetConvolutionParameterfvEXT_c(target, pname, params)
  GLenum target;
  GLenum pname;
  GLfloat* params;
CODE:
  OGLM_GLEWINIT
  OGLM_CHECK_ERR(glGetConvolutionParameterfvEXT, )
  OGLM_AVAIL_CHECK(__glewGetConvolutionParameterfvEXT, glGetConvolutionParameterfvEXT)
  glGetConvolutionParameterfvEXT(target, pname, params);
  OGLM_CHECK_ERR(glGetConvolutionParameterfvEXT, )

void
glGetConvolutionParameterfvEXT_p(target, pname)
  GLenum target;
  GLenum pname;
PPCODE:
  OGLM_GLEWINIT
  OGLM_CHECK_ERR(glGetConvolutionParameterfvEXT, )
  OGLM_AVAIL_CHECK(__glewGetConvolutionParameterfvEXT, glGetConvolutionParameterfvEXT)
  OGLM_SIZE_ENUM(ConvolutionParameter,pname,1)
  GLfloat* params = OGLM_ALLOC(pname_count,GLfloat,params);
  glGetConvolutionParameterfvEXT(target, pname, params);
  OGLM_CHECK_ERR(glGetConvolutionParameterfvEXT, free(params);)
  OGLM_OUT_FINISH(params,pname_count,newSVnv)
  free(params);

void
glGetConvolutionParameteriv_c(target, pname, params)
  GLenum target;
  GLenum pname;
  GLint *params;
CODE:
  OGLM_GLEWINIT
  OGLM_CHECK_ERR(glGetConvolutionParameteriv, )
  OGLM_AVAIL_CHECK(__glewGetConvolutionParameteriv, glGetConvolutionParameteriv)
  glGetConvolutionParameteriv(target, pname, params);
  OGLM_CHECK_ERR(glGetConvolutionParameteriv, )

void
glGetConvolutionParameteriv_p(target, pname)
  GLenum target;
  GLenum pname;
PPCODE:
  OGLM_GLEWINIT
  OGLM_CHECK_ERR(glGetConvolutionParameteriv, )
  OGLM_AVAIL_CHECK(__glewGetConvolutionParameteriv, glGetConvolutionParameteriv)
  OGLM_SIZE_ENUM(ConvolutionParameter,pname,1)
  GLint *params = OGLM_ALLOC(pname_count,GLint,params);
  glGetConvolutionParameteriv(target, pname, params);
  OGLM_CHECK_ERR(glGetConvolutionParameteriv, free(params);)
  OGLM_OUT_FINISH(params,pname_count,newSViv)
  free(params);

void
glGetConvolutionParameterivEXT_c(target, pname, params)
  GLenum target;
  GLenum pname;
  GLint* params;
CODE:
  OGLM_GLEWINIT
  OGLM_CHECK_ERR(glGetConvolutionParameterivEXT, )
  OGLM_AVAIL_CHECK(__glewGetConvolutionParameterivEXT, glGetConvolutionParameterivEXT)
  glGetConvolutionParameterivEXT(target, pname, params);
  OGLM_CHECK_ERR(glGetConvolutionParameterivEXT, )

void
glGetConvolutionParameterivEXT_p(target, pname)
  GLenum target;
  GLenum pname;
PPCODE:
  OGLM_GLEWINIT
  OGLM_CHECK_ERR(glGetConvolutionParameterivEXT, )
  OGLM_AVAIL_CHECK(__glewGetConvolutionParameterivEXT, glGetConvolutionParameterivEXT)
  OGLM_SIZE_ENUM(ConvolutionParameter,pname,1)
  GLint* params = OGLM_ALLOC(pname_count,GLint,params);
  glGetConvolutionParameterivEXT(target, pname, params);
  OGLM_CHECK_ERR(glGetConvolutionParameterivEXT, free(params);)
  OGLM_OUT_FINISH(params,pname_count,newSViv)
  free(params);

void
glGetCoverageModulationTableNV_c(bufsize, v)
  GLsizei bufsize;
  GLfloat* v;
CODE:
  OGLM_GLEWINIT
  OGLM_CHECK_ERR(glGetCoverageModulationTableNV, )
  OGLM_AVAIL_CHECK(__glewGetCoverageModulationTableNV, glGetCoverageModulationTableNV)
  glGetCoverageModulationTableNV(bufsize, v);
  OGLM_CHECK_ERR(glGetCoverageModulationTableNV, )

GLuint
glGetDebugMessageLog_c(count, bufSize, sources, types, ids, severities, lengths, messageLog)
  GLuint count;
  GLsizei bufSize;
  GLenum* sources;
  GLenum* types;
  GLuint* ids;
  GLenum* severities;
  GLsizei* lengths;
  GLchar* messageLog;
ALIAS:
  glGetDebugMessageLogARB_c = 1
  glGetDebugMessageLogKHR_c = 2
CODE:
  OGLM_GLEWINIT
  OGLM_CHECK_ERR(glGetDebugMessageLog, )
  OGLM_AVAIL_CHECK(__glewGetDebugMessageLog, glGetDebugMessageLog)
  RETVAL = glGetDebugMessageLog(count, bufSize, sources, types, ids, severities, lengths, messageLog);
  OGLM_CHECK_ERR(glGetDebugMessageLog, )
OUTPUT:
  RETVAL

GLuint
glGetDebugMessageLog_p(count, bufSize)
  GLuint count;
  GLsizei bufSize;
ALIAS:
  glGetDebugMessageLogARB_p = 1
  glGetDebugMessageLogKHR_p = 2
PPCODE:
  OGLM_GLEWINIT
  OGLM_CHECK_ERR(glGetDebugMessageLog, )
  OGLM_AVAIL_CHECK(__glewGetDebugMessageLog, glGetDebugMessageLog)
  GLuint* ids = OGLM_ALLOC(count,GLuint,ids);
  GLsizei* lengths = OGLM_ALLOC(count,GLsizei,lengths);
  GLenum* severities = OGLM_ALLOC(count,GLenum,severities);
  GLenum* sources = OGLM_ALLOC(count,GLenum,sources);
  GLenum* types = OGLM_ALLOC(count,GLenum,types);
  GLchar messageLog[bufSize];
  RETVAL = glGetDebugMessageLog(count, bufSize, sources, types, ids, severities, lengths, messageLog);
  OGLM_CHECK_ERR(glGetDebugMessageLog, free(sources);free(types);free(ids);free(severities);free(lengths);)
  EXTEND(sp, 7);
  mPUSHs(newSVuv(RETVAL));
  OGLM_PUSH_ARRAY(glGetDebugMessageLog, newSViv, sources, count)
  OGLM_PUSH_ARRAY(glGetDebugMessageLog, newSViv, types, count)
  OGLM_PUSH_ARRAY(glGetDebugMessageLog, newSVuv, ids, count)
  OGLM_PUSH_ARRAY(glGetDebugMessageLog, newSViv, severities, count)
  OGLM_PUSH_ARRAY(glGetDebugMessageLog, newSViv, lengths, count)
  mPUSHs(newSVpv(messageLog,0));
  free(sources);free(types);free(ids);free(severities);free(lengths);

GLuint
glGetDebugMessageLogAMD_c(count, bufSize, categories, severities, ids, lengths, message)
  GLuint count;
  GLsizei bufSize;
  GLenum* categories;
  GLenum* severities;
  GLuint* ids;
  GLsizei* lengths;
  GLchar* message;
CODE:
  OGLM_GLEWINIT
  OGLM_CHECK_ERR(glGetDebugMessageLogAMD, )
  OGLM_AVAIL_CHECK(__glewGetDebugMessageLogAMD, glGetDebugMessageLogAMD)
  RETVAL = glGetDebugMessageLogAMD(count, bufSize, categories, severities, ids, lengths, message);
  OGLM_CHECK_ERR(glGetDebugMessageLogAMD, )
OUTPUT:
  RETVAL

GLuint
glGetDebugMessageLogAMD_p(count, bufSize)
  GLuint count;
  GLsizei bufSize;
PPCODE:
  OGLM_GLEWINIT
  OGLM_CHECK_ERR(glGetDebugMessageLogAMD, )
  OGLM_AVAIL_CHECK(__glewGetDebugMessageLogAMD, glGetDebugMessageLogAMD)
  GLenum* categories = OGLM_ALLOC(count,GLenum,categories);
  GLuint* ids = OGLM_ALLOC(count,GLuint,ids);
  GLsizei* lengths = OGLM_ALLOC(count,GLsizei,lengths);
  GLenum* severities = OGLM_ALLOC(count,GLenum,severities);
  GLchar message[bufSize];
  RETVAL = glGetDebugMessageLogAMD(count, bufSize, categories, severities, ids, lengths, message);
  OGLM_CHECK_ERR(glGetDebugMessageLogAMD, free(categories);free(severities);free(ids);free(lengths);)
  EXTEND(sp, 6);
  mPUSHs(newSVuv(RETVAL));
  OGLM_PUSH_ARRAY(glGetDebugMessageLogAMD, newSViv, categories, count)
  OGLM_PUSH_ARRAY(glGetDebugMessageLogAMD, newSViv, severities, count)
  OGLM_PUSH_ARRAY(glGetDebugMessageLogAMD, newSVuv, ids, count)
  OGLM_PUSH_ARRAY(glGetDebugMessageLogAMD, newSViv, lengths, count)
  mPUSHs(newSVpv(message,0));
  free(categories);free(severities);free(ids);free(lengths);

void
glGetDetailTexFuncSGIS_c(target, points)
  GLenum target;
  GLfloat* points;
CODE:
  OGLM_GLEWINIT
  OGLM_CHECK_ERR(glGetDetailTexFuncSGIS, )
  OGLM_AVAIL_CHECK(__glewGetDetailTexFuncSGIS, glGetDetailTexFuncSGIS)
  glGetDetailTexFuncSGIS(target, points);
  OGLM_CHECK_ERR(glGetDetailTexFuncSGIS, )

void
glGetDetailTexFuncSGIS_p(target)
  GLenum target;
PPCODE:
  OGLM_GLEWINIT
  OGLM_CHECK_ERR(glGetDetailTexFuncSGIS, )
  OGLM_AVAIL_CHECK(__glewGetDetailTexFuncSGIS, glGetDetailTexFuncSGIS)
  OGLM_SIZE_ENUM(TextureTarget,target,1)
  GLfloat* points = OGLM_ALLOC(target_count,GLfloat,points);
  glGetDetailTexFuncSGIS(target, points);
  OGLM_CHECK_ERR(glGetDetailTexFuncSGIS, free(points);)
  OGLM_OUT_FINISH(points,target_count,newSVnv)
  free(points);

void
glGetDoublei_v_c(target, index, data)
  GLenum target;
  GLuint index;
  GLdouble* data;
ALIAS:
  glGetDoubleIndexedvEXT_c = 1
  glGetDoublei_vEXT_c = 2
CODE:
  OGLM_GLEWINIT
  OGLM_CHECK_ERR(glGetDoublei_v, )
  OGLM_AVAIL_CHECK(__glewGetDoublei_v, glGetDoublei_v)
  glGetDoublei_v(target, index, data);
  OGLM_CHECK_ERR(glGetDoublei_v, )

void
glGetDoublei_v_p(target, index)
  GLenum target;
  GLuint index;
ALIAS:
  glGetDoubleIndexedvEXT_p = 1
  glGetDoublei_vEXT_p = 2
PPCODE:
  OGLM_GLEWINIT
  OGLM_CHECK_ERR(glGetDoublei_v, )
  OGLM_AVAIL_CHECK(__glewGetDoublei_v, glGetDoublei_v)
  OGLM_SIZE_ENUM(GetPName,target,1)
  GLdouble* data = OGLM_ALLOC(target_count,GLdouble,data);
  glGetDoublei_v(target, index, data);
  OGLM_CHECK_ERR(glGetDoublei_v, free(data);)
  OGLM_OUT_FINISH(data,target_count,newSVnv)
  free(data);

void
glGetDoublev_c(pname, data)
  GLenum pname;
  GLdouble *data;
CODE:
  OGLM_GLEWINIT
  OGLM_CHECK_ERR(glGetDoublev, )
  glGetDoublev(pname, data);
  OGLM_CHECK_ERR(glGetDoublev, )

void
glGetDoublev_p(pname)
  GLenum pname;
PPCODE:
  OGLM_GLEWINIT
  OGLM_CHECK_ERR(glGetDoublev, )
  OGLM_SIZE_ENUM(GetPName,pname,1)
  GLdouble *data = OGLM_ALLOC(pname_count,GLdouble,data);
  glGetDoublev(pname, data);
  OGLM_CHECK_ERR(glGetDoublev, free(data);)
  OGLM_OUT_FINISH(data,pname_count,newSVnv)
  free(data);

void
glGetDriverControlStringQCOM_c(driverControl, bufSize, length, driverControlString)
  GLuint driverControl;
  GLsizei bufSize;
  GLsizei* length;
  GLchar *driverControlString;
CODE:
  OGLM_GLEWINIT
  OGLM_CHECK_ERR(glGetDriverControlStringQCOM, )
  OGLM_AVAIL_CHECK(__glewGetDriverControlStringQCOM, glGetDriverControlStringQCOM)
  glGetDriverControlStringQCOM(driverControl, bufSize, length, driverControlString);
  OGLM_CHECK_ERR(glGetDriverControlStringQCOM, )

void
glGetDriverControlsQCOM_c(num, size, driverControls)
  GLint* num;
  GLsizei size;
  GLuint *driverControls;
CODE:
  OGLM_GLEWINIT
  OGLM_CHECK_ERR(glGetDriverControlsQCOM, )
  OGLM_AVAIL_CHECK(__glewGetDriverControlsQCOM, glGetDriverControlsQCOM)
  glGetDriverControlsQCOM(num, size, driverControls);
  OGLM_CHECK_ERR(glGetDriverControlsQCOM, )

GLenum
glGetError()
CODE:
  OGLM_GLEWINIT
  RETVAL = glGetError();
OUTPUT:
  RETVAL

GLboolean
glGetExtensionREGAL(ext)
  const GLchar* ext;
CODE:
  OGLM_GLEWINIT
  OGLM_CHECK_ERR(glGetExtensionREGAL, )
  OGLM_AVAIL_CHECK(__glewGetExtensionREGAL, glGetExtensionREGAL)
  RETVAL = glGetExtensionREGAL(ext);
  OGLM_CHECK_ERR(glGetExtensionREGAL, )
OUTPUT:
  RETVAL

void
glGetFenceivNV_c(fence, pname, params)
  GLuint fence;
  GLenum pname;
  GLint* params;
CODE:
  OGLM_GLEWINIT
  OGLM_CHECK_ERR(glGetFenceivNV, )
  OGLM_AVAIL_CHECK(__glewGetFenceivNV, glGetFenceivNV)
  glGetFenceivNV(fence, pname, params);
  OGLM_CHECK_ERR(glGetFenceivNV, )

void
glGetFinalCombinerInputParameterfvNV_c(variable, pname, params)
  GLenum variable;
  GLenum pname;
  GLfloat* params;
CODE:
  OGLM_GLEWINIT
  OGLM_CHECK_ERR(glGetFinalCombinerInputParameterfvNV, )
  OGLM_AVAIL_CHECK(__glewGetFinalCombinerInputParameterfvNV, glGetFinalCombinerInputParameterfvNV)
  glGetFinalCombinerInputParameterfvNV(variable, pname, params);
  OGLM_CHECK_ERR(glGetFinalCombinerInputParameterfvNV, )

void
glGetFinalCombinerInputParameterivNV_c(variable, pname, params)
  GLenum variable;
  GLenum pname;
  GLint* params;
CODE:
  OGLM_GLEWINIT
  OGLM_CHECK_ERR(glGetFinalCombinerInputParameterivNV, )
  OGLM_AVAIL_CHECK(__glewGetFinalCombinerInputParameterivNV, glGetFinalCombinerInputParameterivNV)
  glGetFinalCombinerInputParameterivNV(variable, pname, params);
  OGLM_CHECK_ERR(glGetFinalCombinerInputParameterivNV, )

void
glGetFirstPerfQueryIdINTEL_c(queryId)
  GLuint* queryId;
CODE:
  OGLM_GLEWINIT
  OGLM_CHECK_ERR(glGetFirstPerfQueryIdINTEL, )
  OGLM_AVAIL_CHECK(__glewGetFirstPerfQueryIdINTEL, glGetFirstPerfQueryIdINTEL)
  glGetFirstPerfQueryIdINTEL(queryId);
  OGLM_CHECK_ERR(glGetFirstPerfQueryIdINTEL, )

void
glGetFixedv_c(pname, params)
  GLenum pname;
  GLfixed* params;
CODE:
  OGLM_GLEWINIT
  OGLM_CHECK_ERR(glGetFixedv, )
  OGLM_AVAIL_CHECK(__glewGetFixedv, glGetFixedv)
  glGetFixedv(pname, params);
  OGLM_CHECK_ERR(glGetFixedv, )

void
glGetFloati_v_c(target, index, data)
  GLenum target;
  GLuint index;
  GLfloat* data;
ALIAS:
  glGetFloatIndexedvEXT_c = 1
  glGetFloati_vEXT_c = 2
  glGetFloati_vNV_c = 3
CODE:
  OGLM_GLEWINIT
  OGLM_CHECK_ERR(glGetFloati_v, )
  OGLM_AVAIL_CHECK(__glewGetFloati_v, glGetFloati_v)
  glGetFloati_v(target, index, data);
  OGLM_CHECK_ERR(glGetFloati_v, )

void
glGetFloati_v_p(target, index)
  GLenum target;
  GLuint index;
ALIAS:
  glGetFloatIndexedvEXT_p = 1
  glGetFloati_vEXT_p = 2
  glGetFloati_vNV_p = 3
PPCODE:
  OGLM_GLEWINIT
  OGLM_CHECK_ERR(glGetFloati_v, )
  OGLM_AVAIL_CHECK(__glewGetFloati_v, glGetFloati_v)
  OGLM_SIZE_ENUM(GetPName,target,1)
  GLfloat* data = OGLM_ALLOC(target_count,GLfloat,data);
  glGetFloati_v(target, index, data);
  OGLM_CHECK_ERR(glGetFloati_v, free(data);)
  OGLM_OUT_FINISH(data,target_count,newSVnv)
  free(data);

void
glGetFloatv_c(pname, data)
  GLenum pname;
  GLfloat *data;
CODE:
  OGLM_GLEWINIT
  OGLM_CHECK_ERR(glGetFloatv, )
  glGetFloatv(pname, data);
  OGLM_CHECK_ERR(glGetFloatv, )

void
glGetFloatv_p(pname)
  GLenum pname;
PPCODE:
  OGLM_GLEWINIT
  OGLM_CHECK_ERR(glGetFloatv, )
  OGLM_SIZE_ENUM(GetPName,pname,1)
  GLfloat *data = OGLM_ALLOC(pname_count,GLfloat,data);
  glGetFloatv(pname, data);
  OGLM_CHECK_ERR(glGetFloatv, free(data);)
  OGLM_OUT_FINISH(data,pname_count,newSVnv)
  free(data);

void
glGetFogFuncSGIS_c(points)
  GLfloat* points;
CODE:
  OGLM_GLEWINIT
  OGLM_CHECK_ERR(glGetFogFuncSGIS, )
  OGLM_AVAIL_CHECK(__glewGetFogFuncSGIS, glGetFogFuncSGIS)
  glGetFogFuncSGIS(points);
  OGLM_CHECK_ERR(glGetFogFuncSGIS, )

void
glGetFogLayersSGIX_c(points)
  GLfloat* points;
CODE:
  OGLM_GLEWINIT
  OGLM_CHECK_ERR(glGetFogLayersSGIX, )
  OGLM_AVAIL_CHECK(__glewGetFogLayersSGIX, glGetFogLayersSGIX)
  glGetFogLayersSGIX(points);
  OGLM_CHECK_ERR(glGetFogLayersSGIX, )

GLint
glGetFragDataIndex(program, name)
  GLuint program;
  const GLchar * name;
ALIAS:
  glGetFragDataIndexEXT = 1
CODE:
  OGLM_GLEWINIT
  OGLM_CHECK_ERR(glGetFragDataIndex, )
  OGLM_AVAIL_CHECK(__glewGetFragDataIndex, glGetFragDataIndex)
  RETVAL = glGetFragDataIndex(program, name);
  OGLM_CHECK_ERR(glGetFragDataIndex, )
OUTPUT:
  RETVAL

GLint
glGetFragDataLocation(program, name)
  GLuint program;
  const GLchar* name;
ALIAS:
  glGetFragDataLocationEXT = 1
CODE:
  OGLM_GLEWINIT
  OGLM_CHECK_ERR(glGetFragDataLocation, )
  OGLM_AVAIL_CHECK(__glewGetFragDataLocation, glGetFragDataLocation)
  RETVAL = glGetFragDataLocation(program, name);
  OGLM_CHECK_ERR(glGetFragDataLocation, )
OUTPUT:
  RETVAL

void
glGetFragmentLightfvEXT_c(light, pname, params)
  GLenum light;
  GLenum pname;
  GLfloat* params;
CODE:
  OGLM_GLEWINIT
  OGLM_CHECK_ERR(glGetFragmentLightfvEXT, )
  OGLM_AVAIL_CHECK(__glewGetFragmentLightfvEXT, glGetFragmentLightfvEXT)
  glGetFragmentLightfvEXT(light, pname, params);
  OGLM_CHECK_ERR(glGetFragmentLightfvEXT, )

void
glGetFragmentLightfvSGIX_c(light, pname, params)
  GLenum light;
  GLenum pname;
  GLfloat* params;
CODE:
  OGLM_GLEWINIT
  OGLM_CHECK_ERR(glGetFragmentLightfvSGIX, )
  OGLM_AVAIL_CHECK(__glewGetFragmentLightfvSGIX, glGetFragmentLightfvSGIX)
  glGetFragmentLightfvSGIX(light, pname, params);
  OGLM_CHECK_ERR(glGetFragmentLightfvSGIX, )

void
glGetFragmentLightfvSGIX_p(light, pname)
  GLenum light;
  GLenum pname;
PPCODE:
  OGLM_GLEWINIT
  OGLM_CHECK_ERR(glGetFragmentLightfvSGIX, )
  OGLM_AVAIL_CHECK(__glewGetFragmentLightfvSGIX, glGetFragmentLightfvSGIX)
  OGLM_SIZE_ENUM(FragmentLightParameterSGIX,pname,1)
  GLfloat* params = OGLM_ALLOC(pname_count,GLfloat,params);
  glGetFragmentLightfvSGIX(light, pname, params);
  OGLM_CHECK_ERR(glGetFragmentLightfvSGIX, free(params);)
  OGLM_OUT_FINISH(params,pname_count,newSVnv)
  free(params);

void
glGetFragmentLightivEXT_c(light, pname, params)
  GLenum light;
  GLenum pname;
  GLint* params;
CODE:
  OGLM_GLEWINIT
  OGLM_CHECK_ERR(glGetFragmentLightivEXT, )
  OGLM_AVAIL_CHECK(__glewGetFragmentLightivEXT, glGetFragmentLightivEXT)
  glGetFragmentLightivEXT(light, pname, params);
  OGLM_CHECK_ERR(glGetFragmentLightivEXT, )

void
glGetFragmentLightivSGIX_c(light, pname, params)
  GLenum light;
  GLenum pname;
  GLint* params;
CODE:
  OGLM_GLEWINIT
  OGLM_CHECK_ERR(glGetFragmentLightivSGIX, )
  OGLM_AVAIL_CHECK(__glewGetFragmentLightivSGIX, glGetFragmentLightivSGIX)
  glGetFragmentLightivSGIX(light, pname, params);
  OGLM_CHECK_ERR(glGetFragmentLightivSGIX, )

void
glGetFragmentLightivSGIX_p(light, pname)
  GLenum light;
  GLenum pname;
PPCODE:
  OGLM_GLEWINIT
  OGLM_CHECK_ERR(glGetFragmentLightivSGIX, )
  OGLM_AVAIL_CHECK(__glewGetFragmentLightivSGIX, glGetFragmentLightivSGIX)
  OGLM_SIZE_ENUM(FragmentLightParameterSGIX,pname,1)
  GLint* params = OGLM_ALLOC(pname_count,GLint,params);
  glGetFragmentLightivSGIX(light, pname, params);
  OGLM_CHECK_ERR(glGetFragmentLightivSGIX, free(params);)
  OGLM_OUT_FINISH(params,pname_count,newSViv)
  free(params);

void
glGetFragmentMaterialfvEXT_c(face, pname, params)
  GLenum face;
  GLenum pname;
  const GLfloat* params;
CODE:
  OGLM_GLEWINIT
  OGLM_CHECK_ERR(glGetFragmentMaterialfvEXT, )
  OGLM_AVAIL_CHECK(__glewGetFragmentMaterialfvEXT, glGetFragmentMaterialfvEXT)
  glGetFragmentMaterialfvEXT(face, pname, params);
  OGLM_CHECK_ERR(glGetFragmentMaterialfvEXT, )

void
glGetFragmentMaterialfvSGIX_c(face, pname, params)
  GLenum face;
  GLenum pname;
  GLfloat* params;
CODE:
  OGLM_GLEWINIT
  OGLM_CHECK_ERR(glGetFragmentMaterialfvSGIX, )
  OGLM_AVAIL_CHECK(__glewGetFragmentMaterialfvSGIX, glGetFragmentMaterialfvSGIX)
  glGetFragmentMaterialfvSGIX(face, pname, params);
  OGLM_CHECK_ERR(glGetFragmentMaterialfvSGIX, )

void
glGetFragmentMaterialfvSGIX_p(face, pname)
  GLenum face;
  GLenum pname;
PPCODE:
  OGLM_GLEWINIT
  OGLM_CHECK_ERR(glGetFragmentMaterialfvSGIX, )
  OGLM_AVAIL_CHECK(__glewGetFragmentMaterialfvSGIX, glGetFragmentMaterialfvSGIX)
  OGLM_SIZE_ENUM(MaterialParameter,pname,1)
  GLfloat* params = OGLM_ALLOC(pname_count,GLfloat,params);
  glGetFragmentMaterialfvSGIX(face, pname, params);
  OGLM_CHECK_ERR(glGetFragmentMaterialfvSGIX, free(params);)
  OGLM_OUT_FINISH(params,pname_count,newSVnv)
  free(params);

void
glGetFragmentMaterialivEXT_c(face, pname, params)
  GLenum face;
  GLenum pname;
  const GLint* params;
CODE:
  OGLM_GLEWINIT
  OGLM_CHECK_ERR(glGetFragmentMaterialivEXT, )
  OGLM_AVAIL_CHECK(__glewGetFragmentMaterialivEXT, glGetFragmentMaterialivEXT)
  glGetFragmentMaterialivEXT(face, pname, params);
  OGLM_CHECK_ERR(glGetFragmentMaterialivEXT, )

void
glGetFragmentMaterialivSGIX_c(face, pname, params)
  GLenum face;
  GLenum pname;
  GLint* params;
CODE:
  OGLM_GLEWINIT
  OGLM_CHECK_ERR(glGetFragmentMaterialivSGIX, )
  OGLM_AVAIL_CHECK(__glewGetFragmentMaterialivSGIX, glGetFragmentMaterialivSGIX)
  glGetFragmentMaterialivSGIX(face, pname, params);
  OGLM_CHECK_ERR(glGetFragmentMaterialivSGIX, )

void
glGetFragmentMaterialivSGIX_p(face, pname)
  GLenum face;
  GLenum pname;
PPCODE:
  OGLM_GLEWINIT
  OGLM_CHECK_ERR(glGetFragmentMaterialivSGIX, )
  OGLM_AVAIL_CHECK(__glewGetFragmentMaterialivSGIX, glGetFragmentMaterialivSGIX)
  OGLM_SIZE_ENUM(MaterialParameter,pname,1)
  GLint* params = OGLM_ALLOC(pname_count,GLint,params);
  glGetFragmentMaterialivSGIX(face, pname, params);
  OGLM_CHECK_ERR(glGetFragmentMaterialivSGIX, free(params);)
  OGLM_OUT_FINISH(params,pname_count,newSViv)
  free(params);

void
glGetFragmentShadingRatesEXT_c(samples, maxCount, count, shadingRates)
  GLsizei samples;
  GLsizei maxCount;
  GLsizei* count;
  GLenum *shadingRates;
CODE:
  OGLM_GLEWINIT
  OGLM_CHECK_ERR(glGetFragmentShadingRatesEXT, )
  OGLM_AVAIL_CHECK(__glewGetFragmentShadingRatesEXT, glGetFragmentShadingRatesEXT)
  glGetFragmentShadingRatesEXT(samples, maxCount, count, shadingRates);
  OGLM_CHECK_ERR(glGetFragmentShadingRatesEXT, )

void
glGetFragmentShadingRatesEXT_p(samples, maxCount)
  GLsizei samples;
  GLsizei maxCount;
PPCODE:
  OGLM_GLEWINIT
  OGLM_CHECK_ERR(glGetFragmentShadingRatesEXT, )
  OGLM_AVAIL_CHECK(__glewGetFragmentShadingRatesEXT, glGetFragmentShadingRatesEXT)
  GLenum *shadingRates = OGLM_ALLOC(maxCount,GLenum,shadingRates);
  GLsizei count[1];
  glGetFragmentShadingRatesEXT(samples, maxCount, count, shadingRates);
  OGLM_CHECK_ERR(glGetFragmentShadingRatesEXT, free(shadingRates);)
  EXTEND(sp, 2);
  mPUSHs(newSViv(count[0]));
  OGLM_PUSH_ARRAY(glGetFragmentShadingRatesEXT, newSViv, shadingRates, maxCount)
  free(shadingRates);

void
glGetFramebufferAttachmentParameteriv_c(target, attachment, pname, params)
  GLenum target;
  GLenum attachment;
  GLenum pname;
  GLint* params;
ALIAS:
  glGetFramebufferAttachmentParameterivEXT_c = 1
CODE:
  OGLM_GLEWINIT
  OGLM_CHECK_ERR(glGetFramebufferAttachmentParameteriv, )
  OGLM_AVAIL_CHECK(__glewGetFramebufferAttachmentParameteriv, glGetFramebufferAttachmentParameteriv)
  glGetFramebufferAttachmentParameteriv(target, attachment, pname, params);
  OGLM_CHECK_ERR(glGetFramebufferAttachmentParameteriv, )

void
glGetFramebufferAttachmentParameteriv_p(target, attachment, pname)
  GLenum target;
  GLenum attachment;
  GLenum pname;
ALIAS:
  glGetFramebufferAttachmentParameterivEXT_p = 1
PPCODE:
  OGLM_GLEWINIT
  OGLM_CHECK_ERR(glGetFramebufferAttachmentParameteriv, )
  OGLM_AVAIL_CHECK(__glewGetFramebufferAttachmentParameteriv, glGetFramebufferAttachmentParameteriv)
  OGLM_SIZE_ENUM(FramebufferAttachmentParameterName,pname,1)
  GLint* params = OGLM_ALLOC(pname_count,GLint,params);
  glGetFramebufferAttachmentParameteriv(target, attachment, pname, params);
  OGLM_CHECK_ERR(glGetFramebufferAttachmentParameteriv, free(params);)
  OGLM_OUT_FINISH(params,pname_count,newSViv)
  free(params);

void
glGetFramebufferAttachmentParameterivOES_c(target, attachment, pname, params)
  GLenum target;
  GLenum attachment;
  GLenum pname;
  GLint* params;
CODE:
  OGLM_GLEWINIT
  OGLM_CHECK_ERR(glGetFramebufferAttachmentParameterivOES, )
  OGLM_AVAIL_CHECK(__glewGetFramebufferAttachmentParameterivOES, glGetFramebufferAttachmentParameterivOES)
  glGetFramebufferAttachmentParameterivOES(target, attachment, pname, params);
  OGLM_CHECK_ERR(glGetFramebufferAttachmentParameterivOES, )

void
glGetFramebufferParameterfvAMD_c(target, pname, numsamples, pixelindex, size, values)
  GLenum target;
  GLenum pname;
  GLuint numsamples;
  GLuint pixelindex;
  GLsizei size;
  GLfloat* values;
CODE:
  OGLM_GLEWINIT
  OGLM_CHECK_ERR(glGetFramebufferParameterfvAMD, )
  OGLM_AVAIL_CHECK(__glewGetFramebufferParameterfvAMD, glGetFramebufferParameterfvAMD)
  glGetFramebufferParameterfvAMD(target, pname, numsamples, pixelindex, size, values);
  OGLM_CHECK_ERR(glGetFramebufferParameterfvAMD, )

void
glGetFramebufferParameteriv_c(target, pname, params)
  GLenum target;
  GLenum pname;
  GLint* params;
CODE:
  OGLM_GLEWINIT
  OGLM_CHECK_ERR(glGetFramebufferParameteriv, )
  OGLM_AVAIL_CHECK(__glewGetFramebufferParameteriv, glGetFramebufferParameteriv)
  glGetFramebufferParameteriv(target, pname, params);
  OGLM_CHECK_ERR(glGetFramebufferParameteriv, )

void
glGetFramebufferParameteriv_p(target, pname)
  GLenum target;
  GLenum pname;
PPCODE:
  OGLM_GLEWINIT
  OGLM_CHECK_ERR(glGetFramebufferParameteriv, )
  OGLM_AVAIL_CHECK(__glewGetFramebufferParameteriv, glGetFramebufferParameteriv)
  OGLM_SIZE_ENUM(FramebufferAttachmentParameterName,pname,1)
  GLint* params = OGLM_ALLOC(pname_count,GLint,params);
  glGetFramebufferParameteriv(target, pname, params);
  OGLM_CHECK_ERR(glGetFramebufferParameteriv, free(params);)
  OGLM_OUT_FINISH(params,pname_count,newSViv)
  free(params);

void
glGetFramebufferParameterivEXT_c(framebuffer, pname, params)
  GLuint framebuffer;
  GLenum pname;
  GLint* params;
CODE:
  OGLM_GLEWINIT
  OGLM_CHECK_ERR(glGetFramebufferParameterivEXT, )
  OGLM_AVAIL_CHECK(__glewGetFramebufferParameterivEXT, glGetFramebufferParameterivEXT)
  glGetFramebufferParameterivEXT(framebuffer, pname, params);
  OGLM_CHECK_ERR(glGetFramebufferParameterivEXT, )

void
glGetFramebufferParameterivEXT_p(framebuffer, pname)
  GLuint framebuffer;
  GLenum pname;
PPCODE:
  OGLM_GLEWINIT
  OGLM_CHECK_ERR(glGetFramebufferParameterivEXT, )
  OGLM_AVAIL_CHECK(__glewGetFramebufferParameterivEXT, glGetFramebufferParameterivEXT)
  OGLM_SIZE_ENUM(GetFramebufferParameter,pname,1)
  GLint* params = OGLM_ALLOC(pname_count,GLint,params);
  glGetFramebufferParameterivEXT(framebuffer, pname, params);
  OGLM_CHECK_ERR(glGetFramebufferParameterivEXT, free(params);)
  OGLM_OUT_FINISH(params,pname_count,newSViv)
  free(params);

void
glGetFramebufferParameterivMESA_c(target, pname, params)
  GLenum target;
  GLenum pname;
  GLint* params;
CODE:
  OGLM_GLEWINIT
  OGLM_CHECK_ERR(glGetFramebufferParameterivMESA, )
  OGLM_AVAIL_CHECK(__glewGetFramebufferParameterivMESA, glGetFramebufferParameterivMESA)
  glGetFramebufferParameterivMESA(target, pname, params);
  OGLM_CHECK_ERR(glGetFramebufferParameterivMESA, )

void
glGetFramebufferParameterivMESA_p(target, pname)
  GLenum target;
  GLenum pname;
PPCODE:
  OGLM_GLEWINIT
  OGLM_CHECK_ERR(glGetFramebufferParameterivMESA, )
  OGLM_AVAIL_CHECK(__glewGetFramebufferParameterivMESA, glGetFramebufferParameterivMESA)
  OGLM_SIZE_ENUM(FramebufferAttachmentParameterName,pname,1)
  GLint* params = OGLM_ALLOC(pname_count,GLint,params);
  glGetFramebufferParameterivMESA(target, pname, params);
  OGLM_CHECK_ERR(glGetFramebufferParameterivMESA, free(params);)
  OGLM_OUT_FINISH(params,pname_count,newSViv)
  free(params);

GLsizei
glGetFramebufferPixelLocalStorageSizeEXT(target)
  GLuint target;
CODE:
  OGLM_GLEWINIT
  OGLM_CHECK_ERR(glGetFramebufferPixelLocalStorageSizeEXT, )
  OGLM_AVAIL_CHECK(__glewGetFramebufferPixelLocalStorageSizeEXT, glGetFramebufferPixelLocalStorageSizeEXT)
  RETVAL = glGetFramebufferPixelLocalStorageSizeEXT(target);
  OGLM_CHECK_ERR(glGetFramebufferPixelLocalStorageSizeEXT, )
OUTPUT:
  RETVAL

GLenum
glGetGraphicsResetStatus()
ALIAS:
  glGetGraphicsResetStatusEXT = 1
  glGetGraphicsResetStatusKHR = 2
CODE:
  OGLM_GLEWINIT
  OGLM_CHECK_ERR(glGetGraphicsResetStatus, )
  OGLM_AVAIL_CHECK(__glewGetGraphicsResetStatus, glGetGraphicsResetStatus)
  RETVAL = glGetGraphicsResetStatus();
  OGLM_CHECK_ERR(glGetGraphicsResetStatus, )
OUTPUT:
  RETVAL

GLenum
glGetGraphicsResetStatusARB()
CODE:
  OGLM_GLEWINIT
  OGLM_CHECK_ERR(glGetGraphicsResetStatusARB, )
  OGLM_AVAIL_CHECK(__glewGetGraphicsResetStatusARB, glGetGraphicsResetStatusARB)
  RETVAL = glGetGraphicsResetStatusARB();
  OGLM_CHECK_ERR(glGetGraphicsResetStatusARB, )
OUTPUT:
  RETVAL

GLhandleARB
glGetHandleARB(pname)
  GLenum pname;
CODE:
  OGLM_GLEWINIT
  OGLM_CHECK_ERR(glGetHandleARB, )
  OGLM_AVAIL_CHECK(__glewGetHandleARB, glGetHandleARB)
  RETVAL = glGetHandleARB(pname);
  OGLM_CHECK_ERR(glGetHandleARB, )
OUTPUT:
  RETVAL

void
glGetHistogram_c(target, reset, format, type, values)
  GLenum target;
  GLboolean reset;
  GLenum format;
  GLenum type;
  void *values;
CODE:
  OGLM_GLEWINIT
  OGLM_CHECK_ERR(glGetHistogram, )
  OGLM_AVAIL_CHECK(__glewGetHistogram, glGetHistogram)
  glGetHistogram(target, reset, format, type, values);
  OGLM_CHECK_ERR(glGetHistogram, )

void
glGetHistogramEXT_c(target, reset, format, type, values)
  GLenum target;
  GLboolean reset;
  GLenum format;
  GLenum type;
  void *values;
CODE:
  OGLM_GLEWINIT
  OGLM_CHECK_ERR(glGetHistogramEXT, )
  OGLM_AVAIL_CHECK(__glewGetHistogramEXT, glGetHistogramEXT)
  glGetHistogramEXT(target, reset, format, type, values);
  OGLM_CHECK_ERR(glGetHistogramEXT, )

void
glGetHistogramParameterfv_c(target, pname, params)
  GLenum target;
  GLenum pname;
  GLfloat *params;
CODE:
  OGLM_GLEWINIT
  OGLM_CHECK_ERR(glGetHistogramParameterfv, )
  OGLM_AVAIL_CHECK(__glewGetHistogramParameterfv, glGetHistogramParameterfv)
  glGetHistogramParameterfv(target, pname, params);
  OGLM_CHECK_ERR(glGetHistogramParameterfv, )

void
glGetHistogramParameterfv_p(target, pname)
  GLenum target;
  GLenum pname;
PPCODE:
  OGLM_GLEWINIT
  OGLM_CHECK_ERR(glGetHistogramParameterfv, )
  OGLM_AVAIL_CHECK(__glewGetHistogramParameterfv, glGetHistogramParameterfv)
  OGLM_SIZE_ENUM(GetHistogramParameterPNameEXT,pname,1)
  GLfloat *params = OGLM_ALLOC(pname_count,GLfloat,params);
  glGetHistogramParameterfv(target, pname, params);
  OGLM_CHECK_ERR(glGetHistogramParameterfv, free(params);)
  OGLM_OUT_FINISH(params,pname_count,newSVnv)
  free(params);

void
glGetHistogramParameterfvEXT_c(target, pname, params)
  GLenum target;
  GLenum pname;
  GLfloat* params;
CODE:
  OGLM_GLEWINIT
  OGLM_CHECK_ERR(glGetHistogramParameterfvEXT, )
  OGLM_AVAIL_CHECK(__glewGetHistogramParameterfvEXT, glGetHistogramParameterfvEXT)
  glGetHistogramParameterfvEXT(target, pname, params);
  OGLM_CHECK_ERR(glGetHistogramParameterfvEXT, )

void
glGetHistogramParameterfvEXT_p(target, pname)
  GLenum target;
  GLenum pname;
PPCODE:
  OGLM_GLEWINIT
  OGLM_CHECK_ERR(glGetHistogramParameterfvEXT, )
  OGLM_AVAIL_CHECK(__glewGetHistogramParameterfvEXT, glGetHistogramParameterfvEXT)
  OGLM_SIZE_ENUM(GetHistogramParameterPNameEXT,pname,1)
  GLfloat* params = OGLM_ALLOC(pname_count,GLfloat,params);
  glGetHistogramParameterfvEXT(target, pname, params);
  OGLM_CHECK_ERR(glGetHistogramParameterfvEXT, free(params);)
  OGLM_OUT_FINISH(params,pname_count,newSVnv)
  free(params);

void
glGetHistogramParameteriv_c(target, pname, params)
  GLenum target;
  GLenum pname;
  GLint *params;
CODE:
  OGLM_GLEWINIT
  OGLM_CHECK_ERR(glGetHistogramParameteriv, )
  OGLM_AVAIL_CHECK(__glewGetHistogramParameteriv, glGetHistogramParameteriv)
  glGetHistogramParameteriv(target, pname, params);
  OGLM_CHECK_ERR(glGetHistogramParameteriv, )

void
glGetHistogramParameteriv_p(target, pname)
  GLenum target;
  GLenum pname;
PPCODE:
  OGLM_GLEWINIT
  OGLM_CHECK_ERR(glGetHistogramParameteriv, )
  OGLM_AVAIL_CHECK(__glewGetHistogramParameteriv, glGetHistogramParameteriv)
  OGLM_SIZE_ENUM(GetHistogramParameterPNameEXT,pname,1)
  GLint *params = OGLM_ALLOC(pname_count,GLint,params);
  glGetHistogramParameteriv(target, pname, params);
  OGLM_CHECK_ERR(glGetHistogramParameteriv, free(params);)
  OGLM_OUT_FINISH(params,pname_count,newSViv)
  free(params);

void
glGetHistogramParameterivEXT_c(target, pname, params)
  GLenum target;
  GLenum pname;
  GLint* params;
CODE:
  OGLM_GLEWINIT
  OGLM_CHECK_ERR(glGetHistogramParameterivEXT, )
  OGLM_AVAIL_CHECK(__glewGetHistogramParameterivEXT, glGetHistogramParameterivEXT)
  glGetHistogramParameterivEXT(target, pname, params);
  OGLM_CHECK_ERR(glGetHistogramParameterivEXT, )

void
glGetHistogramParameterivEXT_p(target, pname)
  GLenum target;
  GLenum pname;
PPCODE:
  OGLM_GLEWINIT
  OGLM_CHECK_ERR(glGetHistogramParameterivEXT, )
  OGLM_AVAIL_CHECK(__glewGetHistogramParameterivEXT, glGetHistogramParameterivEXT)
  OGLM_SIZE_ENUM(GetHistogramParameterPNameEXT,pname,1)
  GLint* params = OGLM_ALLOC(pname_count,GLint,params);
  glGetHistogramParameterivEXT(target, pname, params);
  OGLM_CHECK_ERR(glGetHistogramParameterivEXT, free(params);)
  OGLM_OUT_FINISH(params,pname_count,newSViv)
  free(params);

GLuint64
glGetImageHandleARB(texture, level, layered, layer, format)
  GLuint texture;
  GLint level;
  GLboolean layered;
  GLint layer;
  GLenum format;
CODE:
  OGLM_GLEWINIT
  OGLM_CHECK_ERR(glGetImageHandleARB, )
  OGLM_AVAIL_CHECK(__glewGetImageHandleARB, glGetImageHandleARB)
  RETVAL = glGetImageHandleARB(texture, level, layered, layer, format);
  OGLM_CHECK_ERR(glGetImageHandleARB, )
OUTPUT:
  RETVAL

GLuint64
glGetImageHandleNV(texture, level, layered, layer, format)
  GLuint texture;
  GLint level;
  GLboolean layered;
  GLint layer;
  GLenum format;
CODE:
  OGLM_GLEWINIT
  OGLM_CHECK_ERR(glGetImageHandleNV, )
  OGLM_AVAIL_CHECK(__glewGetImageHandleNV, glGetImageHandleNV)
  RETVAL = glGetImageHandleNV(texture, level, layered, layer, format);
  OGLM_CHECK_ERR(glGetImageHandleNV, )
OUTPUT:
  RETVAL

void
glGetImageTransformParameterfvHP_c(target, pname, params)
  GLenum target;
  GLenum pname;
  const GLfloat* params;
CODE:
  OGLM_GLEWINIT
  OGLM_CHECK_ERR(glGetImageTransformParameterfvHP, )
  OGLM_AVAIL_CHECK(__glewGetImageTransformParameterfvHP, glGetImageTransformParameterfvHP)
  glGetImageTransformParameterfvHP(target, pname, params);
  OGLM_CHECK_ERR(glGetImageTransformParameterfvHP, )

void
glGetImageTransformParameterivHP_c(target, pname, params)
  GLenum target;
  GLenum pname;
  const GLint* params;
CODE:
  OGLM_GLEWINIT
  OGLM_CHECK_ERR(glGetImageTransformParameterivHP, )
  OGLM_AVAIL_CHECK(__glewGetImageTransformParameterivHP, glGetImageTransformParameterivHP)
  glGetImageTransformParameterivHP(target, pname, params);
  OGLM_CHECK_ERR(glGetImageTransformParameterivHP, )

void
glGetInfoLogARB_c(obj, maxLength, length, infoLog)
  GLhandleARB obj;
  GLsizei maxLength;
  GLsizei* length;
  GLcharARB *infoLog;
CODE:
  OGLM_GLEWINIT
  OGLM_CHECK_ERR(glGetInfoLogARB, )
  OGLM_AVAIL_CHECK(__glewGetInfoLogARB, glGetInfoLogARB)
  glGetInfoLogARB(obj, maxLength, length, infoLog);
  OGLM_CHECK_ERR(glGetInfoLogARB, )

void
glGetInfoLogARB_p(obj, maxLength)
  GLhandleARB obj;
  GLsizei maxLength;
PPCODE:
  OGLM_GLEWINIT
  OGLM_CHECK_ERR(glGetInfoLogARB, )
  OGLM_AVAIL_CHECK(__glewGetInfoLogARB, glGetInfoLogARB)
  GLcharARB infoLog[maxLength];
  GLsizei length[1];
  glGetInfoLogARB(obj, maxLength, length, infoLog);
  OGLM_CHECK_ERR(glGetInfoLogARB, )
  EXTEND(sp, 2);
  mPUSHs(newSViv(length[0]));
  mPUSHs(newSVpv(infoLog,0));

void
glGetInteger64i_v_c(target, index, data)
  GLenum target;
  GLuint index;
  GLint64 * data;
CODE:
  OGLM_GLEWINIT
  OGLM_CHECK_ERR(glGetInteger64i_v, )
  OGLM_AVAIL_CHECK(__glewGetInteger64i_v, glGetInteger64i_v)
  glGetInteger64i_v(target, index, data);
  OGLM_CHECK_ERR(glGetInteger64i_v, )

void
glGetInteger64i_v_p(target, index)
  GLenum target;
  GLuint index;
PPCODE:
  OGLM_GLEWINIT
  OGLM_CHECK_ERR(glGetInteger64i_v, )
  OGLM_AVAIL_CHECK(__glewGetInteger64i_v, glGetInteger64i_v)
  OGLM_SIZE_ENUM(GetPName,target,1)
  GLint64 * data = OGLM_ALLOC(target_count,GLint64,data);
  glGetInteger64i_v(target, index, data);
  OGLM_CHECK_ERR(glGetInteger64i_v, free(data);)
  OGLM_OUT_FINISH(data,target_count,newSViv)
  free(data);

void
glGetInteger64v_c(pname, data)
  GLenum pname;
  GLint64* data;
ALIAS:
  glGetInteger64vAPPLE_c = 1
  glGetInteger64vEXT_c = 2
CODE:
  OGLM_GLEWINIT
  OGLM_CHECK_ERR(glGetInteger64v, )
  OGLM_AVAIL_CHECK(__glewGetInteger64v, glGetInteger64v)
  glGetInteger64v(pname, data);
  OGLM_CHECK_ERR(glGetInteger64v, )

void
glGetInteger64v_p(pname)
  GLenum pname;
ALIAS:
  glGetInteger64vAPPLE_p = 1
  glGetInteger64vEXT_p = 2
PPCODE:
  OGLM_GLEWINIT
  OGLM_CHECK_ERR(glGetInteger64v, )
  OGLM_AVAIL_CHECK(__glewGetInteger64v, glGetInteger64v)
  OGLM_SIZE_ENUM(GetPName,pname,1)
  GLint64* data = OGLM_ALLOC(pname_count,GLint64,data);
  glGetInteger64v(pname, data);
  OGLM_CHECK_ERR(glGetInteger64v, free(data);)
  OGLM_OUT_FINISH(data,pname_count,newSViv)
  free(data);

void
glGetIntegeri_v_c(target, index, data)
  GLenum target;
  GLuint index;
  GLint* data;
ALIAS:
  glGetIntegerIndexedvEXT_c = 1
CODE:
  OGLM_GLEWINIT
  OGLM_CHECK_ERR(glGetIntegeri_v, )
  OGLM_AVAIL_CHECK(__glewGetIntegeri_v, glGetIntegeri_v)
  glGetIntegeri_v(target, index, data);
  OGLM_CHECK_ERR(glGetIntegeri_v, )

void
glGetIntegeri_v_p(target, index)
  GLenum target;
  GLuint index;
ALIAS:
  glGetIntegerIndexedvEXT_p = 1
PPCODE:
  OGLM_GLEWINIT
  OGLM_CHECK_ERR(glGetIntegeri_v, )
  OGLM_AVAIL_CHECK(__glewGetIntegeri_v, glGetIntegeri_v)
  OGLM_SIZE_ENUM(GetPName,target,1)
  GLint* data = OGLM_ALLOC(target_count,GLint,data);
  glGetIntegeri_v(target, index, data);
  OGLM_CHECK_ERR(glGetIntegeri_v, free(data);)
  OGLM_OUT_FINISH(data,target_count,newSViv)
  free(data);

void
glGetIntegeri_vEXT_c(target, index, data)
  GLenum target;
  GLuint index;
  GLint* data;
CODE:
  OGLM_GLEWINIT
  OGLM_CHECK_ERR(glGetIntegeri_vEXT, )
  OGLM_AVAIL_CHECK(__glewGetIntegeri_vEXT, glGetIntegeri_vEXT)
  glGetIntegeri_vEXT(target, index, data);
  OGLM_CHECK_ERR(glGetIntegeri_vEXT, )

void
glGetIntegerui64i_vNV_c(value, index, result)
  GLenum value;
  GLuint index;
  GLuint64EXT * result;
CODE:
  OGLM_GLEWINIT
  OGLM_CHECK_ERR(glGetIntegerui64i_vNV, )
  OGLM_AVAIL_CHECK(__glewGetIntegerui64i_vNV, glGetIntegerui64i_vNV)
  glGetIntegerui64i_vNV(value, index, result);
  OGLM_CHECK_ERR(glGetIntegerui64i_vNV, )

void
glGetIntegerui64vNV_c(value, result)
  GLenum value;
  GLuint64EXT* result;
CODE:
  OGLM_GLEWINIT
  OGLM_CHECK_ERR(glGetIntegerui64vNV, )
  OGLM_AVAIL_CHECK(__glewGetIntegerui64vNV, glGetIntegerui64vNV)
  glGetIntegerui64vNV(value, result);
  OGLM_CHECK_ERR(glGetIntegerui64vNV, )

void
glGetIntegerv_c(pname, data)
  GLenum pname;
  GLint *data;
CODE:
  OGLM_GLEWINIT
  OGLM_CHECK_ERR(glGetIntegerv, )
  glGetIntegerv(pname, data);
  OGLM_CHECK_ERR(glGetIntegerv, )

void
glGetIntegerv_p(pname)
  GLenum pname;
PPCODE:
  OGLM_GLEWINIT
  OGLM_CHECK_ERR(glGetIntegerv, )
  OGLM_SIZE_ENUM(GetPName,pname,1)
  GLint *data = OGLM_ALLOC(pname_count,GLint,data);
  glGetIntegerv(pname, data);
  OGLM_CHECK_ERR(glGetIntegerv, free(data);)
  OGLM_OUT_FINISH(data,pname_count,newSViv)
  free(data);

void
glGetInternalformatSampleivNV_c(target, internalformat, samples, pname, count, params)
  GLenum target;
  GLenum internalformat;
  GLsizei samples;
  GLenum pname;
  GLsizei count;
  GLint* params;
CODE:
  OGLM_GLEWINIT
  OGLM_CHECK_ERR(glGetInternalformatSampleivNV, )
  OGLM_AVAIL_CHECK(__glewGetInternalformatSampleivNV, glGetInternalformatSampleivNV)
  glGetInternalformatSampleivNV(target, internalformat, samples, pname, count, params);
  OGLM_CHECK_ERR(glGetInternalformatSampleivNV, )

void
glGetInternalformatSampleivNV_p(target, internalformat, samples, pname, count)
  GLenum target;
  GLenum internalformat;
  GLsizei samples;
  GLenum pname;
  GLsizei count;
PPCODE:
  OGLM_GLEWINIT
  OGLM_CHECK_ERR(glGetInternalformatSampleivNV, )
  OGLM_AVAIL_CHECK(__glewGetInternalformatSampleivNV, glGetInternalformatSampleivNV)
  GLint* params = OGLM_ALLOC(count,GLint,params);
  glGetInternalformatSampleivNV(target, internalformat, samples, pname, count, params);
  OGLM_CHECK_ERR(glGetInternalformatSampleivNV, free(params);)
  OGLM_OUT_FINISH(params,count,newSViv)
  free(params);

void
glGetInternalformati64v_c(target, internalformat, pname, count, params)
  GLenum target;
  GLenum internalformat;
  GLenum pname;
  GLsizei count;
  GLint64* params;
CODE:
  OGLM_GLEWINIT
  OGLM_CHECK_ERR(glGetInternalformati64v, )
  OGLM_AVAIL_CHECK(__glewGetInternalformati64v, glGetInternalformati64v)
  glGetInternalformati64v(target, internalformat, pname, count, params);
  OGLM_CHECK_ERR(glGetInternalformati64v, )

void
glGetInternalformati64v_p(target, internalformat, pname, count)
  GLenum target;
  GLenum internalformat;
  GLenum pname;
  GLsizei count;
PPCODE:
  OGLM_GLEWINIT
  OGLM_CHECK_ERR(glGetInternalformati64v, )
  OGLM_AVAIL_CHECK(__glewGetInternalformati64v, glGetInternalformati64v)
  GLint64* params = OGLM_ALLOC(count,GLint64,params);
  glGetInternalformati64v(target, internalformat, pname, count, params);
  OGLM_CHECK_ERR(glGetInternalformati64v, free(params);)
  OGLM_OUT_FINISH(params,count,newSViv)
  free(params);

void
glGetInternalformativ_c(target, internalformat, pname, count, params)
  GLenum target;
  GLenum internalformat;
  GLenum pname;
  GLsizei count;
  GLint* params;
CODE:
  OGLM_GLEWINIT
  OGLM_CHECK_ERR(glGetInternalformativ, )
  OGLM_AVAIL_CHECK(__glewGetInternalformativ, glGetInternalformativ)
  glGetInternalformativ(target, internalformat, pname, count, params);
  OGLM_CHECK_ERR(glGetInternalformativ, )

void
glGetInternalformativ_p(target, internalformat, pname, count)
  GLenum target;
  GLenum internalformat;
  GLenum pname;
  GLsizei count;
PPCODE:
  OGLM_GLEWINIT
  OGLM_CHECK_ERR(glGetInternalformativ, )
  OGLM_AVAIL_CHECK(__glewGetInternalformativ, glGetInternalformativ)
  GLint* params = OGLM_ALLOC(count,GLint,params);
  glGetInternalformativ(target, internalformat, pname, count, params);
  OGLM_CHECK_ERR(glGetInternalformativ, free(params);)
  OGLM_OUT_FINISH(params,count,newSViv)
  free(params);

void
glGetInvariantBooleanvEXT_c(id, value, data)
  GLuint id;
  GLenum value;
  GLboolean *data;
CODE:
  OGLM_GLEWINIT
  OGLM_CHECK_ERR(glGetInvariantBooleanvEXT, )
  OGLM_AVAIL_CHECK(__glewGetInvariantBooleanvEXT, glGetInvariantBooleanvEXT)
  glGetInvariantBooleanvEXT(id, value, data);
  OGLM_CHECK_ERR(glGetInvariantBooleanvEXT, )

void
glGetInvariantFloatvEXT_c(id, value, data)
  GLuint id;
  GLenum value;
  GLfloat *data;
CODE:
  OGLM_GLEWINIT
  OGLM_CHECK_ERR(glGetInvariantFloatvEXT, )
  OGLM_AVAIL_CHECK(__glewGetInvariantFloatvEXT, glGetInvariantFloatvEXT)
  glGetInvariantFloatvEXT(id, value, data);
  OGLM_CHECK_ERR(glGetInvariantFloatvEXT, )

void
glGetInvariantIntegervEXT_c(id, value, data)
  GLuint id;
  GLenum value;
  GLint *data;
CODE:
  OGLM_GLEWINIT
  OGLM_CHECK_ERR(glGetInvariantIntegervEXT, )
  OGLM_AVAIL_CHECK(__glewGetInvariantIntegervEXT, glGetInvariantIntegervEXT)
  glGetInvariantIntegervEXT(id, value, data);
  OGLM_CHECK_ERR(glGetInvariantIntegervEXT, )

void
glGetLightfv_c(light, pname, params)
  GLenum light;
  GLenum pname;
  GLfloat *params;
CODE:
  OGLM_GLEWINIT
  OGLM_CHECK_ERR(glGetLightfv, )
  glGetLightfv(light, pname, params);
  OGLM_CHECK_ERR(glGetLightfv, )

void
glGetLightfv_p(light, pname)
  GLenum light;
  GLenum pname;
PPCODE:
  OGLM_GLEWINIT
  OGLM_CHECK_ERR(glGetLightfv, )
  OGLM_SIZE_ENUM(LightParameter,pname,1)
  GLfloat *params = OGLM_ALLOC(pname_count,GLfloat,params);
  glGetLightfv(light, pname, params);
  OGLM_CHECK_ERR(glGetLightfv, free(params);)
  OGLM_OUT_FINISH(params,pname_count,newSVnv)
  free(params);

void
glGetLightiv_c(light, pname, params)
  GLenum light;
  GLenum pname;
  GLint *params;
CODE:
  OGLM_GLEWINIT
  OGLM_CHECK_ERR(glGetLightiv, )
  glGetLightiv(light, pname, params);
  OGLM_CHECK_ERR(glGetLightiv, )

void
glGetLightiv_p(light, pname)
  GLenum light;
  GLenum pname;
PPCODE:
  OGLM_GLEWINIT
  OGLM_CHECK_ERR(glGetLightiv, )
  OGLM_SIZE_ENUM(LightParameter,pname,1)
  GLint *params = OGLM_ALLOC(pname_count,GLint,params);
  glGetLightiv(light, pname, params);
  OGLM_CHECK_ERR(glGetLightiv, free(params);)
  OGLM_OUT_FINISH(params,pname_count,newSViv)
  free(params);

void
glGetLightxv_c(light, pname, params)
  GLenum light;
  GLenum pname;
  GLfixed* params;
CODE:
  OGLM_GLEWINIT
  OGLM_CHECK_ERR(glGetLightxv, )
  OGLM_AVAIL_CHECK(__glewGetLightxv, glGetLightxv)
  glGetLightxv(light, pname, params);
  OGLM_CHECK_ERR(glGetLightxv, )

void
glGetLightxv_p(light, pname)
  GLenum light;
  GLenum pname;
PPCODE:
  OGLM_GLEWINIT
  OGLM_CHECK_ERR(glGetLightxv, )
  OGLM_AVAIL_CHECK(__glewGetLightxv, glGetLightxv)
  OGLM_SIZE_ENUM(LightParameter,pname,1)
  GLfixed* params = OGLM_ALLOC(pname_count,GLfixed,params);
  glGetLightxv(light, pname, params);
  OGLM_CHECK_ERR(glGetLightxv, free(params);)
  OGLM_OUT_FINISH(params,pname_count,newSViv)
  free(params);

void
glGetLocalConstantBooleanvEXT_c(id, value, data)
  GLuint id;
  GLenum value;
  GLboolean *data;
CODE:
  OGLM_GLEWINIT
  OGLM_CHECK_ERR(glGetLocalConstantBooleanvEXT, )
  OGLM_AVAIL_CHECK(__glewGetLocalConstantBooleanvEXT, glGetLocalConstantBooleanvEXT)
  glGetLocalConstantBooleanvEXT(id, value, data);
  OGLM_CHECK_ERR(glGetLocalConstantBooleanvEXT, )

void
glGetLocalConstantFloatvEXT_c(id, value, data)
  GLuint id;
  GLenum value;
  GLfloat *data;
CODE:
  OGLM_GLEWINIT
  OGLM_CHECK_ERR(glGetLocalConstantFloatvEXT, )
  OGLM_AVAIL_CHECK(__glewGetLocalConstantFloatvEXT, glGetLocalConstantFloatvEXT)
  glGetLocalConstantFloatvEXT(id, value, data);
  OGLM_CHECK_ERR(glGetLocalConstantFloatvEXT, )

void
glGetLocalConstantIntegervEXT_c(id, value, data)
  GLuint id;
  GLenum value;
  GLint *data;
CODE:
  OGLM_GLEWINIT
  OGLM_CHECK_ERR(glGetLocalConstantIntegervEXT, )
  OGLM_AVAIL_CHECK(__glewGetLocalConstantIntegervEXT, glGetLocalConstantIntegervEXT)
  glGetLocalConstantIntegervEXT(id, value, data);
  OGLM_CHECK_ERR(glGetLocalConstantIntegervEXT, )

void
glGetMPEGParameterfvSGIX_c(target, pname, params)
  GLenum target;
  GLenum pname;
  GLfloat* params;
CODE:
  OGLM_GLEWINIT
  OGLM_CHECK_ERR(glGetMPEGParameterfvSGIX, )
  OGLM_AVAIL_CHECK(__glewGetMPEGParameterfvSGIX, glGetMPEGParameterfvSGIX)
  glGetMPEGParameterfvSGIX(target, pname, params);
  OGLM_CHECK_ERR(glGetMPEGParameterfvSGIX, )

void
glGetMPEGParameterivSGIX_c(target, pname, params)
  GLenum target;
  GLenum pname;
  GLint* params;
CODE:
  OGLM_GLEWINIT
  OGLM_CHECK_ERR(glGetMPEGParameterivSGIX, )
  OGLM_AVAIL_CHECK(__glewGetMPEGParameterivSGIX, glGetMPEGParameterivSGIX)
  glGetMPEGParameterivSGIX(target, pname, params);
  OGLM_CHECK_ERR(glGetMPEGParameterivSGIX, )

void
glGetMPEGPredictorSGIX_c(target, format, type, pixels)
  GLenum target;
  GLenum format;
  GLenum type;
  void *pixels;
CODE:
  OGLM_GLEWINIT
  OGLM_CHECK_ERR(glGetMPEGPredictorSGIX, )
  OGLM_AVAIL_CHECK(__glewGetMPEGPredictorSGIX, glGetMPEGPredictorSGIX)
  glGetMPEGPredictorSGIX(target, format, type, pixels);
  OGLM_CHECK_ERR(glGetMPEGPredictorSGIX, )

void
glGetMPEGQuantTableubv_c(target, values)
  GLenum target;
  GLubyte* values;
CODE:
  OGLM_GLEWINIT
  OGLM_CHECK_ERR(glGetMPEGQuantTableubv, )
  OGLM_AVAIL_CHECK(__glewGetMPEGQuantTableubv, glGetMPEGQuantTableubv)
  glGetMPEGQuantTableubv(target, values);
  OGLM_CHECK_ERR(glGetMPEGQuantTableubv, )

void
glGetMapAttribParameterfvNV_c(target, index, pname, params)
  GLenum target;
  GLuint index;
  GLenum pname;
  GLfloat* params;
CODE:
  OGLM_GLEWINIT
  OGLM_CHECK_ERR(glGetMapAttribParameterfvNV, )
  OGLM_AVAIL_CHECK(__glewGetMapAttribParameterfvNV, glGetMapAttribParameterfvNV)
  glGetMapAttribParameterfvNV(target, index, pname, params);
  OGLM_CHECK_ERR(glGetMapAttribParameterfvNV, )

void
glGetMapAttribParameterivNV_c(target, index, pname, params)
  GLenum target;
  GLuint index;
  GLenum pname;
  GLint* params;
CODE:
  OGLM_GLEWINIT
  OGLM_CHECK_ERR(glGetMapAttribParameterivNV, )
  OGLM_AVAIL_CHECK(__glewGetMapAttribParameterivNV, glGetMapAttribParameterivNV)
  glGetMapAttribParameterivNV(target, index, pname, params);
  OGLM_CHECK_ERR(glGetMapAttribParameterivNV, )

void
glGetMapControlPointsNV_c(target, index, type, ustride, vstride, packed, points)
  GLenum target;
  GLuint index;
  GLenum type;
  GLsizei ustride;
  GLsizei vstride;
  GLboolean packed;
  void *points;
CODE:
  OGLM_GLEWINIT
  OGLM_CHECK_ERR(glGetMapControlPointsNV, )
  OGLM_AVAIL_CHECK(__glewGetMapControlPointsNV, glGetMapControlPointsNV)
  glGetMapControlPointsNV(target, index, type, ustride, vstride, packed, points);
  OGLM_CHECK_ERR(glGetMapControlPointsNV, )

void
glGetMapParameterfvNV_c(target, pname, params)
  GLenum target;
  GLenum pname;
  GLfloat* params;
CODE:
  OGLM_GLEWINIT
  OGLM_CHECK_ERR(glGetMapParameterfvNV, )
  OGLM_AVAIL_CHECK(__glewGetMapParameterfvNV, glGetMapParameterfvNV)
  glGetMapParameterfvNV(target, pname, params);
  OGLM_CHECK_ERR(glGetMapParameterfvNV, )

void
glGetMapParameterivNV_c(target, pname, params)
  GLenum target;
  GLenum pname;
  GLint* params;
CODE:
  OGLM_GLEWINIT
  OGLM_CHECK_ERR(glGetMapParameterivNV, )
  OGLM_AVAIL_CHECK(__glewGetMapParameterivNV, glGetMapParameterivNV)
  glGetMapParameterivNV(target, pname, params);
  OGLM_CHECK_ERR(glGetMapParameterivNV, )

void
glGetMapdv_c(target, query, v)
  GLenum target;
  GLenum query;
  GLdouble *v;
CODE:
  OGLM_GLEWINIT
  OGLM_CHECK_ERR(glGetMapdv, )
  glGetMapdv(target, query, v);
  OGLM_CHECK_ERR(glGetMapdv, )

void
glGetMapfv_c(target, query, v)
  GLenum target;
  GLenum query;
  GLfloat *v;
CODE:
  OGLM_GLEWINIT
  OGLM_CHECK_ERR(glGetMapfv, )
  glGetMapfv(target, query, v);
  OGLM_CHECK_ERR(glGetMapfv, )

void
glGetMapiv_c(target, query, v)
  GLenum target;
  GLenum query;
  GLint *v;
CODE:
  OGLM_GLEWINIT
  OGLM_CHECK_ERR(glGetMapiv, )
  glGetMapiv(target, query, v);
  OGLM_CHECK_ERR(glGetMapiv, )

void
glGetMaterialfv_c(face, pname, params)
  GLenum face;
  GLenum pname;
  GLfloat *params;
CODE:
  OGLM_GLEWINIT
  OGLM_CHECK_ERR(glGetMaterialfv, )
  glGetMaterialfv(face, pname, params);
  OGLM_CHECK_ERR(glGetMaterialfv, )

void
glGetMaterialfv_p(face, pname)
  GLenum face;
  GLenum pname;
PPCODE:
  OGLM_GLEWINIT
  OGLM_CHECK_ERR(glGetMaterialfv, )
  OGLM_SIZE_ENUM(MaterialParameter,pname,1)
  GLfloat *params = OGLM_ALLOC(pname_count,GLfloat,params);
  glGetMaterialfv(face, pname, params);
  OGLM_CHECK_ERR(glGetMaterialfv, free(params);)
  OGLM_OUT_FINISH(params,pname_count,newSVnv)
  free(params);

void
glGetMaterialiv_c(face, pname, params)
  GLenum face;
  GLenum pname;
  GLint *params;
CODE:
  OGLM_GLEWINIT
  OGLM_CHECK_ERR(glGetMaterialiv, )
  glGetMaterialiv(face, pname, params);
  OGLM_CHECK_ERR(glGetMaterialiv, )

void
glGetMaterialiv_p(face, pname)
  GLenum face;
  GLenum pname;
PPCODE:
  OGLM_GLEWINIT
  OGLM_CHECK_ERR(glGetMaterialiv, )
  OGLM_SIZE_ENUM(MaterialParameter,pname,1)
  GLint *params = OGLM_ALLOC(pname_count,GLint,params);
  glGetMaterialiv(face, pname, params);
  OGLM_CHECK_ERR(glGetMaterialiv, free(params);)
  OGLM_OUT_FINISH(params,pname_count,newSViv)
  free(params);

void
glGetMaterialxv_c(face, pname, params)
  GLenum face;
  GLenum pname;
  GLfixed* params;
CODE:
  OGLM_GLEWINIT
  OGLM_CHECK_ERR(glGetMaterialxv, )
  OGLM_AVAIL_CHECK(__glewGetMaterialxv, glGetMaterialxv)
  glGetMaterialxv(face, pname, params);
  OGLM_CHECK_ERR(glGetMaterialxv, )

void
glGetMaterialxv_p(face, pname)
  GLenum face;
  GLenum pname;
PPCODE:
  OGLM_GLEWINIT
  OGLM_CHECK_ERR(glGetMaterialxv, )
  OGLM_AVAIL_CHECK(__glewGetMaterialxv, glGetMaterialxv)
  OGLM_SIZE_ENUM(MaterialParameter,pname,1)
  GLfixed* params = OGLM_ALLOC(pname_count,GLfixed,params);
  glGetMaterialxv(face, pname, params);
  OGLM_CHECK_ERR(glGetMaterialxv, free(params);)
  OGLM_OUT_FINISH(params,pname_count,newSViv)
  free(params);

void
glGetMemoryObjectDetachedResourcesuivNV_c(memory, pname, first, count, params)
  GLuint memory;
  GLenum pname;
  GLint first;
  GLsizei count;
  GLuint* params;
CODE:
  OGLM_GLEWINIT
  OGLM_CHECK_ERR(glGetMemoryObjectDetachedResourcesuivNV, )
  OGLM_AVAIL_CHECK(__glewGetMemoryObjectDetachedResourcesuivNV, glGetMemoryObjectDetachedResourcesuivNV)
  glGetMemoryObjectDetachedResourcesuivNV(memory, pname, first, count, params);
  OGLM_CHECK_ERR(glGetMemoryObjectDetachedResourcesuivNV, )

void
glGetMemoryObjectParameterivEXT_c(memoryObject, pname, params)
  GLuint memoryObject;
  GLenum pname;
  GLint* params;
CODE:
  OGLM_GLEWINIT
  OGLM_CHECK_ERR(glGetMemoryObjectParameterivEXT, )
  OGLM_AVAIL_CHECK(__glewGetMemoryObjectParameterivEXT, glGetMemoryObjectParameterivEXT)
  glGetMemoryObjectParameterivEXT(memoryObject, pname, params);
  OGLM_CHECK_ERR(glGetMemoryObjectParameterivEXT, )

void
glGetMinmax_c(target, reset, format, type, values)
  GLenum target;
  GLboolean reset;
  GLenum format;
  GLenum type;
  void *values;
CODE:
  OGLM_GLEWINIT
  OGLM_CHECK_ERR(glGetMinmax, )
  OGLM_AVAIL_CHECK(__glewGetMinmax, glGetMinmax)
  glGetMinmax(target, reset, format, type, values);
  OGLM_CHECK_ERR(glGetMinmax, )

void
glGetMinmaxEXT_c(target, reset, format, type, values)
  GLenum target;
  GLboolean reset;
  GLenum format;
  GLenum type;
  void *values;
CODE:
  OGLM_GLEWINIT
  OGLM_CHECK_ERR(glGetMinmaxEXT, )
  OGLM_AVAIL_CHECK(__glewGetMinmaxEXT, glGetMinmaxEXT)
  glGetMinmaxEXT(target, reset, format, type, values);
  OGLM_CHECK_ERR(glGetMinmaxEXT, )

void
glGetMinmaxParameterfv_c(target, pname, params)
  GLenum target;
  GLenum pname;
  GLfloat *params;
CODE:
  OGLM_GLEWINIT
  OGLM_CHECK_ERR(glGetMinmaxParameterfv, )
  OGLM_AVAIL_CHECK(__glewGetMinmaxParameterfv, glGetMinmaxParameterfv)
  glGetMinmaxParameterfv(target, pname, params);
  OGLM_CHECK_ERR(glGetMinmaxParameterfv, )

void
glGetMinmaxParameterfv_p(target, pname)
  GLenum target;
  GLenum pname;
PPCODE:
  OGLM_GLEWINIT
  OGLM_CHECK_ERR(glGetMinmaxParameterfv, )
  OGLM_AVAIL_CHECK(__glewGetMinmaxParameterfv, glGetMinmaxParameterfv)
  OGLM_SIZE_ENUM(GetMinmaxParameterPNameEXT,pname,1)
  GLfloat *params = OGLM_ALLOC(pname_count,GLfloat,params);
  glGetMinmaxParameterfv(target, pname, params);
  OGLM_CHECK_ERR(glGetMinmaxParameterfv, free(params);)
  OGLM_OUT_FINISH(params,pname_count,newSVnv)
  free(params);

void
glGetMinmaxParameterfvEXT_c(target, pname, params)
  GLenum target;
  GLenum pname;
  GLfloat* params;
CODE:
  OGLM_GLEWINIT
  OGLM_CHECK_ERR(glGetMinmaxParameterfvEXT, )
  OGLM_AVAIL_CHECK(__glewGetMinmaxParameterfvEXT, glGetMinmaxParameterfvEXT)
  glGetMinmaxParameterfvEXT(target, pname, params);
  OGLM_CHECK_ERR(glGetMinmaxParameterfvEXT, )

void
glGetMinmaxParameterfvEXT_p(target, pname)
  GLenum target;
  GLenum pname;
PPCODE:
  OGLM_GLEWINIT
  OGLM_CHECK_ERR(glGetMinmaxParameterfvEXT, )
  OGLM_AVAIL_CHECK(__glewGetMinmaxParameterfvEXT, glGetMinmaxParameterfvEXT)
  OGLM_SIZE_ENUM(GetMinmaxParameterPNameEXT,pname,1)
  GLfloat* params = OGLM_ALLOC(pname_count,GLfloat,params);
  glGetMinmaxParameterfvEXT(target, pname, params);
  OGLM_CHECK_ERR(glGetMinmaxParameterfvEXT, free(params);)
  OGLM_OUT_FINISH(params,pname_count,newSVnv)
  free(params);

void
glGetMinmaxParameteriv_c(target, pname, params)
  GLenum target;
  GLenum pname;
  GLint *params;
CODE:
  OGLM_GLEWINIT
  OGLM_CHECK_ERR(glGetMinmaxParameteriv, )
  OGLM_AVAIL_CHECK(__glewGetMinmaxParameteriv, glGetMinmaxParameteriv)
  glGetMinmaxParameteriv(target, pname, params);
  OGLM_CHECK_ERR(glGetMinmaxParameteriv, )

void
glGetMinmaxParameteriv_p(target, pname)
  GLenum target;
  GLenum pname;
PPCODE:
  OGLM_GLEWINIT
  OGLM_CHECK_ERR(glGetMinmaxParameteriv, )
  OGLM_AVAIL_CHECK(__glewGetMinmaxParameteriv, glGetMinmaxParameteriv)
  OGLM_SIZE_ENUM(GetMinmaxParameterPNameEXT,pname,1)
  GLint *params = OGLM_ALLOC(pname_count,GLint,params);
  glGetMinmaxParameteriv(target, pname, params);
  OGLM_CHECK_ERR(glGetMinmaxParameteriv, free(params);)
  OGLM_OUT_FINISH(params,pname_count,newSViv)
  free(params);

void
glGetMinmaxParameterivEXT_c(target, pname, params)
  GLenum target;
  GLenum pname;
  GLint* params;
CODE:
  OGLM_GLEWINIT
  OGLM_CHECK_ERR(glGetMinmaxParameterivEXT, )
  OGLM_AVAIL_CHECK(__glewGetMinmaxParameterivEXT, glGetMinmaxParameterivEXT)
  glGetMinmaxParameterivEXT(target, pname, params);
  OGLM_CHECK_ERR(glGetMinmaxParameterivEXT, )

void
glGetMinmaxParameterivEXT_p(target, pname)
  GLenum target;
  GLenum pname;
PPCODE:
  OGLM_GLEWINIT
  OGLM_CHECK_ERR(glGetMinmaxParameterivEXT, )
  OGLM_AVAIL_CHECK(__glewGetMinmaxParameterivEXT, glGetMinmaxParameterivEXT)
  OGLM_SIZE_ENUM(GetMinmaxParameterPNameEXT,pname,1)
  GLint* params = OGLM_ALLOC(pname_count,GLint,params);
  glGetMinmaxParameterivEXT(target, pname, params);
  OGLM_CHECK_ERR(glGetMinmaxParameterivEXT, free(params);)
  OGLM_OUT_FINISH(params,pname_count,newSViv)
  free(params);

void
glGetMultiTexEnvfvEXT_c(texunit, target, pname, params)
  GLenum texunit;
  GLenum target;
  GLenum pname;
  GLfloat* params;
CODE:
  OGLM_GLEWINIT
  OGLM_CHECK_ERR(glGetMultiTexEnvfvEXT, )
  OGLM_AVAIL_CHECK(__glewGetMultiTexEnvfvEXT, glGetMultiTexEnvfvEXT)
  glGetMultiTexEnvfvEXT(texunit, target, pname, params);
  OGLM_CHECK_ERR(glGetMultiTexEnvfvEXT, )

void
glGetMultiTexEnvfvEXT_p(texunit, target, pname)
  GLenum texunit;
  GLenum target;
  GLenum pname;
PPCODE:
  OGLM_GLEWINIT
  OGLM_CHECK_ERR(glGetMultiTexEnvfvEXT, )
  OGLM_AVAIL_CHECK(__glewGetMultiTexEnvfvEXT, glGetMultiTexEnvfvEXT)
  OGLM_SIZE_ENUM(TextureEnvParameter,pname,1)
  GLfloat* params = OGLM_ALLOC(pname_count,GLfloat,params);
  glGetMultiTexEnvfvEXT(texunit, target, pname, params);
  OGLM_CHECK_ERR(glGetMultiTexEnvfvEXT, free(params);)
  OGLM_OUT_FINISH(params,pname_count,newSVnv)
  free(params);

void
glGetMultiTexEnvivEXT_c(texunit, target, pname, params)
  GLenum texunit;
  GLenum target;
  GLenum pname;
  GLint* params;
CODE:
  OGLM_GLEWINIT
  OGLM_CHECK_ERR(glGetMultiTexEnvivEXT, )
  OGLM_AVAIL_CHECK(__glewGetMultiTexEnvivEXT, glGetMultiTexEnvivEXT)
  glGetMultiTexEnvivEXT(texunit, target, pname, params);
  OGLM_CHECK_ERR(glGetMultiTexEnvivEXT, )

void
glGetMultiTexEnvivEXT_p(texunit, target, pname)
  GLenum texunit;
  GLenum target;
  GLenum pname;
PPCODE:
  OGLM_GLEWINIT
  OGLM_CHECK_ERR(glGetMultiTexEnvivEXT, )
  OGLM_AVAIL_CHECK(__glewGetMultiTexEnvivEXT, glGetMultiTexEnvivEXT)
  OGLM_SIZE_ENUM(TextureEnvParameter,pname,1)
  GLint* params = OGLM_ALLOC(pname_count,GLint,params);
  glGetMultiTexEnvivEXT(texunit, target, pname, params);
  OGLM_CHECK_ERR(glGetMultiTexEnvivEXT, free(params);)
  OGLM_OUT_FINISH(params,pname_count,newSViv)
  free(params);

void
glGetMultiTexGendvEXT_c(texunit, coord, pname, params)
  GLenum texunit;
  GLenum coord;
  GLenum pname;
  GLdouble* params;
CODE:
  OGLM_GLEWINIT
  OGLM_CHECK_ERR(glGetMultiTexGendvEXT, )
  OGLM_AVAIL_CHECK(__glewGetMultiTexGendvEXT, glGetMultiTexGendvEXT)
  glGetMultiTexGendvEXT(texunit, coord, pname, params);
  OGLM_CHECK_ERR(glGetMultiTexGendvEXT, )

void
glGetMultiTexGendvEXT_p(texunit, coord, pname)
  GLenum texunit;
  GLenum coord;
  GLenum pname;
PPCODE:
  OGLM_GLEWINIT
  OGLM_CHECK_ERR(glGetMultiTexGendvEXT, )
  OGLM_AVAIL_CHECK(__glewGetMultiTexGendvEXT, glGetMultiTexGendvEXT)
  OGLM_SIZE_ENUM(TextureGenParameter,pname,1)
  GLdouble* params = OGLM_ALLOC(pname_count,GLdouble,params);
  glGetMultiTexGendvEXT(texunit, coord, pname, params);
  OGLM_CHECK_ERR(glGetMultiTexGendvEXT, free(params);)
  OGLM_OUT_FINISH(params,pname_count,newSVnv)
  free(params);

void
glGetMultiTexGenfvEXT_c(texunit, coord, pname, params)
  GLenum texunit;
  GLenum coord;
  GLenum pname;
  GLfloat* params;
CODE:
  OGLM_GLEWINIT
  OGLM_CHECK_ERR(glGetMultiTexGenfvEXT, )
  OGLM_AVAIL_CHECK(__glewGetMultiTexGenfvEXT, glGetMultiTexGenfvEXT)
  glGetMultiTexGenfvEXT(texunit, coord, pname, params);
  OGLM_CHECK_ERR(glGetMultiTexGenfvEXT, )

void
glGetMultiTexGenfvEXT_p(texunit, coord, pname)
  GLenum texunit;
  GLenum coord;
  GLenum pname;
PPCODE:
  OGLM_GLEWINIT
  OGLM_CHECK_ERR(glGetMultiTexGenfvEXT, )
  OGLM_AVAIL_CHECK(__glewGetMultiTexGenfvEXT, glGetMultiTexGenfvEXT)
  OGLM_SIZE_ENUM(TextureGenParameter,pname,1)
  GLfloat* params = OGLM_ALLOC(pname_count,GLfloat,params);
  glGetMultiTexGenfvEXT(texunit, coord, pname, params);
  OGLM_CHECK_ERR(glGetMultiTexGenfvEXT, free(params);)
  OGLM_OUT_FINISH(params,pname_count,newSVnv)
  free(params);

void
glGetMultiTexGenivEXT_c(texunit, coord, pname, params)
  GLenum texunit;
  GLenum coord;
  GLenum pname;
  GLint* params;
CODE:
  OGLM_GLEWINIT
  OGLM_CHECK_ERR(glGetMultiTexGenivEXT, )
  OGLM_AVAIL_CHECK(__glewGetMultiTexGenivEXT, glGetMultiTexGenivEXT)
  glGetMultiTexGenivEXT(texunit, coord, pname, params);
  OGLM_CHECK_ERR(glGetMultiTexGenivEXT, )

void
glGetMultiTexGenivEXT_p(texunit, coord, pname)
  GLenum texunit;
  GLenum coord;
  GLenum pname;
PPCODE:
  OGLM_GLEWINIT
  OGLM_CHECK_ERR(glGetMultiTexGenivEXT, )
  OGLM_AVAIL_CHECK(__glewGetMultiTexGenivEXT, glGetMultiTexGenivEXT)
  OGLM_SIZE_ENUM(TextureGenParameter,pname,1)
  GLint* params = OGLM_ALLOC(pname_count,GLint,params);
  glGetMultiTexGenivEXT(texunit, coord, pname, params);
  OGLM_CHECK_ERR(glGetMultiTexGenivEXT, free(params);)
  OGLM_OUT_FINISH(params,pname_count,newSViv)
  free(params);

void
glGetMultiTexImageEXT_c(texunit, target, level, format, type, pixels)
  GLenum texunit;
  GLenum target;
  GLint level;
  GLenum format;
  GLenum type;
  void *pixels;
CODE:
  OGLM_GLEWINIT
  OGLM_CHECK_ERR(glGetMultiTexImageEXT, )
  OGLM_AVAIL_CHECK(__glewGetMultiTexImageEXT, glGetMultiTexImageEXT)
  glGetMultiTexImageEXT(texunit, target, level, format, type, pixels);
  OGLM_CHECK_ERR(glGetMultiTexImageEXT, )

void
glGetMultiTexLevelParameterfvEXT_c(texunit, target, level, pname, params)
  GLenum texunit;
  GLenum target;
  GLint level;
  GLenum pname;
  GLfloat* params;
CODE:
  OGLM_GLEWINIT
  OGLM_CHECK_ERR(glGetMultiTexLevelParameterfvEXT, )
  OGLM_AVAIL_CHECK(__glewGetMultiTexLevelParameterfvEXT, glGetMultiTexLevelParameterfvEXT)
  glGetMultiTexLevelParameterfvEXT(texunit, target, level, pname, params);
  OGLM_CHECK_ERR(glGetMultiTexLevelParameterfvEXT, )

void
glGetMultiTexLevelParameterfvEXT_p(texunit, target, level, pname)
  GLenum texunit;
  GLenum target;
  GLint level;
  GLenum pname;
PPCODE:
  OGLM_GLEWINIT
  OGLM_CHECK_ERR(glGetMultiTexLevelParameterfvEXT, )
  OGLM_AVAIL_CHECK(__glewGetMultiTexLevelParameterfvEXT, glGetMultiTexLevelParameterfvEXT)
  OGLM_SIZE_ENUM(GetTextureParameter,pname,1)
  GLfloat* params = OGLM_ALLOC(pname_count,GLfloat,params);
  glGetMultiTexLevelParameterfvEXT(texunit, target, level, pname, params);
  OGLM_CHECK_ERR(glGetMultiTexLevelParameterfvEXT, free(params);)
  OGLM_OUT_FINISH(params,pname_count,newSVnv)
  free(params);

void
glGetMultiTexLevelParameterivEXT_c(texunit, target, level, pname, params)
  GLenum texunit;
  GLenum target;
  GLint level;
  GLenum pname;
  GLint* params;
CODE:
  OGLM_GLEWINIT
  OGLM_CHECK_ERR(glGetMultiTexLevelParameterivEXT, )
  OGLM_AVAIL_CHECK(__glewGetMultiTexLevelParameterivEXT, glGetMultiTexLevelParameterivEXT)
  glGetMultiTexLevelParameterivEXT(texunit, target, level, pname, params);
  OGLM_CHECK_ERR(glGetMultiTexLevelParameterivEXT, )

void
glGetMultiTexLevelParameterivEXT_p(texunit, target, level, pname)
  GLenum texunit;
  GLenum target;
  GLint level;
  GLenum pname;
PPCODE:
  OGLM_GLEWINIT
  OGLM_CHECK_ERR(glGetMultiTexLevelParameterivEXT, )
  OGLM_AVAIL_CHECK(__glewGetMultiTexLevelParameterivEXT, glGetMultiTexLevelParameterivEXT)
  OGLM_SIZE_ENUM(GetTextureParameter,pname,1)
  GLint* params = OGLM_ALLOC(pname_count,GLint,params);
  glGetMultiTexLevelParameterivEXT(texunit, target, level, pname, params);
  OGLM_CHECK_ERR(glGetMultiTexLevelParameterivEXT, free(params);)
  OGLM_OUT_FINISH(params,pname_count,newSViv)
  free(params);

void
glGetMultiTexParameterIivEXT_c(texunit, target, pname, params)
  GLenum texunit;
  GLenum target;
  GLenum pname;
  GLint* params;
CODE:
  OGLM_GLEWINIT
  OGLM_CHECK_ERR(glGetMultiTexParameterIivEXT, )
  OGLM_AVAIL_CHECK(__glewGetMultiTexParameterIivEXT, glGetMultiTexParameterIivEXT)
  glGetMultiTexParameterIivEXT(texunit, target, pname, params);
  OGLM_CHECK_ERR(glGetMultiTexParameterIivEXT, )

void
glGetMultiTexParameterIivEXT_p(texunit, target, pname)
  GLenum texunit;
  GLenum target;
  GLenum pname;
PPCODE:
  OGLM_GLEWINIT
  OGLM_CHECK_ERR(glGetMultiTexParameterIivEXT, )
  OGLM_AVAIL_CHECK(__glewGetMultiTexParameterIivEXT, glGetMultiTexParameterIivEXT)
  OGLM_SIZE_ENUM(GetTextureParameter,pname,1)
  GLint* params = OGLM_ALLOC(pname_count,GLint,params);
  glGetMultiTexParameterIivEXT(texunit, target, pname, params);
  OGLM_CHECK_ERR(glGetMultiTexParameterIivEXT, free(params);)
  OGLM_OUT_FINISH(params,pname_count,newSViv)
  free(params);

void
glGetMultiTexParameterIuivEXT_c(texunit, target, pname, params)
  GLenum texunit;
  GLenum target;
  GLenum pname;
  GLuint* params;
CODE:
  OGLM_GLEWINIT
  OGLM_CHECK_ERR(glGetMultiTexParameterIuivEXT, )
  OGLM_AVAIL_CHECK(__glewGetMultiTexParameterIuivEXT, glGetMultiTexParameterIuivEXT)
  glGetMultiTexParameterIuivEXT(texunit, target, pname, params);
  OGLM_CHECK_ERR(glGetMultiTexParameterIuivEXT, )

void
glGetMultiTexParameterIuivEXT_p(texunit, target, pname)
  GLenum texunit;
  GLenum target;
  GLenum pname;
PPCODE:
  OGLM_GLEWINIT
  OGLM_CHECK_ERR(glGetMultiTexParameterIuivEXT, )
  OGLM_AVAIL_CHECK(__glewGetMultiTexParameterIuivEXT, glGetMultiTexParameterIuivEXT)
  OGLM_SIZE_ENUM(GetTextureParameter,pname,1)
  GLuint* params = OGLM_ALLOC(pname_count,GLuint,params);
  glGetMultiTexParameterIuivEXT(texunit, target, pname, params);
  OGLM_CHECK_ERR(glGetMultiTexParameterIuivEXT, free(params);)
  OGLM_OUT_FINISH(params,pname_count,newSVuv)
  free(params);

void
glGetMultiTexParameterfvEXT_c(texunit, target, pname, params)
  GLenum texunit;
  GLenum target;
  GLenum pname;
  GLfloat* params;
CODE:
  OGLM_GLEWINIT
  OGLM_CHECK_ERR(glGetMultiTexParameterfvEXT, )
  OGLM_AVAIL_CHECK(__glewGetMultiTexParameterfvEXT, glGetMultiTexParameterfvEXT)
  glGetMultiTexParameterfvEXT(texunit, target, pname, params);
  OGLM_CHECK_ERR(glGetMultiTexParameterfvEXT, )

void
glGetMultiTexParameterfvEXT_p(texunit, target, pname)
  GLenum texunit;
  GLenum target;
  GLenum pname;
PPCODE:
  OGLM_GLEWINIT
  OGLM_CHECK_ERR(glGetMultiTexParameterfvEXT, )
  OGLM_AVAIL_CHECK(__glewGetMultiTexParameterfvEXT, glGetMultiTexParameterfvEXT)
  OGLM_SIZE_ENUM(GetTextureParameter,pname,1)
  GLfloat* params = OGLM_ALLOC(pname_count,GLfloat,params);
  glGetMultiTexParameterfvEXT(texunit, target, pname, params);
  OGLM_CHECK_ERR(glGetMultiTexParameterfvEXT, free(params);)
  OGLM_OUT_FINISH(params,pname_count,newSVnv)
  free(params);

void
glGetMultiTexParameterivEXT_c(texunit, target, pname, params)
  GLenum texunit;
  GLenum target;
  GLenum pname;
  GLint* params;
CODE:
  OGLM_GLEWINIT
  OGLM_CHECK_ERR(glGetMultiTexParameterivEXT, )
  OGLM_AVAIL_CHECK(__glewGetMultiTexParameterivEXT, glGetMultiTexParameterivEXT)
  glGetMultiTexParameterivEXT(texunit, target, pname, params);
  OGLM_CHECK_ERR(glGetMultiTexParameterivEXT, )

void
glGetMultiTexParameterivEXT_p(texunit, target, pname)
  GLenum texunit;
  GLenum target;
  GLenum pname;
PPCODE:
  OGLM_GLEWINIT
  OGLM_CHECK_ERR(glGetMultiTexParameterivEXT, )
  OGLM_AVAIL_CHECK(__glewGetMultiTexParameterivEXT, glGetMultiTexParameterivEXT)
  OGLM_SIZE_ENUM(GetTextureParameter,pname,1)
  GLint* params = OGLM_ALLOC(pname_count,GLint,params);
  glGetMultiTexParameterivEXT(texunit, target, pname, params);
  OGLM_CHECK_ERR(glGetMultiTexParameterivEXT, free(params);)
  OGLM_OUT_FINISH(params,pname_count,newSViv)
  free(params);

void
glGetMultisamplefv_c(pname, index, val)
  GLenum pname;
  GLuint index;
  GLfloat* val;
ALIAS:
  glGetMultisamplefvNV_c = 1
CODE:
  OGLM_GLEWINIT
  OGLM_CHECK_ERR(glGetMultisamplefv, )
  OGLM_AVAIL_CHECK(__glewGetMultisamplefv, glGetMultisamplefv)
  glGetMultisamplefv(pname, index, val);
  OGLM_CHECK_ERR(glGetMultisamplefv, )

void
glGetMultisamplefv_p(pname, index)
  GLenum pname;
  GLuint index;
ALIAS:
  glGetMultisamplefvNV_p = 1
PPCODE:
  OGLM_GLEWINIT
  OGLM_CHECK_ERR(glGetMultisamplefv, )
  OGLM_AVAIL_CHECK(__glewGetMultisamplefv, glGetMultisamplefv)
  OGLM_SIZE_ENUM(GetMultisamplePNameNV,pname,1)
  GLfloat* val = OGLM_ALLOC(pname_count,GLfloat,val);
  glGetMultisamplefv(pname, index, val);
  OGLM_CHECK_ERR(glGetMultisamplefv, free(val);)
  OGLM_OUT_FINISH(val,pname_count,newSVnv)
  free(val);

void
glGetNamedBufferParameteri64v_c(buffer, pname, params)
  GLuint buffer;
  GLenum pname;
  GLint64* params;
CODE:
  OGLM_GLEWINIT
  OGLM_CHECK_ERR(glGetNamedBufferParameteri64v, )
  OGLM_AVAIL_CHECK(__glewGetNamedBufferParameteri64v, glGetNamedBufferParameteri64v)
  glGetNamedBufferParameteri64v(buffer, pname, params);
  OGLM_CHECK_ERR(glGetNamedBufferParameteri64v, )

void
glGetNamedBufferParameteriv_c(buffer, pname, params)
  GLuint buffer;
  GLenum pname;
  GLint* params;
CODE:
  OGLM_GLEWINIT
  OGLM_CHECK_ERR(glGetNamedBufferParameteriv, )
  OGLM_AVAIL_CHECK(__glewGetNamedBufferParameteriv, glGetNamedBufferParameteriv)
  glGetNamedBufferParameteriv(buffer, pname, params);
  OGLM_CHECK_ERR(glGetNamedBufferParameteriv, )

void
glGetNamedBufferParameterivEXT_c(buffer, pname, params)
  GLuint buffer;
  GLenum pname;
  GLint* params;
CODE:
  OGLM_GLEWINIT
  OGLM_CHECK_ERR(glGetNamedBufferParameterivEXT, )
  OGLM_AVAIL_CHECK(__glewGetNamedBufferParameterivEXT, glGetNamedBufferParameterivEXT)
  glGetNamedBufferParameterivEXT(buffer, pname, params);
  OGLM_CHECK_ERR(glGetNamedBufferParameterivEXT, )

void
glGetNamedBufferParameterivEXT_p(buffer, pname)
  GLuint buffer;
  GLenum pname;
PPCODE:
  OGLM_GLEWINIT
  OGLM_CHECK_ERR(glGetNamedBufferParameterivEXT, )
  OGLM_AVAIL_CHECK(__glewGetNamedBufferParameterivEXT, glGetNamedBufferParameterivEXT)
  OGLM_SIZE_ENUM(BufferPNameARB,pname,1)
  GLint* params = OGLM_ALLOC(pname_count,GLint,params);
  glGetNamedBufferParameterivEXT(buffer, pname, params);
  OGLM_CHECK_ERR(glGetNamedBufferParameterivEXT, free(params);)
  OGLM_OUT_FINISH(params,pname_count,newSViv)
  free(params);

void
glGetNamedBufferParameterui64vNV_c(buffer, pname, params)
  GLuint buffer;
  GLenum pname;
  GLuint64EXT* params;
CODE:
  OGLM_GLEWINIT
  OGLM_CHECK_ERR(glGetNamedBufferParameterui64vNV, )
  OGLM_AVAIL_CHECK(__glewGetNamedBufferParameterui64vNV, glGetNamedBufferParameterui64vNV)
  glGetNamedBufferParameterui64vNV(buffer, pname, params);
  OGLM_CHECK_ERR(glGetNamedBufferParameterui64vNV, )

void
glGetNamedBufferParameterui64vNV_p(buffer, pname)
  GLuint buffer;
  GLenum pname;
PPCODE:
  OGLM_GLEWINIT
  OGLM_CHECK_ERR(glGetNamedBufferParameterui64vNV, )
  OGLM_AVAIL_CHECK(__glewGetNamedBufferParameterui64vNV, glGetNamedBufferParameterui64vNV)
  OGLM_SIZE_ENUM(BufferPNameARB,pname,1)
  GLuint64EXT* params = OGLM_ALLOC(pname_count,GLuint64EXT,params);
  glGetNamedBufferParameterui64vNV(buffer, pname, params);
  OGLM_CHECK_ERR(glGetNamedBufferParameterui64vNV, free(params);)
  OGLM_OUT_FINISH(params,pname_count,newSVuv)
  free(params);

void
glGetNamedBufferPointerv_c(buffer, pname, params)
  GLuint buffer;
  GLenum pname;
  void** params;
CODE:
  OGLM_GLEWINIT
  OGLM_CHECK_ERR(glGetNamedBufferPointerv, )
  OGLM_AVAIL_CHECK(__glewGetNamedBufferPointerv, glGetNamedBufferPointerv)
  glGetNamedBufferPointerv(buffer, pname, params);
  OGLM_CHECK_ERR(glGetNamedBufferPointerv, )

void
glGetNamedBufferPointervEXT_c(buffer, pname, params)
  GLuint buffer;
  GLenum pname;
  void** params;
CODE:
  OGLM_GLEWINIT
  OGLM_CHECK_ERR(glGetNamedBufferPointervEXT, )
  OGLM_AVAIL_CHECK(__glewGetNamedBufferPointervEXT, glGetNamedBufferPointervEXT)
  glGetNamedBufferPointervEXT(buffer, pname, params);
  OGLM_CHECK_ERR(glGetNamedBufferPointervEXT, )

void
glGetNamedBufferSubData_c(buffer, offset, size, data)
  GLuint buffer;
  GLintptr offset;
  GLsizeiptr size;
  void *data;
CODE:
  OGLM_GLEWINIT
  OGLM_CHECK_ERR(glGetNamedBufferSubData, )
  OGLM_AVAIL_CHECK(__glewGetNamedBufferSubData, glGetNamedBufferSubData)
  glGetNamedBufferSubData(buffer, offset, size, data);
  OGLM_CHECK_ERR(glGetNamedBufferSubData, )

void
glGetNamedBufferSubDataEXT_c(buffer, offset, size, data)
  GLuint buffer;
  GLintptr offset;
  GLsizeiptr size;
  void *data;
CODE:
  OGLM_GLEWINIT
  OGLM_CHECK_ERR(glGetNamedBufferSubDataEXT, )
  OGLM_AVAIL_CHECK(__glewGetNamedBufferSubDataEXT, glGetNamedBufferSubDataEXT)
  glGetNamedBufferSubDataEXT(buffer, offset, size, data);
  OGLM_CHECK_ERR(glGetNamedBufferSubDataEXT, )

void
glGetNamedFramebufferAttachmentParameteriv_c(framebuffer, attachment, pname, params)
  GLuint framebuffer;
  GLenum attachment;
  GLenum pname;
  GLint* params;
CODE:
  OGLM_GLEWINIT
  OGLM_CHECK_ERR(glGetNamedFramebufferAttachmentParameteriv, )
  OGLM_AVAIL_CHECK(__glewGetNamedFramebufferAttachmentParameteriv, glGetNamedFramebufferAttachmentParameteriv)
  glGetNamedFramebufferAttachmentParameteriv(framebuffer, attachment, pname, params);
  OGLM_CHECK_ERR(glGetNamedFramebufferAttachmentParameteriv, )

void
glGetNamedFramebufferAttachmentParameterivEXT_c(framebuffer, attachment, pname, params)
  GLuint framebuffer;
  GLenum attachment;
  GLenum pname;
  GLint* params;
CODE:
  OGLM_GLEWINIT
  OGLM_CHECK_ERR(glGetNamedFramebufferAttachmentParameterivEXT, )
  OGLM_AVAIL_CHECK(__glewGetNamedFramebufferAttachmentParameterivEXT, glGetNamedFramebufferAttachmentParameterivEXT)
  glGetNamedFramebufferAttachmentParameterivEXT(framebuffer, attachment, pname, params);
  OGLM_CHECK_ERR(glGetNamedFramebufferAttachmentParameterivEXT, )

void
glGetNamedFramebufferAttachmentParameterivEXT_p(framebuffer, attachment, pname)
  GLuint framebuffer;
  GLenum attachment;
  GLenum pname;
PPCODE:
  OGLM_GLEWINIT
  OGLM_CHECK_ERR(glGetNamedFramebufferAttachmentParameterivEXT, )
  OGLM_AVAIL_CHECK(__glewGetNamedFramebufferAttachmentParameterivEXT, glGetNamedFramebufferAttachmentParameterivEXT)
  OGLM_SIZE_ENUM(FramebufferAttachmentParameterName,pname,1)
  GLint* params = OGLM_ALLOC(pname_count,GLint,params);
  glGetNamedFramebufferAttachmentParameterivEXT(framebuffer, attachment, pname, params);
  OGLM_CHECK_ERR(glGetNamedFramebufferAttachmentParameterivEXT, free(params);)
  OGLM_OUT_FINISH(params,pname_count,newSViv)
  free(params);

void
glGetNamedFramebufferParameterfvAMD_c(framebuffer, pname, numsamples, pixelindex, size, values)
  GLuint framebuffer;
  GLenum pname;
  GLuint numsamples;
  GLuint pixelindex;
  GLsizei size;
  GLfloat* values;
CODE:
  OGLM_GLEWINIT
  OGLM_CHECK_ERR(glGetNamedFramebufferParameterfvAMD, )
  OGLM_AVAIL_CHECK(__glewGetNamedFramebufferParameterfvAMD, glGetNamedFramebufferParameterfvAMD)
  glGetNamedFramebufferParameterfvAMD(framebuffer, pname, numsamples, pixelindex, size, values);
  OGLM_CHECK_ERR(glGetNamedFramebufferParameterfvAMD, )

void
glGetNamedFramebufferParameteriv_c(framebuffer, pname, param)
  GLuint framebuffer;
  GLenum pname;
  GLint* param;
CODE:
  OGLM_GLEWINIT
  OGLM_CHECK_ERR(glGetNamedFramebufferParameteriv, )
  OGLM_AVAIL_CHECK(__glewGetNamedFramebufferParameteriv, glGetNamedFramebufferParameteriv)
  glGetNamedFramebufferParameteriv(framebuffer, pname, param);
  OGLM_CHECK_ERR(glGetNamedFramebufferParameteriv, )

void
glGetNamedFramebufferParameterivEXT_c(framebuffer, pname, params)
  GLuint framebuffer;
  GLenum pname;
  GLint* params;
CODE:
  OGLM_GLEWINIT
  OGLM_CHECK_ERR(glGetNamedFramebufferParameterivEXT, )
  OGLM_AVAIL_CHECK(__glewGetNamedFramebufferParameterivEXT, glGetNamedFramebufferParameterivEXT)
  glGetNamedFramebufferParameterivEXT(framebuffer, pname, params);
  OGLM_CHECK_ERR(glGetNamedFramebufferParameterivEXT, )

void
glGetNamedFramebufferParameterivEXT_p(framebuffer, pname)
  GLuint framebuffer;
  GLenum pname;
PPCODE:
  OGLM_GLEWINIT
  OGLM_CHECK_ERR(glGetNamedFramebufferParameterivEXT, )
  OGLM_AVAIL_CHECK(__glewGetNamedFramebufferParameterivEXT, glGetNamedFramebufferParameterivEXT)
  OGLM_SIZE_ENUM(GetFramebufferParameter,pname,1)
  GLint* params = OGLM_ALLOC(pname_count,GLint,params);
  glGetNamedFramebufferParameterivEXT(framebuffer, pname, params);
  OGLM_CHECK_ERR(glGetNamedFramebufferParameterivEXT, free(params);)
  OGLM_OUT_FINISH(params,pname_count,newSViv)
  free(params);

void
glGetNamedProgramLocalParameterIivEXT_c(program, target, index, params)
  GLuint program;
  GLenum target;
  GLuint index;
  GLint* params;
CODE:
  OGLM_GLEWINIT
  OGLM_CHECK_ERR(glGetNamedProgramLocalParameterIivEXT, )
  OGLM_AVAIL_CHECK(__glewGetNamedProgramLocalParameterIivEXT, glGetNamedProgramLocalParameterIivEXT)
  glGetNamedProgramLocalParameterIivEXT(program, target, index, params);
  OGLM_CHECK_ERR(glGetNamedProgramLocalParameterIivEXT, )

void
glGetNamedProgramLocalParameterIivEXT_p(program, target, index)
  GLuint program;
  GLenum target;
  GLuint index;
PPCODE:
  OGLM_GLEWINIT
  OGLM_CHECK_ERR(glGetNamedProgramLocalParameterIivEXT, )
  OGLM_AVAIL_CHECK(__glewGetNamedProgramLocalParameterIivEXT, glGetNamedProgramLocalParameterIivEXT)
  GLint* params = OGLM_ALLOC(4,GLint,params);
  glGetNamedProgramLocalParameterIivEXT(program, target, index, params);
  OGLM_CHECK_ERR(glGetNamedProgramLocalParameterIivEXT, free(params);)
  OGLM_OUT_FINISH(params,4,newSViv)
  free(params);

void
glGetNamedProgramLocalParameterIuivEXT_c(program, target, index, params)
  GLuint program;
  GLenum target;
  GLuint index;
  GLuint* params;
CODE:
  OGLM_GLEWINIT
  OGLM_CHECK_ERR(glGetNamedProgramLocalParameterIuivEXT, )
  OGLM_AVAIL_CHECK(__glewGetNamedProgramLocalParameterIuivEXT, glGetNamedProgramLocalParameterIuivEXT)
  glGetNamedProgramLocalParameterIuivEXT(program, target, index, params);
  OGLM_CHECK_ERR(glGetNamedProgramLocalParameterIuivEXT, )

void
glGetNamedProgramLocalParameterIuivEXT_p(program, target, index)
  GLuint program;
  GLenum target;
  GLuint index;
PPCODE:
  OGLM_GLEWINIT
  OGLM_CHECK_ERR(glGetNamedProgramLocalParameterIuivEXT, )
  OGLM_AVAIL_CHECK(__glewGetNamedProgramLocalParameterIuivEXT, glGetNamedProgramLocalParameterIuivEXT)
  GLuint* params = OGLM_ALLOC(4,GLuint,params);
  glGetNamedProgramLocalParameterIuivEXT(program, target, index, params);
  OGLM_CHECK_ERR(glGetNamedProgramLocalParameterIuivEXT, free(params);)
  OGLM_OUT_FINISH(params,4,newSVuv)
  free(params);

void
glGetNamedProgramLocalParameterdvEXT_c(program, target, index, params)
  GLuint program;
  GLenum target;
  GLuint index;
  GLdouble* params;
CODE:
  OGLM_GLEWINIT
  OGLM_CHECK_ERR(glGetNamedProgramLocalParameterdvEXT, )
  OGLM_AVAIL_CHECK(__glewGetNamedProgramLocalParameterdvEXT, glGetNamedProgramLocalParameterdvEXT)
  glGetNamedProgramLocalParameterdvEXT(program, target, index, params);
  OGLM_CHECK_ERR(glGetNamedProgramLocalParameterdvEXT, )

void
glGetNamedProgramLocalParameterdvEXT_p(program, target, index)
  GLuint program;
  GLenum target;
  GLuint index;
PPCODE:
  OGLM_GLEWINIT
  OGLM_CHECK_ERR(glGetNamedProgramLocalParameterdvEXT, )
  OGLM_AVAIL_CHECK(__glewGetNamedProgramLocalParameterdvEXT, glGetNamedProgramLocalParameterdvEXT)
  GLdouble* params = OGLM_ALLOC(4,GLdouble,params);
  glGetNamedProgramLocalParameterdvEXT(program, target, index, params);
  OGLM_CHECK_ERR(glGetNamedProgramLocalParameterdvEXT, free(params);)
  OGLM_OUT_FINISH(params,4,newSVnv)
  free(params);

void
glGetNamedProgramLocalParameterfvEXT_c(program, target, index, params)
  GLuint program;
  GLenum target;
  GLuint index;
  GLfloat* params;
CODE:
  OGLM_GLEWINIT
  OGLM_CHECK_ERR(glGetNamedProgramLocalParameterfvEXT, )
  OGLM_AVAIL_CHECK(__glewGetNamedProgramLocalParameterfvEXT, glGetNamedProgramLocalParameterfvEXT)
  glGetNamedProgramLocalParameterfvEXT(program, target, index, params);
  OGLM_CHECK_ERR(glGetNamedProgramLocalParameterfvEXT, )

void
glGetNamedProgramLocalParameterfvEXT_p(program, target, index)
  GLuint program;
  GLenum target;
  GLuint index;
PPCODE:
  OGLM_GLEWINIT
  OGLM_CHECK_ERR(glGetNamedProgramLocalParameterfvEXT, )
  OGLM_AVAIL_CHECK(__glewGetNamedProgramLocalParameterfvEXT, glGetNamedProgramLocalParameterfvEXT)
  GLfloat* params = OGLM_ALLOC(4,GLfloat,params);
  glGetNamedProgramLocalParameterfvEXT(program, target, index, params);
  OGLM_CHECK_ERR(glGetNamedProgramLocalParameterfvEXT, free(params);)
  OGLM_OUT_FINISH(params,4,newSVnv)
  free(params);

void
glGetNamedProgramStringEXT_c(program, target, pname, string)
  GLuint program;
  GLenum target;
  GLenum pname;
  void *string;
CODE:
  OGLM_GLEWINIT
  OGLM_CHECK_ERR(glGetNamedProgramStringEXT, )
  OGLM_AVAIL_CHECK(__glewGetNamedProgramStringEXT, glGetNamedProgramStringEXT)
  glGetNamedProgramStringEXT(program, target, pname, string);
  OGLM_CHECK_ERR(glGetNamedProgramStringEXT, )

void
glGetNamedProgramivEXT_c(program, target, pname, params)
  GLuint program;
  GLenum target;
  GLenum pname;
  GLint* params;
CODE:
  OGLM_GLEWINIT
  OGLM_CHECK_ERR(glGetNamedProgramivEXT, )
  OGLM_AVAIL_CHECK(__glewGetNamedProgramivEXT, glGetNamedProgramivEXT)
  glGetNamedProgramivEXT(program, target, pname, params);
  OGLM_CHECK_ERR(glGetNamedProgramivEXT, )

GLint
glGetNamedProgramivEXT_p(program, target, pname)
  GLuint program;
  GLenum target;
  GLenum pname;
CODE:
  OGLM_GLEWINIT
  OGLM_CHECK_ERR(glGetNamedProgramivEXT, )
  OGLM_AVAIL_CHECK(__glewGetNamedProgramivEXT, glGetNamedProgramivEXT)
  GLint params[1];
  glGetNamedProgramivEXT(program, target, pname, params);
  OGLM_CHECK_ERR(glGetNamedProgramivEXT, )
  RETVAL = params[0];
OUTPUT:
  RETVAL

void
glGetNamedRenderbufferParameteriv_c(renderbuffer, pname, params)
  GLuint renderbuffer;
  GLenum pname;
  GLint* params;
CODE:
  OGLM_GLEWINIT
  OGLM_CHECK_ERR(glGetNamedRenderbufferParameteriv, )
  OGLM_AVAIL_CHECK(__glewGetNamedRenderbufferParameteriv, glGetNamedRenderbufferParameteriv)
  glGetNamedRenderbufferParameteriv(renderbuffer, pname, params);
  OGLM_CHECK_ERR(glGetNamedRenderbufferParameteriv, )

void
glGetNamedRenderbufferParameterivEXT_c(renderbuffer, pname, params)
  GLuint renderbuffer;
  GLenum pname;
  GLint* params;
CODE:
  OGLM_GLEWINIT
  OGLM_CHECK_ERR(glGetNamedRenderbufferParameterivEXT, )
  OGLM_AVAIL_CHECK(__glewGetNamedRenderbufferParameterivEXT, glGetNamedRenderbufferParameterivEXT)
  glGetNamedRenderbufferParameterivEXT(renderbuffer, pname, params);
  OGLM_CHECK_ERR(glGetNamedRenderbufferParameterivEXT, )

void
glGetNamedRenderbufferParameterivEXT_p(renderbuffer, pname)
  GLuint renderbuffer;
  GLenum pname;
PPCODE:
  OGLM_GLEWINIT
  OGLM_CHECK_ERR(glGetNamedRenderbufferParameterivEXT, )
  OGLM_AVAIL_CHECK(__glewGetNamedRenderbufferParameterivEXT, glGetNamedRenderbufferParameterivEXT)
  OGLM_SIZE_ENUM(RenderbufferParameterName,pname,1)
  GLint* params = OGLM_ALLOC(pname_count,GLint,params);
  glGetNamedRenderbufferParameterivEXT(renderbuffer, pname, params);
  OGLM_CHECK_ERR(glGetNamedRenderbufferParameterivEXT, free(params);)
  OGLM_OUT_FINISH(params,pname_count,newSViv)
  free(params);

void
glGetNamedStringARB_c(namelen, name, bufSize, stringlen, string)
  GLint namelen;
  const GLchar* name;
  GLsizei bufSize;
  GLint *stringlen;
  GLchar *string;
CODE:
  OGLM_GLEWINIT
  OGLM_CHECK_ERR(glGetNamedStringARB, )
  OGLM_AVAIL_CHECK(__glewGetNamedStringARB, glGetNamedStringARB)
  glGetNamedStringARB(namelen, name, bufSize, stringlen, string);
  OGLM_CHECK_ERR(glGetNamedStringARB, )

void
glGetNamedStringARB_p(namelen, name, bufSize)
  GLint namelen;
  const GLchar* name;
  GLsizei bufSize;
PPCODE:
  OGLM_GLEWINIT
  OGLM_CHECK_ERR(glGetNamedStringARB, )
  OGLM_AVAIL_CHECK(__glewGetNamedStringARB, glGetNamedStringARB)
  GLchar string[bufSize];
  GLint stringlen[1];
  glGetNamedStringARB(namelen, name, bufSize, stringlen, string);
  OGLM_CHECK_ERR(glGetNamedStringARB, )
  EXTEND(sp, 2);
  mPUSHs(newSViv(stringlen[0]));
  mPUSHs(newSVpv(string,0));

void
glGetNamedStringivARB_c(namelen, name, pname, params)
  GLint namelen;
  const GLchar* name;
  GLenum pname;
  GLint *params;
CODE:
  OGLM_GLEWINIT
  OGLM_CHECK_ERR(glGetNamedStringivARB, )
  OGLM_AVAIL_CHECK(__glewGetNamedStringivARB, glGetNamedStringivARB)
  glGetNamedStringivARB(namelen, name, pname, params);
  OGLM_CHECK_ERR(glGetNamedStringivARB, )

void
glGetNextPerfQueryIdINTEL_c(queryId, nextQueryId)
  GLuint queryId;
  GLuint* nextQueryId;
CODE:
  OGLM_GLEWINIT
  OGLM_CHECK_ERR(glGetNextPerfQueryIdINTEL, )
  OGLM_AVAIL_CHECK(__glewGetNextPerfQueryIdINTEL, glGetNextPerfQueryIdINTEL)
  glGetNextPerfQueryIdINTEL(queryId, nextQueryId);
  OGLM_CHECK_ERR(glGetNextPerfQueryIdINTEL, )

void
glGetNonlinLightfvSGIX_c(light, pname, terms, data)
  GLenum light;
  GLenum pname;
  GLint* terms;
  GLfloat *data;
CODE:
  OGLM_GLEWINIT
  OGLM_CHECK_ERR(glGetNonlinLightfvSGIX, )
  OGLM_AVAIL_CHECK(__glewGetNonlinLightfvSGIX, glGetNonlinLightfvSGIX)
  glGetNonlinLightfvSGIX(light, pname, terms, data);
  OGLM_CHECK_ERR(glGetNonlinLightfvSGIX, )

void
glGetNonlinMaterialfvSGIX_c(face, pname, terms, data)
  GLenum face;
  GLenum pname;
  GLint* terms;
  const GLfloat *data;
CODE:
  OGLM_GLEWINIT
  OGLM_CHECK_ERR(glGetNonlinMaterialfvSGIX, )
  OGLM_AVAIL_CHECK(__glewGetNonlinMaterialfvSGIX, glGetNonlinMaterialfvSGIX)
  glGetNonlinMaterialfvSGIX(face, pname, terms, data);
  OGLM_CHECK_ERR(glGetNonlinMaterialfvSGIX, )

void
glGetObjectBufferfvATI_c(buffer, pname, params)
  GLuint buffer;
  GLenum pname;
  GLfloat* params;
CODE:
  OGLM_GLEWINIT
  OGLM_CHECK_ERR(glGetObjectBufferfvATI, )
  OGLM_AVAIL_CHECK(__glewGetObjectBufferfvATI, glGetObjectBufferfvATI)
  glGetObjectBufferfvATI(buffer, pname, params);
  OGLM_CHECK_ERR(glGetObjectBufferfvATI, )

GLfloat
glGetObjectBufferfvATI_p(buffer, pname)
  GLuint buffer;
  GLenum pname;
CODE:
  OGLM_GLEWINIT
  OGLM_CHECK_ERR(glGetObjectBufferfvATI, )
  OGLM_AVAIL_CHECK(__glewGetObjectBufferfvATI, glGetObjectBufferfvATI)
  GLfloat params[1];
  glGetObjectBufferfvATI(buffer, pname, params);
  OGLM_CHECK_ERR(glGetObjectBufferfvATI, )
  RETVAL = params[0];
OUTPUT:
  RETVAL

void
glGetObjectBufferivATI_c(buffer, pname, params)
  GLuint buffer;
  GLenum pname;
  GLint* params;
CODE:
  OGLM_GLEWINIT
  OGLM_CHECK_ERR(glGetObjectBufferivATI, )
  OGLM_AVAIL_CHECK(__glewGetObjectBufferivATI, glGetObjectBufferivATI)
  glGetObjectBufferivATI(buffer, pname, params);
  OGLM_CHECK_ERR(glGetObjectBufferivATI, )

GLint
glGetObjectBufferivATI_p(buffer, pname)
  GLuint buffer;
  GLenum pname;
CODE:
  OGLM_GLEWINIT
  OGLM_CHECK_ERR(glGetObjectBufferivATI, )
  OGLM_AVAIL_CHECK(__glewGetObjectBufferivATI, glGetObjectBufferivATI)
  GLint params[1];
  glGetObjectBufferivATI(buffer, pname, params);
  OGLM_CHECK_ERR(glGetObjectBufferivATI, )
  RETVAL = params[0];
OUTPUT:
  RETVAL

void
glGetObjectLabel_c(identifier, name, bufSize, length, label)
  GLenum identifier;
  GLuint name;
  GLsizei bufSize;
  GLsizei* length;
  GLchar *label;
ALIAS:
  glGetObjectLabelKHR_c = 1
CODE:
  OGLM_GLEWINIT
  OGLM_CHECK_ERR(glGetObjectLabel, )
  OGLM_AVAIL_CHECK(__glewGetObjectLabel, glGetObjectLabel)
  glGetObjectLabel(identifier, name, bufSize, length, label);
  OGLM_CHECK_ERR(glGetObjectLabel, )

GLchar *
glGetObjectLabel_p(identifier, name)
  GLenum identifier;
  GLuint name;
ALIAS:
  glGetObjectLabelKHR_p = 1
CODE:
  OGLM_GLEWINIT
  OGLM_CHECK_ERR(glGetObjectLabel, )
  OGLM_AVAIL_CHECK(__glewGetObjectLabel, glGetObjectLabel)
  GLsizei bufSize;
  glGetIntegerv(GL_MAX_LABEL_LENGTH,&bufSize);
  GLsizei* length = NULL;
  GLchar label[bufSize];
  glGetObjectLabel(identifier, name, bufSize, length, label);
  OGLM_CHECK_ERR(glGetObjectLabel, )
  RETVAL = label;
OUTPUT:
  RETVAL

void
glGetObjectLabelEXT_c(type, object, bufSize, length, label)
  GLenum type;
  GLuint object;
  GLsizei bufSize;
  GLsizei* length;
  GLchar *label;
CODE:
  OGLM_GLEWINIT
  OGLM_CHECK_ERR(glGetObjectLabelEXT, )
  OGLM_AVAIL_CHECK(__glewGetObjectLabelEXT, glGetObjectLabelEXT)
  glGetObjectLabelEXT(type, object, bufSize, length, label);
  OGLM_CHECK_ERR(glGetObjectLabelEXT, )

void
glGetObjectLabelEXT_p(type, object, bufSize)
  GLenum type;
  GLuint object;
  GLsizei bufSize;
PPCODE:
  OGLM_GLEWINIT
  OGLM_CHECK_ERR(glGetObjectLabelEXT, )
  OGLM_AVAIL_CHECK(__glewGetObjectLabelEXT, glGetObjectLabelEXT)
  GLchar label[bufSize];
  GLsizei length[1];
  glGetObjectLabelEXT(type, object, bufSize, length, label);
  OGLM_CHECK_ERR(glGetObjectLabelEXT, )
  EXTEND(sp, 2);
  mPUSHs(newSViv(length[0]));
  mPUSHs(newSVpv(label,0));

void
glGetObjectParameterfvARB_c(obj, pname, params)
  GLhandleARB obj;
  GLenum pname;
  GLfloat* params;
CODE:
  OGLM_GLEWINIT
  OGLM_CHECK_ERR(glGetObjectParameterfvARB, )
  OGLM_AVAIL_CHECK(__glewGetObjectParameterfvARB, glGetObjectParameterfvARB)
  glGetObjectParameterfvARB(obj, pname, params);
  OGLM_CHECK_ERR(glGetObjectParameterfvARB, )

void
glGetObjectParameterivAPPLE_c(objectType, name, pname, params)
  GLenum objectType;
  GLuint name;
  GLenum pname;
  GLint* params;
CODE:
  OGLM_GLEWINIT
  OGLM_CHECK_ERR(glGetObjectParameterivAPPLE, )
  OGLM_AVAIL_CHECK(__glewGetObjectParameterivAPPLE, glGetObjectParameterivAPPLE)
  glGetObjectParameterivAPPLE(objectType, name, pname, params);
  OGLM_CHECK_ERR(glGetObjectParameterivAPPLE, )

void
glGetObjectParameterivARB_c(obj, pname, params)
  GLhandleARB obj;
  GLenum pname;
  GLint* params;
CODE:
  OGLM_GLEWINIT
  OGLM_CHECK_ERR(glGetObjectParameterivARB, )
  OGLM_AVAIL_CHECK(__glewGetObjectParameterivARB, glGetObjectParameterivARB)
  glGetObjectParameterivARB(obj, pname, params);
  OGLM_CHECK_ERR(glGetObjectParameterivARB, )

void
glGetObjectPtrLabel_c(ptr, bufSize, length, label)
  void* ptr;
  GLsizei bufSize;
  GLsizei* length;
  GLchar *label;
ALIAS:
  glGetObjectPtrLabelKHR_c = 1
CODE:
  OGLM_GLEWINIT
  OGLM_CHECK_ERR(glGetObjectPtrLabel, )
  OGLM_AVAIL_CHECK(__glewGetObjectPtrLabel, glGetObjectPtrLabel)
  glGetObjectPtrLabel(ptr, bufSize, length, label);
  OGLM_CHECK_ERR(glGetObjectPtrLabel, )

void
glGetOcclusionQueryivNV_c(id, pname, params)
  GLuint id;
  GLenum pname;
  GLint* params;
CODE:
  OGLM_GLEWINIT
  OGLM_CHECK_ERR(glGetOcclusionQueryivNV, )
  OGLM_AVAIL_CHECK(__glewGetOcclusionQueryivNV, glGetOcclusionQueryivNV)
  glGetOcclusionQueryivNV(id, pname, params);
  OGLM_CHECK_ERR(glGetOcclusionQueryivNV, )

void
glGetOcclusionQueryuivNV_c(id, pname, params)
  GLuint id;
  GLenum pname;
  GLuint* params;
CODE:
  OGLM_GLEWINIT
  OGLM_CHECK_ERR(glGetOcclusionQueryuivNV, )
  OGLM_AVAIL_CHECK(__glewGetOcclusionQueryuivNV, glGetOcclusionQueryuivNV)
  glGetOcclusionQueryuivNV(id, pname, params);
  OGLM_CHECK_ERR(glGetOcclusionQueryuivNV, )

void
glGetPathColorGenfvNV_c(color, pname, value)
  GLenum color;
  GLenum pname;
  GLfloat* value;
CODE:
  OGLM_GLEWINIT
  OGLM_CHECK_ERR(glGetPathColorGenfvNV, )
  OGLM_AVAIL_CHECK(__glewGetPathColorGenfvNV, glGetPathColorGenfvNV)
  glGetPathColorGenfvNV(color, pname, value);
  OGLM_CHECK_ERR(glGetPathColorGenfvNV, )

void
glGetPathColorGenivNV_c(color, pname, value)
  GLenum color;
  GLenum pname;
  GLint* value;
CODE:
  OGLM_GLEWINIT
  OGLM_CHECK_ERR(glGetPathColorGenivNV, )
  OGLM_AVAIL_CHECK(__glewGetPathColorGenivNV, glGetPathColorGenivNV)
  glGetPathColorGenivNV(color, pname, value);
  OGLM_CHECK_ERR(glGetPathColorGenivNV, )

void
glGetPathCommandsNV_c(path, commands)
  GLuint path;
  GLubyte* commands;
CODE:
  OGLM_GLEWINIT
  OGLM_CHECK_ERR(glGetPathCommandsNV, )
  OGLM_AVAIL_CHECK(__glewGetPathCommandsNV, glGetPathCommandsNV)
  glGetPathCommandsNV(path, commands);
  OGLM_CHECK_ERR(glGetPathCommandsNV, )

void
glGetPathCoordsNV_c(path, coords)
  GLuint path;
  GLfloat* coords;
CODE:
  OGLM_GLEWINIT
  OGLM_CHECK_ERR(glGetPathCoordsNV, )
  OGLM_AVAIL_CHECK(__glewGetPathCoordsNV, glGetPathCoordsNV)
  glGetPathCoordsNV(path, coords);
  OGLM_CHECK_ERR(glGetPathCoordsNV, )

void
glGetPathDashArrayNV_c(path, dashArray)
  GLuint path;
  GLfloat* dashArray;
CODE:
  OGLM_GLEWINIT
  OGLM_CHECK_ERR(glGetPathDashArrayNV, )
  OGLM_AVAIL_CHECK(__glewGetPathDashArrayNV, glGetPathDashArrayNV)
  glGetPathDashArrayNV(path, dashArray);
  OGLM_CHECK_ERR(glGetPathDashArrayNV, )

GLfloat
glGetPathLengthNV(path, startSegment, numSegments)
  GLuint path;
  GLsizei startSegment;
  GLsizei numSegments;
CODE:
  OGLM_GLEWINIT
  OGLM_CHECK_ERR(glGetPathLengthNV, )
  OGLM_AVAIL_CHECK(__glewGetPathLengthNV, glGetPathLengthNV)
  RETVAL = glGetPathLengthNV(path, startSegment, numSegments);
  OGLM_CHECK_ERR(glGetPathLengthNV, )
OUTPUT:
  RETVAL

void
glGetPathMetricRangeNV_c(metricQueryMask, firstPathName, numPaths, stride, metrics)
  GLbitfield metricQueryMask;
  GLuint firstPathName;
  GLsizei numPaths;
  GLsizei stride;
  GLfloat* metrics;
CODE:
  OGLM_GLEWINIT
  OGLM_CHECK_ERR(glGetPathMetricRangeNV, )
  OGLM_AVAIL_CHECK(__glewGetPathMetricRangeNV, glGetPathMetricRangeNV)
  glGetPathMetricRangeNV(metricQueryMask, firstPathName, numPaths, stride, metrics);
  OGLM_CHECK_ERR(glGetPathMetricRangeNV, )

void
glGetPathMetricsNV_c(metricQueryMask, numPaths, pathNameType, paths, pathBase, stride, metrics)
  GLbitfield metricQueryMask;
  GLsizei numPaths;
  GLenum pathNameType;
  const void *paths;
  GLuint pathBase;
  GLsizei stride;
  GLfloat *metrics;
CODE:
  OGLM_GLEWINIT
  OGLM_CHECK_ERR(glGetPathMetricsNV, )
  OGLM_AVAIL_CHECK(__glewGetPathMetricsNV, glGetPathMetricsNV)
  glGetPathMetricsNV(metricQueryMask, numPaths, pathNameType, paths, pathBase, stride, metrics);
  OGLM_CHECK_ERR(glGetPathMetricsNV, )

void
glGetPathParameterfvNV_c(path, pname, value)
  GLuint path;
  GLenum pname;
  GLfloat* value;
CODE:
  OGLM_GLEWINIT
  OGLM_CHECK_ERR(glGetPathParameterfvNV, )
  OGLM_AVAIL_CHECK(__glewGetPathParameterfvNV, glGetPathParameterfvNV)
  glGetPathParameterfvNV(path, pname, value);
  OGLM_CHECK_ERR(glGetPathParameterfvNV, )

void
glGetPathParameterfvNV_p(path, pname)
  GLuint path;
  GLenum pname;
PPCODE:
  OGLM_GLEWINIT
  OGLM_CHECK_ERR(glGetPathParameterfvNV, )
  OGLM_AVAIL_CHECK(__glewGetPathParameterfvNV, glGetPathParameterfvNV)
  GLfloat* value = OGLM_ALLOC(4,GLfloat,value);
  glGetPathParameterfvNV(path, pname, value);
  OGLM_CHECK_ERR(glGetPathParameterfvNV, free(value);)
  OGLM_OUT_FINISH(value,4,newSVnv)
  free(value);

void
glGetPathParameterivNV_c(path, pname, value)
  GLuint path;
  GLenum pname;
  GLint* value;
CODE:
  OGLM_GLEWINIT
  OGLM_CHECK_ERR(glGetPathParameterivNV, )
  OGLM_AVAIL_CHECK(__glewGetPathParameterivNV, glGetPathParameterivNV)
  glGetPathParameterivNV(path, pname, value);
  OGLM_CHECK_ERR(glGetPathParameterivNV, )

void
glGetPathParameterivNV_p(path, pname)
  GLuint path;
  GLenum pname;
PPCODE:
  OGLM_GLEWINIT
  OGLM_CHECK_ERR(glGetPathParameterivNV, )
  OGLM_AVAIL_CHECK(__glewGetPathParameterivNV, glGetPathParameterivNV)
  GLint* value = OGLM_ALLOC(4,GLint,value);
  glGetPathParameterivNV(path, pname, value);
  OGLM_CHECK_ERR(glGetPathParameterivNV, free(value);)
  OGLM_OUT_FINISH(value,4,newSViv)
  free(value);

void
glGetPathSpacingNV_c(pathListMode, numPaths, pathNameType, paths, pathBase, advanceScale, kerningScale, transformType, returnedSpacing)
  GLenum pathListMode;
  GLsizei numPaths;
  GLenum pathNameType;
  const void *paths;
  GLuint pathBase;
  GLfloat advanceScale;
  GLfloat kerningScale;
  GLenum transformType;
  GLfloat *returnedSpacing;
CODE:
  OGLM_GLEWINIT
  OGLM_CHECK_ERR(glGetPathSpacingNV, )
  OGLM_AVAIL_CHECK(__glewGetPathSpacingNV, glGetPathSpacingNV)
  glGetPathSpacingNV(pathListMode, numPaths, pathNameType, paths, pathBase, advanceScale, kerningScale, transformType, returnedSpacing);
  OGLM_CHECK_ERR(glGetPathSpacingNV, )

void
glGetPathTexGenfvNV_c(texCoordSet, pname, value)
  GLenum texCoordSet;
  GLenum pname;
  GLfloat* value;
CODE:
  OGLM_GLEWINIT
  OGLM_CHECK_ERR(glGetPathTexGenfvNV, )
  OGLM_AVAIL_CHECK(__glewGetPathTexGenfvNV, glGetPathTexGenfvNV)
  glGetPathTexGenfvNV(texCoordSet, pname, value);
  OGLM_CHECK_ERR(glGetPathTexGenfvNV, )

void
glGetPathTexGenivNV_c(texCoordSet, pname, value)
  GLenum texCoordSet;
  GLenum pname;
  GLint* value;
CODE:
  OGLM_GLEWINIT
  OGLM_CHECK_ERR(glGetPathTexGenivNV, )
  OGLM_AVAIL_CHECK(__glewGetPathTexGenivNV, glGetPathTexGenivNV)
  glGetPathTexGenivNV(texCoordSet, pname, value);
  OGLM_CHECK_ERR(glGetPathTexGenivNV, )

void
glGetPerfCounterInfoINTEL_c(queryId, counterId, counterNameLength, counterName, counterDescLength, counterDesc, counterOffset, counterDataSize, counterTypeEnum, counterDataTypeEnum, rawCounterMaxValue)
  GLuint queryId;
  GLuint counterId;
  GLuint counterNameLength;
  GLchar* counterName;
  GLuint counterDescLength;
  GLchar *counterDesc;
  GLuint *counterOffset;
  GLuint *counterDataSize;
  GLuint *counterTypeEnum;
  GLuint *counterDataTypeEnum;
  GLuint64 *rawCounterMaxValue;
CODE:
  OGLM_GLEWINIT
  OGLM_CHECK_ERR(glGetPerfCounterInfoINTEL, )
  OGLM_AVAIL_CHECK(__glewGetPerfCounterInfoINTEL, glGetPerfCounterInfoINTEL)
  glGetPerfCounterInfoINTEL(queryId, counterId, counterNameLength, counterName, counterDescLength, counterDesc, counterOffset, counterDataSize, counterTypeEnum, counterDataTypeEnum, rawCounterMaxValue);
  OGLM_CHECK_ERR(glGetPerfCounterInfoINTEL, )

void
glGetPerfMonitorCounterDataAMD_c(monitor, pname, dataSize, data, bytesWritten)
  GLuint monitor;
  GLenum pname;
  GLsizei dataSize;
  GLuint* data;
  GLint *bytesWritten;
CODE:
  OGLM_GLEWINIT
  OGLM_CHECK_ERR(glGetPerfMonitorCounterDataAMD, )
  OGLM_AVAIL_CHECK(__glewGetPerfMonitorCounterDataAMD, glGetPerfMonitorCounterDataAMD)
  glGetPerfMonitorCounterDataAMD(monitor, pname, dataSize, data, bytesWritten);
  OGLM_CHECK_ERR(glGetPerfMonitorCounterDataAMD, )

void
glGetPerfMonitorCounterDataAMD_p(monitor, pname, dataSize)
  GLuint monitor;
  GLenum pname;
  GLsizei dataSize;
PPCODE:
  OGLM_GLEWINIT
  OGLM_CHECK_ERR(glGetPerfMonitorCounterDataAMD, )
  OGLM_AVAIL_CHECK(__glewGetPerfMonitorCounterDataAMD, glGetPerfMonitorCounterDataAMD)
  GLuint* data = OGLM_ALLOC(dataSize/4,GLuint,data);
  GLint bytesWritten[1];
  glGetPerfMonitorCounterDataAMD(monitor, pname, dataSize, data, bytesWritten);
  OGLM_CHECK_ERR(glGetPerfMonitorCounterDataAMD, free(data);)
  EXTEND(sp, 2);
  OGLM_PUSH_ARRAY(glGetPerfMonitorCounterDataAMD, newSVuv, data, dataSize/4)
  mPUSHs(newSViv(bytesWritten[0]));
  free(data);

void
glGetPerfMonitorCounterInfoAMD_c(group, counter, pname, data)
  GLuint group;
  GLuint counter;
  GLenum pname;
  void *data;
CODE:
  OGLM_GLEWINIT
  OGLM_CHECK_ERR(glGetPerfMonitorCounterInfoAMD, )
  OGLM_AVAIL_CHECK(__glewGetPerfMonitorCounterInfoAMD, glGetPerfMonitorCounterInfoAMD)
  glGetPerfMonitorCounterInfoAMD(group, counter, pname, data);
  OGLM_CHECK_ERR(glGetPerfMonitorCounterInfoAMD, )

void
glGetPerfMonitorCounterStringAMD_c(group, counter, bufSize, length, counterString)
  GLuint group;
  GLuint counter;
  GLsizei bufSize;
  GLsizei* length;
  GLchar *counterString;
CODE:
  OGLM_GLEWINIT
  OGLM_CHECK_ERR(glGetPerfMonitorCounterStringAMD, )
  OGLM_AVAIL_CHECK(__glewGetPerfMonitorCounterStringAMD, glGetPerfMonitorCounterStringAMD)
  glGetPerfMonitorCounterStringAMD(group, counter, bufSize, length, counterString);
  OGLM_CHECK_ERR(glGetPerfMonitorCounterStringAMD, )

void
glGetPerfMonitorCounterStringAMD_p(group, counter, bufSize)
  GLuint group;
  GLuint counter;
  GLsizei bufSize;
PPCODE:
  OGLM_GLEWINIT
  OGLM_CHECK_ERR(glGetPerfMonitorCounterStringAMD, )
  OGLM_AVAIL_CHECK(__glewGetPerfMonitorCounterStringAMD, glGetPerfMonitorCounterStringAMD)
  GLchar counterString[bufSize];
  GLsizei length[1];
  glGetPerfMonitorCounterStringAMD(group, counter, bufSize, length, counterString);
  OGLM_CHECK_ERR(glGetPerfMonitorCounterStringAMD, )
  EXTEND(sp, 2);
  mPUSHs(newSViv(length[0]));
  mPUSHs(newSVpv(counterString,0));

void
glGetPerfMonitorCountersAMD_c(group, numCounters, maxActiveCounters, counterSize, counters)
  GLuint group;
  GLint* numCounters;
  GLint *maxActiveCounters;
  GLsizei counterSize;
  GLuint *counters;
CODE:
  OGLM_GLEWINIT
  OGLM_CHECK_ERR(glGetPerfMonitorCountersAMD, )
  OGLM_AVAIL_CHECK(__glewGetPerfMonitorCountersAMD, glGetPerfMonitorCountersAMD)
  glGetPerfMonitorCountersAMD(group, numCounters, maxActiveCounters, counterSize, counters);
  OGLM_CHECK_ERR(glGetPerfMonitorCountersAMD, )

void
glGetPerfMonitorCountersAMD_p(group, counterSize)
  GLuint group;
  GLsizei counterSize;
PPCODE:
  OGLM_GLEWINIT
  OGLM_CHECK_ERR(glGetPerfMonitorCountersAMD, )
  OGLM_AVAIL_CHECK(__glewGetPerfMonitorCountersAMD, glGetPerfMonitorCountersAMD)
  GLuint *counters = OGLM_ALLOC(counterSize,GLuint,counters);
  GLint maxActiveCounters[1];
  GLint numCounters[1];
  glGetPerfMonitorCountersAMD(group, numCounters, maxActiveCounters, counterSize, counters);
  OGLM_CHECK_ERR(glGetPerfMonitorCountersAMD, free(counters);)
  EXTEND(sp, 3);
  mPUSHs(newSViv(numCounters[0]));
  mPUSHs(newSViv(maxActiveCounters[0]));
  OGLM_PUSH_ARRAY(glGetPerfMonitorCountersAMD, newSVuv, counters, counterSize)
  free(counters);

void
glGetPerfMonitorGroupStringAMD_c(group, bufSize, length, groupString)
  GLuint group;
  GLsizei bufSize;
  GLsizei* length;
  GLchar *groupString;
CODE:
  OGLM_GLEWINIT
  OGLM_CHECK_ERR(glGetPerfMonitorGroupStringAMD, )
  OGLM_AVAIL_CHECK(__glewGetPerfMonitorGroupStringAMD, glGetPerfMonitorGroupStringAMD)
  glGetPerfMonitorGroupStringAMD(group, bufSize, length, groupString);
  OGLM_CHECK_ERR(glGetPerfMonitorGroupStringAMD, )

void
glGetPerfMonitorGroupStringAMD_p(group, bufSize)
  GLuint group;
  GLsizei bufSize;
PPCODE:
  OGLM_GLEWINIT
  OGLM_CHECK_ERR(glGetPerfMonitorGroupStringAMD, )
  OGLM_AVAIL_CHECK(__glewGetPerfMonitorGroupStringAMD, glGetPerfMonitorGroupStringAMD)
  GLchar groupString[bufSize];
  GLsizei length[1];
  glGetPerfMonitorGroupStringAMD(group, bufSize, length, groupString);
  OGLM_CHECK_ERR(glGetPerfMonitorGroupStringAMD, )
  EXTEND(sp, 2);
  mPUSHs(newSViv(length[0]));
  mPUSHs(newSVpv(groupString,0));

void
glGetPerfMonitorGroupsAMD_c(numGroups, groupsSize, groups)
  GLint* numGroups;
  GLsizei groupsSize;
  GLuint *groups;
CODE:
  OGLM_GLEWINIT
  OGLM_CHECK_ERR(glGetPerfMonitorGroupsAMD, )
  OGLM_AVAIL_CHECK(__glewGetPerfMonitorGroupsAMD, glGetPerfMonitorGroupsAMD)
  glGetPerfMonitorGroupsAMD(numGroups, groupsSize, groups);
  OGLM_CHECK_ERR(glGetPerfMonitorGroupsAMD, )

void
glGetPerfMonitorGroupsAMD_p(groupsSize)
  GLsizei groupsSize;
PPCODE:
  OGLM_GLEWINIT
  OGLM_CHECK_ERR(glGetPerfMonitorGroupsAMD, )
  OGLM_AVAIL_CHECK(__glewGetPerfMonitorGroupsAMD, glGetPerfMonitorGroupsAMD)
  GLuint *groups = OGLM_ALLOC(groupsSize,GLuint,groups);
  GLint numGroups[1];
  glGetPerfMonitorGroupsAMD(numGroups, groupsSize, groups);
  OGLM_CHECK_ERR(glGetPerfMonitorGroupsAMD, free(groups);)
  EXTEND(sp, 2);
  mPUSHs(newSViv(numGroups[0]));
  OGLM_PUSH_ARRAY(glGetPerfMonitorGroupsAMD, newSVuv, groups, groupsSize)
  free(groups);

void
glGetPerfQueryDataINTEL_c(queryHandle, flags, dataSize, data, bytesWritten)
  GLuint queryHandle;
  GLuint flags;
  GLsizei dataSize;
  void *data;
  GLuint *bytesWritten;
CODE:
  OGLM_GLEWINIT
  OGLM_CHECK_ERR(glGetPerfQueryDataINTEL, )
  OGLM_AVAIL_CHECK(__glewGetPerfQueryDataINTEL, glGetPerfQueryDataINTEL)
  glGetPerfQueryDataINTEL(queryHandle, flags, dataSize, data, bytesWritten);
  OGLM_CHECK_ERR(glGetPerfQueryDataINTEL, )

void
glGetPerfQueryIdByNameINTEL_c(queryName, queryId)
  GLchar* queryName;
  GLuint *queryId;
CODE:
  OGLM_GLEWINIT
  OGLM_CHECK_ERR(glGetPerfQueryIdByNameINTEL, )
  OGLM_AVAIL_CHECK(__glewGetPerfQueryIdByNameINTEL, glGetPerfQueryIdByNameINTEL)
  glGetPerfQueryIdByNameINTEL(queryName, queryId);
  OGLM_CHECK_ERR(glGetPerfQueryIdByNameINTEL, )

void
glGetPerfQueryInfoINTEL_c(queryId, queryNameLength, queryName, dataSize, noCounters, noInstances, capsMask)
  GLuint queryId;
  GLuint queryNameLength;
  GLchar* queryName;
  GLuint *dataSize;
  GLuint *noCounters;
  GLuint *noInstances;
  GLuint *capsMask;
CODE:
  OGLM_GLEWINIT
  OGLM_CHECK_ERR(glGetPerfQueryInfoINTEL, )
  OGLM_AVAIL_CHECK(__glewGetPerfQueryInfoINTEL, glGetPerfQueryInfoINTEL)
  glGetPerfQueryInfoINTEL(queryId, queryNameLength, queryName, dataSize, noCounters, noInstances, capsMask);
  OGLM_CHECK_ERR(glGetPerfQueryInfoINTEL, )

void
glGetPixelMapfv_c(map, values)
  GLenum map;
  GLfloat *values;
CODE:
  OGLM_GLEWINIT
  OGLM_CHECK_ERR(glGetPixelMapfv, )
  glGetPixelMapfv(map, values);
  OGLM_CHECK_ERR(glGetPixelMapfv, )

void
glGetPixelMapuiv_c(map, values)
  GLenum map;
  GLuint *values;
CODE:
  OGLM_GLEWINIT
  OGLM_CHECK_ERR(glGetPixelMapuiv, )
  glGetPixelMapuiv(map, values);
  OGLM_CHECK_ERR(glGetPixelMapuiv, )

void
glGetPixelMapusv_c(map, values)
  GLenum map;
  GLushort *values;
CODE:
  OGLM_GLEWINIT
  OGLM_CHECK_ERR(glGetPixelMapusv, )
  glGetPixelMapusv(map, values);
  OGLM_CHECK_ERR(glGetPixelMapusv, )

void
glGetPixelTransformParameterfvEXT_c(target, pname, params)
  GLenum target;
  GLenum pname;
  const GLfloat* params;
CODE:
  OGLM_GLEWINIT
  OGLM_CHECK_ERR(glGetPixelTransformParameterfvEXT, )
  OGLM_AVAIL_CHECK(__glewGetPixelTransformParameterfvEXT, glGetPixelTransformParameterfvEXT)
  glGetPixelTransformParameterfvEXT(target, pname, params);
  OGLM_CHECK_ERR(glGetPixelTransformParameterfvEXT, )

void
glGetPixelTransformParameterfvSGI_c(target, pname, params)
  GLenum target;
  GLenum pname;
  GLfloat* params;
CODE:
  OGLM_GLEWINIT
  OGLM_CHECK_ERR(glGetPixelTransformParameterfvSGI, )
  OGLM_AVAIL_CHECK(__glewGetPixelTransformParameterfvSGI, glGetPixelTransformParameterfvSGI)
  glGetPixelTransformParameterfvSGI(target, pname, params);
  OGLM_CHECK_ERR(glGetPixelTransformParameterfvSGI, )

void
glGetPixelTransformParameterivEXT_c(target, pname, params)
  GLenum target;
  GLenum pname;
  const GLint* params;
CODE:
  OGLM_GLEWINIT
  OGLM_CHECK_ERR(glGetPixelTransformParameterivEXT, )
  OGLM_AVAIL_CHECK(__glewGetPixelTransformParameterivEXT, glGetPixelTransformParameterivEXT)
  glGetPixelTransformParameterivEXT(target, pname, params);
  OGLM_CHECK_ERR(glGetPixelTransformParameterivEXT, )

void
glGetPixelTransformParameterivSGI_c(target, pname, params)
  GLenum target;
  GLenum pname;
  GLint* params;
CODE:
  OGLM_GLEWINIT
  OGLM_CHECK_ERR(glGetPixelTransformParameterivSGI, )
  OGLM_AVAIL_CHECK(__glewGetPixelTransformParameterivSGI, glGetPixelTransformParameterivSGI)
  glGetPixelTransformParameterivSGI(target, pname, params);
  OGLM_CHECK_ERR(glGetPixelTransformParameterivSGI, )

void
glGetPointerIndexedvEXT_c(target, index, data)
  GLenum target;
  GLuint index;
  void** data;
CODE:
  OGLM_GLEWINIT
  OGLM_CHECK_ERR(glGetPointerIndexedvEXT, )
  OGLM_AVAIL_CHECK(__glewGetPointerIndexedvEXT, glGetPointerIndexedvEXT)
  glGetPointerIndexedvEXT(target, index, data);
  OGLM_CHECK_ERR(glGetPointerIndexedvEXT, )

void
glGetPointeri_vEXT_c(pname, index, params)
  GLenum pname;
  GLuint index;
  void** params;
CODE:
  OGLM_GLEWINIT
  OGLM_CHECK_ERR(glGetPointeri_vEXT, )
  OGLM_AVAIL_CHECK(__glewGetPointeri_vEXT, glGetPointeri_vEXT)
  glGetPointeri_vEXT(pname, index, params);
  OGLM_CHECK_ERR(glGetPointeri_vEXT, )

void
glGetPointerv_c(pname, params)
  GLenum pname;
  void* *params;
ALIAS:
  glGetPointervEXT_c = 1
  glGetPointervKHR_c = 2
CODE:
  OGLM_GLEWINIT
  OGLM_CHECK_ERR(glGetPointerv, )
  glGetPointerv(pname, params);
  OGLM_CHECK_ERR(glGetPointerv, )

void
glGetPolygonStipple_c(mask)
  GLubyte *mask;
CODE:
  OGLM_GLEWINIT
  OGLM_CHECK_ERR(glGetPolygonStipple, )
  glGetPolygonStipple(mask);
  OGLM_CHECK_ERR(glGetPolygonStipple, )

void *
glGetProcAddressREGAL_c(name)
  const GLchar *name;
CODE:
  OGLM_GLEWINIT
  OGLM_CHECK_ERR(glGetProcAddressREGAL, )
  OGLM_AVAIL_CHECK(__glewGetProcAddressREGAL, glGetProcAddressREGAL)
  RETVAL = glGetProcAddressREGAL(name);
  OGLM_CHECK_ERR(glGetProcAddressREGAL, )
OUTPUT:
  RETVAL

void
glGetProgramBinary_c(program, bufSize, length, binaryFormat, binary)
  GLuint program;
  GLsizei bufSize;
  GLsizei* length;
  GLenum *binaryFormat;
  void*binary;
CODE:
  OGLM_GLEWINIT
  OGLM_CHECK_ERR(glGetProgramBinary, )
  OGLM_AVAIL_CHECK(__glewGetProgramBinary, glGetProgramBinary)
  glGetProgramBinary(program, bufSize, length, binaryFormat, binary);
  OGLM_CHECK_ERR(glGetProgramBinary, )

void
glGetProgramBinary_p(program)
  GLuint program;
PPCODE:
  OGLM_GLEWINIT
  OGLM_CHECK_ERR(glGetProgramBinary, )
  OGLM_AVAIL_CHECK(__glewGetProgramBinary, glGetProgramBinary)
  OGLM_AVAIL_CHECK(__glewGetProgramiv, glGetProgramiv)
  GLsizei bufSize;
  glGetProgramiv(program,GL_PROGRAM_BINARY_LENGTH,&bufSize);
  GLsizei* length = NULL;
  char binary[bufSize];
  GLenum binaryFormat[1];
  glGetProgramBinary(program, bufSize, length, binaryFormat, binary);
  OGLM_CHECK_ERR(glGetProgramBinary, )
  EXTEND(sp, 2);
  mPUSHs(newSViv(binaryFormat[0]));
  mPUSHs(newSVpv(binary,bufSize));

void
glGetProgramBinaryOES_c(program, bufSize, length, binaryFormat, binary)
  GLuint program;
  GLsizei bufSize;
  GLsizei* length;
  GLenum *binaryFormat;
  void*binary;
CODE:
  OGLM_GLEWINIT
  OGLM_CHECK_ERR(glGetProgramBinaryOES, )
  OGLM_AVAIL_CHECK(__glewGetProgramBinaryOES, glGetProgramBinaryOES)
  glGetProgramBinaryOES(program, bufSize, length, binaryFormat, binary);
  OGLM_CHECK_ERR(glGetProgramBinaryOES, )

void
glGetProgramEnvParameterdvARB_c(target, index, params)
  GLenum target;
  GLuint index;
  GLdouble* params;
CODE:
  OGLM_GLEWINIT
  OGLM_CHECK_ERR(glGetProgramEnvParameterdvARB, )
  OGLM_AVAIL_CHECK(__glewGetProgramEnvParameterdvARB, glGetProgramEnvParameterdvARB)
  glGetProgramEnvParameterdvARB(target, index, params);
  OGLM_CHECK_ERR(glGetProgramEnvParameterdvARB, )

void
glGetProgramEnvParameterdvARB_p(target, index)
  GLenum target;
  GLuint index;
PPCODE:
  OGLM_GLEWINIT
  OGLM_CHECK_ERR(glGetProgramEnvParameterdvARB, )
  OGLM_AVAIL_CHECK(__glewGetProgramEnvParameterdvARB, glGetProgramEnvParameterdvARB)
  GLdouble* params = OGLM_ALLOC(4,GLdouble,params);
  glGetProgramEnvParameterdvARB(target, index, params);
  OGLM_CHECK_ERR(glGetProgramEnvParameterdvARB, free(params);)
  OGLM_OUT_FINISH(params,4,newSVnv)
  free(params);

void
glGetProgramEnvParameterfvARB_c(target, index, params)
  GLenum target;
  GLuint index;
  GLfloat* params;
CODE:
  OGLM_GLEWINIT
  OGLM_CHECK_ERR(glGetProgramEnvParameterfvARB, )
  OGLM_AVAIL_CHECK(__glewGetProgramEnvParameterfvARB, glGetProgramEnvParameterfvARB)
  glGetProgramEnvParameterfvARB(target, index, params);
  OGLM_CHECK_ERR(glGetProgramEnvParameterfvARB, )

void
glGetProgramEnvParameterfvARB_p(target, index)
  GLenum target;
  GLuint index;
PPCODE:
  OGLM_GLEWINIT
  OGLM_CHECK_ERR(glGetProgramEnvParameterfvARB, )
  OGLM_AVAIL_CHECK(__glewGetProgramEnvParameterfvARB, glGetProgramEnvParameterfvARB)
  GLfloat* params = OGLM_ALLOC(4,GLfloat,params);
  glGetProgramEnvParameterfvARB(target, index, params);
  OGLM_CHECK_ERR(glGetProgramEnvParameterfvARB, free(params);)
  OGLM_OUT_FINISH(params,4,newSVnv)
  free(params);

void
glGetProgramInfoLog_c(program, bufSize, length, infoLog)
  GLuint program;
  GLsizei bufSize;
  GLsizei* length;
  GLchar* infoLog;
CODE:
  OGLM_GLEWINIT
  OGLM_CHECK_ERR(glGetProgramInfoLog, )
  OGLM_AVAIL_CHECK(__glewGetProgramInfoLog, glGetProgramInfoLog)
  glGetProgramInfoLog(program, bufSize, length, infoLog);
  OGLM_CHECK_ERR(glGetProgramInfoLog, )

GLchar* 
glGetProgramInfoLog_p(program)
  GLuint program;
CODE:
  OGLM_GLEWINIT
  OGLM_CHECK_ERR(glGetProgramInfoLog, )
  OGLM_AVAIL_CHECK(__glewGetProgramInfoLog, glGetProgramInfoLog)
  OGLM_AVAIL_CHECK(__glewGetProgramiv, glGetProgramiv)
  GLsizei bufSize;
  glGetProgramiv(program,GL_INFO_LOG_LENGTH,&bufSize);
  GLsizei* length = NULL;
  GLchar infoLog[bufSize];
  glGetProgramInfoLog(program, bufSize, length, infoLog);
  OGLM_CHECK_ERR(glGetProgramInfoLog, )
  RETVAL = infoLog;
OUTPUT:
  RETVAL

void
glGetProgramInterfaceiv_c(program, programInterface, pname, params)
  GLuint program;
  GLenum programInterface;
  GLenum pname;
  GLint* params;
CODE:
  OGLM_GLEWINIT
  OGLM_CHECK_ERR(glGetProgramInterfaceiv, )
  OGLM_AVAIL_CHECK(__glewGetProgramInterfaceiv, glGetProgramInterfaceiv)
  glGetProgramInterfaceiv(program, programInterface, pname, params);
  OGLM_CHECK_ERR(glGetProgramInterfaceiv, )

void
glGetProgramInterfaceiv_p(program, programInterface, pname)
  GLuint program;
  GLenum programInterface;
  GLenum pname;
PPCODE:
  OGLM_GLEWINIT
  OGLM_CHECK_ERR(glGetProgramInterfaceiv, )
  OGLM_AVAIL_CHECK(__glewGetProgramInterfaceiv, glGetProgramInterfaceiv)
  OGLM_SIZE_ENUM(ProgramInterfacePName,pname,1)
  GLint* params = OGLM_ALLOC(pname_count,GLint,params);
  glGetProgramInterfaceiv(program, programInterface, pname, params);
  OGLM_CHECK_ERR(glGetProgramInterfaceiv, free(params);)
  OGLM_OUT_FINISH(params,pname_count,newSViv)
  free(params);

void
glGetProgramLocalParameterdvARB_c(target, index, params)
  GLenum target;
  GLuint index;
  GLdouble* params;
CODE:
  OGLM_GLEWINIT
  OGLM_CHECK_ERR(glGetProgramLocalParameterdvARB, )
  OGLM_AVAIL_CHECK(__glewGetProgramLocalParameterdvARB, glGetProgramLocalParameterdvARB)
  glGetProgramLocalParameterdvARB(target, index, params);
  OGLM_CHECK_ERR(glGetProgramLocalParameterdvARB, )

void
glGetProgramLocalParameterdvARB_p(target, index)
  GLenum target;
  GLuint index;
PPCODE:
  OGLM_GLEWINIT
  OGLM_CHECK_ERR(glGetProgramLocalParameterdvARB, )
  OGLM_AVAIL_CHECK(__glewGetProgramLocalParameterdvARB, glGetProgramLocalParameterdvARB)
  GLdouble* params = OGLM_ALLOC(4,GLdouble,params);
  glGetProgramLocalParameterdvARB(target, index, params);
  OGLM_CHECK_ERR(glGetProgramLocalParameterdvARB, free(params);)
  OGLM_OUT_FINISH(params,4,newSVnv)
  free(params);

void
glGetProgramLocalParameterfvARB_c(target, index, params)
  GLenum target;
  GLuint index;
  GLfloat* params;
CODE:
  OGLM_GLEWINIT
  OGLM_CHECK_ERR(glGetProgramLocalParameterfvARB, )
  OGLM_AVAIL_CHECK(__glewGetProgramLocalParameterfvARB, glGetProgramLocalParameterfvARB)
  glGetProgramLocalParameterfvARB(target, index, params);
  OGLM_CHECK_ERR(glGetProgramLocalParameterfvARB, )

void
glGetProgramLocalParameterfvARB_p(target, index)
  GLenum target;
  GLuint index;
PPCODE:
  OGLM_GLEWINIT
  OGLM_CHECK_ERR(glGetProgramLocalParameterfvARB, )
  OGLM_AVAIL_CHECK(__glewGetProgramLocalParameterfvARB, glGetProgramLocalParameterfvARB)
  GLfloat* params = OGLM_ALLOC(4,GLfloat,params);
  glGetProgramLocalParameterfvARB(target, index, params);
  OGLM_CHECK_ERR(glGetProgramLocalParameterfvARB, free(params);)
  OGLM_OUT_FINISH(params,4,newSVnv)
  free(params);

void
glGetProgramNamedParameterdvNV_c(id, len, name, params)
  GLuint id;
  GLsizei len;
  const GLubyte* name;
  GLdouble *params;
CODE:
  OGLM_GLEWINIT
  OGLM_CHECK_ERR(glGetProgramNamedParameterdvNV, )
  OGLM_AVAIL_CHECK(__glewGetProgramNamedParameterdvNV, glGetProgramNamedParameterdvNV)
  glGetProgramNamedParameterdvNV(id, len, name, params);
  OGLM_CHECK_ERR(glGetProgramNamedParameterdvNV, )

void
glGetProgramNamedParameterdvNV_p(id, len, name)
  GLuint id;
  GLsizei len;
  const GLubyte* name;
PPCODE:
  OGLM_GLEWINIT
  OGLM_CHECK_ERR(glGetProgramNamedParameterdvNV, )
  OGLM_AVAIL_CHECK(__glewGetProgramNamedParameterdvNV, glGetProgramNamedParameterdvNV)
  GLdouble *params = OGLM_ALLOC(4,GLdouble,params);
  glGetProgramNamedParameterdvNV(id, len, name, params);
  OGLM_CHECK_ERR(glGetProgramNamedParameterdvNV, free(params);)
  OGLM_OUT_FINISH(params,4,newSVnv)
  free(params);

void
glGetProgramNamedParameterfvNV_c(id, len, name, params)
  GLuint id;
  GLsizei len;
  const GLubyte* name;
  GLfloat *params;
CODE:
  OGLM_GLEWINIT
  OGLM_CHECK_ERR(glGetProgramNamedParameterfvNV, )
  OGLM_AVAIL_CHECK(__glewGetProgramNamedParameterfvNV, glGetProgramNamedParameterfvNV)
  glGetProgramNamedParameterfvNV(id, len, name, params);
  OGLM_CHECK_ERR(glGetProgramNamedParameterfvNV, )

void
glGetProgramNamedParameterfvNV_p(id, len, name)
  GLuint id;
  GLsizei len;
  const GLubyte* name;
PPCODE:
  OGLM_GLEWINIT
  OGLM_CHECK_ERR(glGetProgramNamedParameterfvNV, )
  OGLM_AVAIL_CHECK(__glewGetProgramNamedParameterfvNV, glGetProgramNamedParameterfvNV)
  GLfloat *params = OGLM_ALLOC(4,GLfloat,params);
  glGetProgramNamedParameterfvNV(id, len, name, params);
  OGLM_CHECK_ERR(glGetProgramNamedParameterfvNV, free(params);)
  OGLM_OUT_FINISH(params,4,newSVnv)
  free(params);

void
glGetProgramParameterdvNV_c(target, index, pname, params)
  GLenum target;
  GLuint index;
  GLenum pname;
  GLdouble* params;
CODE:
  OGLM_GLEWINIT
  OGLM_CHECK_ERR(glGetProgramParameterdvNV, )
  OGLM_AVAIL_CHECK(__glewGetProgramParameterdvNV, glGetProgramParameterdvNV)
  glGetProgramParameterdvNV(target, index, pname, params);
  OGLM_CHECK_ERR(glGetProgramParameterdvNV, )

void
glGetProgramParameterdvNV_p(target, index, pname)
  GLenum target;
  GLuint index;
  GLenum pname;
PPCODE:
  OGLM_GLEWINIT
  OGLM_CHECK_ERR(glGetProgramParameterdvNV, )
  OGLM_AVAIL_CHECK(__glewGetProgramParameterdvNV, glGetProgramParameterdvNV)
  GLdouble* params = OGLM_ALLOC(4,GLdouble,params);
  glGetProgramParameterdvNV(target, index, pname, params);
  OGLM_CHECK_ERR(glGetProgramParameterdvNV, free(params);)
  OGLM_OUT_FINISH(params,4,newSVnv)
  free(params);

void
glGetProgramParameterfvNV_c(target, index, pname, params)
  GLenum target;
  GLuint index;
  GLenum pname;
  GLfloat* params;
CODE:
  OGLM_GLEWINIT
  OGLM_CHECK_ERR(glGetProgramParameterfvNV, )
  OGLM_AVAIL_CHECK(__glewGetProgramParameterfvNV, glGetProgramParameterfvNV)
  glGetProgramParameterfvNV(target, index, pname, params);
  OGLM_CHECK_ERR(glGetProgramParameterfvNV, )

void
glGetProgramParameterfvNV_p(target, index, pname)
  GLenum target;
  GLuint index;
  GLenum pname;
PPCODE:
  OGLM_GLEWINIT
  OGLM_CHECK_ERR(glGetProgramParameterfvNV, )
  OGLM_AVAIL_CHECK(__glewGetProgramParameterfvNV, glGetProgramParameterfvNV)
  GLfloat* params = OGLM_ALLOC(4,GLfloat,params);
  glGetProgramParameterfvNV(target, index, pname, params);
  OGLM_CHECK_ERR(glGetProgramParameterfvNV, free(params);)
  OGLM_OUT_FINISH(params,4,newSVnv)
  free(params);

void
glGetProgramPipelineInfoLog_c(pipeline, bufSize, length, infoLog)
  GLuint pipeline;
  GLsizei bufSize;
  GLsizei* length;
  GLchar *infoLog;
CODE:
  OGLM_GLEWINIT
  OGLM_CHECK_ERR(glGetProgramPipelineInfoLog, )
  OGLM_AVAIL_CHECK(__glewGetProgramPipelineInfoLog, glGetProgramPipelineInfoLog)
  glGetProgramPipelineInfoLog(pipeline, bufSize, length, infoLog);
  OGLM_CHECK_ERR(glGetProgramPipelineInfoLog, )

GLchar *
glGetProgramPipelineInfoLog_p(pipeline)
  GLuint pipeline;
CODE:
  OGLM_GLEWINIT
  OGLM_CHECK_ERR(glGetProgramPipelineInfoLog, )
  OGLM_AVAIL_CHECK(__glewGetProgramPipelineInfoLog, glGetProgramPipelineInfoLog)
  OGLM_AVAIL_CHECK(__glewGetProgramPipelineiv, glGetProgramPipelineiv)
  GLsizei bufSize;
  glGetProgramPipelineiv(pipeline,GL_INFO_LOG_LENGTH,&bufSize);
  GLsizei* length = NULL;
  GLchar infoLog[bufSize];
  glGetProgramPipelineInfoLog(pipeline, bufSize, length, infoLog);
  OGLM_CHECK_ERR(glGetProgramPipelineInfoLog, )
  RETVAL = infoLog;
OUTPUT:
  RETVAL

void
glGetProgramPipelineiv_c(pipeline, pname, params)
  GLuint pipeline;
  GLenum pname;
  GLint* params;
CODE:
  OGLM_GLEWINIT
  OGLM_CHECK_ERR(glGetProgramPipelineiv, )
  OGLM_AVAIL_CHECK(__glewGetProgramPipelineiv, glGetProgramPipelineiv)
  glGetProgramPipelineiv(pipeline, pname, params);
  OGLM_CHECK_ERR(glGetProgramPipelineiv, )

void
glGetProgramPipelineiv_p(pipeline, pname)
  GLuint pipeline;
  GLenum pname;
PPCODE:
  OGLM_GLEWINIT
  OGLM_CHECK_ERR(glGetProgramPipelineiv, )
  OGLM_AVAIL_CHECK(__glewGetProgramPipelineiv, glGetProgramPipelineiv)
  OGLM_SIZE_ENUM(PipelineParameterName,pname,1)
  GLint* params = OGLM_ALLOC(pname_count,GLint,params);
  glGetProgramPipelineiv(pipeline, pname, params);
  OGLM_CHECK_ERR(glGetProgramPipelineiv, free(params);)
  OGLM_OUT_FINISH(params,pname_count,newSViv)
  free(params);

GLuint
glGetProgramResourceIndex(program, programInterface, name)
  GLuint program;
  GLenum programInterface;
  const GLchar* name;
CODE:
  OGLM_GLEWINIT
  OGLM_CHECK_ERR(glGetProgramResourceIndex, )
  OGLM_AVAIL_CHECK(__glewGetProgramResourceIndex, glGetProgramResourceIndex)
  RETVAL = glGetProgramResourceIndex(program, programInterface, name);
  OGLM_CHECK_ERR(glGetProgramResourceIndex, )
OUTPUT:
  RETVAL

GLint
glGetProgramResourceLocation(program, programInterface, name)
  GLuint program;
  GLenum programInterface;
  const GLchar* name;
CODE:
  OGLM_GLEWINIT
  OGLM_CHECK_ERR(glGetProgramResourceLocation, )
  OGLM_AVAIL_CHECK(__glewGetProgramResourceLocation, glGetProgramResourceLocation)
  RETVAL = glGetProgramResourceLocation(program, programInterface, name);
  OGLM_CHECK_ERR(glGetProgramResourceLocation, )
OUTPUT:
  RETVAL

GLint
glGetProgramResourceLocationIndex(program, programInterface, name)
  GLuint program;
  GLenum programInterface;
  const GLchar* name;
CODE:
  OGLM_GLEWINIT
  OGLM_CHECK_ERR(glGetProgramResourceLocationIndex, )
  OGLM_AVAIL_CHECK(__glewGetProgramResourceLocationIndex, glGetProgramResourceLocationIndex)
  RETVAL = glGetProgramResourceLocationIndex(program, programInterface, name);
  OGLM_CHECK_ERR(glGetProgramResourceLocationIndex, )
OUTPUT:
  RETVAL

GLint
glGetProgramResourceLocationIndexEXT(program, programInterface, name)
  GLuint program;
  GLenum programInterface;
  const GLchar* name;
CODE:
  OGLM_GLEWINIT
  OGLM_CHECK_ERR(glGetProgramResourceLocationIndexEXT, )
  OGLM_AVAIL_CHECK(__glewGetProgramResourceLocationIndexEXT, glGetProgramResourceLocationIndexEXT)
  RETVAL = glGetProgramResourceLocationIndexEXT(program, programInterface, name);
  OGLM_CHECK_ERR(glGetProgramResourceLocationIndexEXT, )
OUTPUT:
  RETVAL

void
glGetProgramResourceName_c(program, programInterface, index, bufSize, length, name)
  GLuint program;
  GLenum programInterface;
  GLuint index;
  GLsizei bufSize;
  GLsizei* length;
  GLchar *name;
CODE:
  OGLM_GLEWINIT
  OGLM_CHECK_ERR(glGetProgramResourceName, )
  OGLM_AVAIL_CHECK(__glewGetProgramResourceName, glGetProgramResourceName)
  glGetProgramResourceName(program, programInterface, index, bufSize, length, name);
  OGLM_CHECK_ERR(glGetProgramResourceName, )

GLchar *
glGetProgramResourceName_p(program, programInterface, index)
  GLuint program;
  GLenum programInterface;
  GLuint index;
CODE:
  OGLM_GLEWINIT
  OGLM_CHECK_ERR(glGetProgramResourceName, )
  OGLM_AVAIL_CHECK(__glewGetProgramResourceName, glGetProgramResourceName)
  OGLM_AVAIL_CHECK(__glewGetProgramResourceiv, glGetProgramResourceiv)
  GLsizei bufSize;
  glGetProgramResourceiv(program,programInterface,index,1,&(GLenum){GL_NAME_LENGTH},sizeof(bufSize),NULL,&bufSize);
  GLsizei* length = NULL;
  GLchar name[bufSize];
  glGetProgramResourceName(program, programInterface, index, bufSize, length, name);
  OGLM_CHECK_ERR(glGetProgramResourceName, )
  RETVAL = name;
OUTPUT:
  RETVAL

void
glGetProgramResourcefvNV_c(program, programInterface, index, propCount, props, count, length, params)
  GLuint program;
  GLenum programInterface;
  GLuint index;
  GLsizei propCount;
  const GLenum* props;
  GLsizei count;
  GLsizei *length;
  GLfloat *params;
CODE:
  OGLM_GLEWINIT
  OGLM_CHECK_ERR(glGetProgramResourcefvNV, )
  OGLM_AVAIL_CHECK(__glewGetProgramResourcefvNV, glGetProgramResourcefvNV)
  glGetProgramResourcefvNV(program, programInterface, index, propCount, props, count, length, params);
  OGLM_CHECK_ERR(glGetProgramResourcefvNV, )

void
glGetProgramResourcefvNV_p(program, programInterface, index, propCount, props, count)
  GLuint program;
  GLenum programInterface;
  GLuint index;
  GLsizei propCount;
  const GLenum* props;
  GLsizei count;
PPCODE:
  OGLM_GLEWINIT
  OGLM_CHECK_ERR(glGetProgramResourcefvNV, )
  OGLM_AVAIL_CHECK(__glewGetProgramResourcefvNV, glGetProgramResourcefvNV)
  GLfloat *params = OGLM_ALLOC(count,GLfloat,params);
  GLsizei length[1];
  glGetProgramResourcefvNV(program, programInterface, index, propCount, props, count, length, params);
  OGLM_CHECK_ERR(glGetProgramResourcefvNV, free(params);)
  EXTEND(sp, 2);
  mPUSHs(newSViv(length[0]));
  OGLM_PUSH_ARRAY(glGetProgramResourcefvNV, newSVnv, params, count)
  free(params);

void
glGetProgramResourceiv_c(program, programInterface, index, propCount, props, count, length, params)
  GLuint program;
  GLenum programInterface;
  GLuint index;
  GLsizei propCount;
  const GLenum* props;
  GLsizei count;
  GLsizei *length;
  GLint *params;
CODE:
  OGLM_GLEWINIT
  OGLM_CHECK_ERR(glGetProgramResourceiv, )
  OGLM_AVAIL_CHECK(__glewGetProgramResourceiv, glGetProgramResourceiv)
  glGetProgramResourceiv(program, programInterface, index, propCount, props, count, length, params);
  OGLM_CHECK_ERR(glGetProgramResourceiv, )

void
glGetProgramResourceiv_p(program, programInterface, index, ...)
  GLuint program;
  GLenum programInterface;
  GLuint index;
PPCODE:
  OGLM_GLEWINIT
  OGLM_CHECK_ERR(glGetProgramResourceiv, )
  OGLM_AVAIL_CHECK(__glewGetProgramResourceiv, glGetProgramResourceiv)
  GLsizei propCount = items-3;
  GLsizei count = propCount;
  GLsizei *length = NULL;
  GLint *params = OGLM_ALLOC(count,GLint,params);
  GLenum* props = OGLM_GET_VARARGS(props,3,GLenum,IV,propCount);
  glGetProgramResourceiv((GLuint )program, (GLenum )programInterface, (GLuint )index, (GLsizei )propCount, (const GLenum* )props, (GLsizei )count, (GLsizei *)length, (GLint *)params);
  OGLM_CHECK_ERR(glGetProgramResourceiv, free(params);free(props);)
  OGLM_OUT_FINISH(params,count,newSViv)
  free(params);free(props);

void
glGetProgramStageiv_c(program, shadertype, pname, values)
  GLuint program;
  GLenum shadertype;
  GLenum pname;
  GLint* values;
CODE:
  OGLM_GLEWINIT
  OGLM_CHECK_ERR(glGetProgramStageiv, )
  OGLM_AVAIL_CHECK(__glewGetProgramStageiv, glGetProgramStageiv)
  glGetProgramStageiv(program, shadertype, pname, values);
  OGLM_CHECK_ERR(glGetProgramStageiv, )

GLint
glGetProgramStageiv_p(program, shadertype, pname)
  GLuint program;
  GLenum shadertype;
  GLenum pname;
CODE:
  OGLM_GLEWINIT
  OGLM_CHECK_ERR(glGetProgramStageiv, )
  OGLM_AVAIL_CHECK(__glewGetProgramStageiv, glGetProgramStageiv)
  GLint values[1];
  glGetProgramStageiv(program, shadertype, pname, values);
  OGLM_CHECK_ERR(glGetProgramStageiv, )
  RETVAL = values[0];
OUTPUT:
  RETVAL

void
glGetProgramStringARB_c(target, pname, string)
  GLenum target;
  GLenum pname;
  void *string;
CODE:
  OGLM_GLEWINIT
  OGLM_CHECK_ERR(glGetProgramStringARB, )
  OGLM_AVAIL_CHECK(__glewGetProgramStringARB, glGetProgramStringARB)
  glGetProgramStringARB(target, pname, string);
  OGLM_CHECK_ERR(glGetProgramStringARB, )

void
glGetProgramStringNV_c(id, pname, program)
  GLuint id;
  GLenum pname;
  GLubyte* program;
CODE:
  OGLM_GLEWINIT
  OGLM_CHECK_ERR(glGetProgramStringNV, )
  OGLM_AVAIL_CHECK(__glewGetProgramStringNV, glGetProgramStringNV)
  glGetProgramStringNV(id, pname, program);
  OGLM_CHECK_ERR(glGetProgramStringNV, )

void
glGetProgramiv_c(program, pname, params)
  GLuint program;
  GLenum pname;
  GLint* params;
CODE:
  OGLM_GLEWINIT
  OGLM_CHECK_ERR(glGetProgramiv, )
  OGLM_AVAIL_CHECK(__glewGetProgramiv, glGetProgramiv)
  glGetProgramiv(program, pname, params);
  OGLM_CHECK_ERR(glGetProgramiv, )

void
glGetProgramiv_p(program, pname)
  GLuint program;
  GLenum pname;
PPCODE:
  OGLM_GLEWINIT
  OGLM_CHECK_ERR(glGetProgramiv, )
  OGLM_AVAIL_CHECK(__glewGetProgramiv, glGetProgramiv)
  OGLM_SIZE_ENUM(ProgramPropertyARB,pname,1)
  GLint* params = OGLM_ALLOC(pname_count,GLint,params);
  glGetProgramiv(program, pname, params);
  OGLM_CHECK_ERR(glGetProgramiv, free(params);)
  OGLM_OUT_FINISH(params,pname_count,newSViv)
  free(params);

void
glGetProgramivARB_c(target, pname, params)
  GLenum target;
  GLenum pname;
  GLint* params;
CODE:
  OGLM_GLEWINIT
  OGLM_CHECK_ERR(glGetProgramivARB, )
  OGLM_AVAIL_CHECK(__glewGetProgramivARB, glGetProgramivARB)
  glGetProgramivARB(target, pname, params);
  OGLM_CHECK_ERR(glGetProgramivARB, )

GLint
glGetProgramivARB_p(target, pname)
  GLenum target;
  GLenum pname;
CODE:
  OGLM_GLEWINIT
  OGLM_CHECK_ERR(glGetProgramivARB, )
  OGLM_AVAIL_CHECK(__glewGetProgramivARB, glGetProgramivARB)
  GLint params[1];
  glGetProgramivARB(target, pname, params);
  OGLM_CHECK_ERR(glGetProgramivARB, )
  RETVAL = params[0];
OUTPUT:
  RETVAL

void
glGetProgramivNV_c(id, pname, params)
  GLuint id;
  GLenum pname;
  GLint* params;
CODE:
  OGLM_GLEWINIT
  OGLM_CHECK_ERR(glGetProgramivNV, )
  OGLM_AVAIL_CHECK(__glewGetProgramivNV, glGetProgramivNV)
  glGetProgramivNV(id, pname, params);
  OGLM_CHECK_ERR(glGetProgramivNV, )

void
glGetProgramivNV_p(id, pname)
  GLuint id;
  GLenum pname;
PPCODE:
  OGLM_GLEWINIT
  OGLM_CHECK_ERR(glGetProgramivNV, )
  OGLM_AVAIL_CHECK(__glewGetProgramivNV, glGetProgramivNV)
  GLint* params = OGLM_ALLOC(4,GLint,params);
  glGetProgramivNV(id, pname, params);
  OGLM_CHECK_ERR(glGetProgramivNV, free(params);)
  OGLM_OUT_FINISH(params,4,newSViv)
  free(params);

void
glGetQueryBufferObjecti64v(id, buffer, pname, offset)
  GLuint id;
  GLuint buffer;
  GLenum pname;
  GLintptr offset;
CODE:
  OGLM_GLEWINIT
  OGLM_CHECK_ERR(glGetQueryBufferObjecti64v, )
  OGLM_AVAIL_CHECK(__glewGetQueryBufferObjecti64v, glGetQueryBufferObjecti64v)
  glGetQueryBufferObjecti64v(id, buffer, pname, offset);
  OGLM_CHECK_ERR(glGetQueryBufferObjecti64v, )

void
glGetQueryBufferObjectiv(id, buffer, pname, offset)
  GLuint id;
  GLuint buffer;
  GLenum pname;
  GLintptr offset;
CODE:
  OGLM_GLEWINIT
  OGLM_CHECK_ERR(glGetQueryBufferObjectiv, )
  OGLM_AVAIL_CHECK(__glewGetQueryBufferObjectiv, glGetQueryBufferObjectiv)
  glGetQueryBufferObjectiv(id, buffer, pname, offset);
  OGLM_CHECK_ERR(glGetQueryBufferObjectiv, )

void
glGetQueryBufferObjectui64v(id, buffer, pname, offset)
  GLuint id;
  GLuint buffer;
  GLenum pname;
  GLintptr offset;
CODE:
  OGLM_GLEWINIT
  OGLM_CHECK_ERR(glGetQueryBufferObjectui64v, )
  OGLM_AVAIL_CHECK(__glewGetQueryBufferObjectui64v, glGetQueryBufferObjectui64v)
  glGetQueryBufferObjectui64v(id, buffer, pname, offset);
  OGLM_CHECK_ERR(glGetQueryBufferObjectui64v, )

void
glGetQueryBufferObjectuiv(id, buffer, pname, offset)
  GLuint id;
  GLuint buffer;
  GLenum pname;
  GLintptr offset;
CODE:
  OGLM_GLEWINIT
  OGLM_CHECK_ERR(glGetQueryBufferObjectuiv, )
  OGLM_AVAIL_CHECK(__glewGetQueryBufferObjectuiv, glGetQueryBufferObjectuiv)
  glGetQueryBufferObjectuiv(id, buffer, pname, offset);
  OGLM_CHECK_ERR(glGetQueryBufferObjectuiv, )

void
glGetQueryIndexediv_c(target, index, pname, params)
  GLenum target;
  GLuint index;
  GLenum pname;
  GLint* params;
CODE:
  OGLM_GLEWINIT
  OGLM_CHECK_ERR(glGetQueryIndexediv, )
  OGLM_AVAIL_CHECK(__glewGetQueryIndexediv, glGetQueryIndexediv)
  glGetQueryIndexediv(target, index, pname, params);
  OGLM_CHECK_ERR(glGetQueryIndexediv, )

void
glGetQueryIndexediv_p(target, index, pname)
  GLenum target;
  GLuint index;
  GLenum pname;
PPCODE:
  OGLM_GLEWINIT
  OGLM_CHECK_ERR(glGetQueryIndexediv, )
  OGLM_AVAIL_CHECK(__glewGetQueryIndexediv, glGetQueryIndexediv)
  OGLM_SIZE_ENUM(QueryParameterName,pname,1)
  GLint* params = OGLM_ALLOC(pname_count,GLint,params);
  glGetQueryIndexediv(target, index, pname, params);
  OGLM_CHECK_ERR(glGetQueryIndexediv, free(params);)
  OGLM_OUT_FINISH(params,pname_count,newSViv)
  free(params);

void
glGetQueryObjecti64v_c(id, pname, params)
  GLuint id;
  GLenum pname;
  GLint64* params;
ALIAS:
  glGetQueryObjecti64vEXT_c = 1
CODE:
  OGLM_GLEWINIT
  OGLM_CHECK_ERR(glGetQueryObjecti64v, )
  OGLM_AVAIL_CHECK(__glewGetQueryObjecti64v, glGetQueryObjecti64v)
  glGetQueryObjecti64v(id, pname, params);
  OGLM_CHECK_ERR(glGetQueryObjecti64v, )

void
glGetQueryObjecti64v_p(id, pname)
  GLuint id;
  GLenum pname;
ALIAS:
  glGetQueryObjecti64vEXT_p = 1
PPCODE:
  OGLM_GLEWINIT
  OGLM_CHECK_ERR(glGetQueryObjecti64v, )
  OGLM_AVAIL_CHECK(__glewGetQueryObjecti64v, glGetQueryObjecti64v)
  OGLM_SIZE_ENUM(QueryObjectParameterName,pname,1)
  GLint64* params = OGLM_ALLOC(pname_count,GLint64,params);
  glGetQueryObjecti64v(id, pname, params);
  OGLM_CHECK_ERR(glGetQueryObjecti64v, free(params);)
  OGLM_OUT_FINISH(params,pname_count,newSViv)
  free(params);

void
glGetQueryObjecti64vANGLE_c(id, pname, params)
  GLuint id;
  GLenum pname;
  GLint64* params;
CODE:
  OGLM_GLEWINIT
  OGLM_CHECK_ERR(glGetQueryObjecti64vANGLE, )
  OGLM_AVAIL_CHECK(__glewGetQueryObjecti64vANGLE, glGetQueryObjecti64vANGLE)
  glGetQueryObjecti64vANGLE(id, pname, params);
  OGLM_CHECK_ERR(glGetQueryObjecti64vANGLE, )

void
glGetQueryObjectiv_c(id, pname, params)
  GLuint id;
  GLenum pname;
  GLint* params;
ALIAS:
  glGetQueryObjectivARB_c = 1
  glGetQueryObjectivEXT_c = 2
CODE:
  OGLM_GLEWINIT
  OGLM_CHECK_ERR(glGetQueryObjectiv, )
  OGLM_AVAIL_CHECK(__glewGetQueryObjectiv, glGetQueryObjectiv)
  glGetQueryObjectiv(id, pname, params);
  OGLM_CHECK_ERR(glGetQueryObjectiv, )

void
glGetQueryObjectiv_p(id, pname)
  GLuint id;
  GLenum pname;
ALIAS:
  glGetQueryObjectivARB_p = 1
  glGetQueryObjectivEXT_p = 2
PPCODE:
  OGLM_GLEWINIT
  OGLM_CHECK_ERR(glGetQueryObjectiv, )
  OGLM_AVAIL_CHECK(__glewGetQueryObjectiv, glGetQueryObjectiv)
  OGLM_SIZE_ENUM(QueryObjectParameterName,pname,1)
  GLint* params = OGLM_ALLOC(pname_count,GLint,params);
  glGetQueryObjectiv(id, pname, params);
  OGLM_CHECK_ERR(glGetQueryObjectiv, free(params);)
  OGLM_OUT_FINISH(params,pname_count,newSViv)
  free(params);

void
glGetQueryObjectivANGLE_c(id, pname, params)
  GLuint id;
  GLenum pname;
  GLint* params;
CODE:
  OGLM_GLEWINIT
  OGLM_CHECK_ERR(glGetQueryObjectivANGLE, )
  OGLM_AVAIL_CHECK(__glewGetQueryObjectivANGLE, glGetQueryObjectivANGLE)
  glGetQueryObjectivANGLE(id, pname, params);
  OGLM_CHECK_ERR(glGetQueryObjectivANGLE, )

void
glGetQueryObjectui64v_c(id, pname, params)
  GLuint id;
  GLenum pname;
  GLuint64* params;
ALIAS:
  glGetQueryObjectui64vEXT_c = 1
CODE:
  OGLM_GLEWINIT
  OGLM_CHECK_ERR(glGetQueryObjectui64v, )
  OGLM_AVAIL_CHECK(__glewGetQueryObjectui64v, glGetQueryObjectui64v)
  glGetQueryObjectui64v(id, pname, params);
  OGLM_CHECK_ERR(glGetQueryObjectui64v, )

void
glGetQueryObjectui64v_p(id, pname)
  GLuint id;
  GLenum pname;
ALIAS:
  glGetQueryObjectui64vEXT_p = 1
PPCODE:
  OGLM_GLEWINIT
  OGLM_CHECK_ERR(glGetQueryObjectui64v, )
  OGLM_AVAIL_CHECK(__glewGetQueryObjectui64v, glGetQueryObjectui64v)
  OGLM_SIZE_ENUM(QueryObjectParameterName,pname,1)
  GLuint64* params = OGLM_ALLOC(pname_count,GLuint64,params);
  glGetQueryObjectui64v(id, pname, params);
  OGLM_CHECK_ERR(glGetQueryObjectui64v, free(params);)
  OGLM_OUT_FINISH(params,pname_count,newSVuv)
  free(params);

void
glGetQueryObjectui64vANGLE_c(id, pname, params)
  GLuint id;
  GLenum pname;
  GLuint64* params;
CODE:
  OGLM_GLEWINIT
  OGLM_CHECK_ERR(glGetQueryObjectui64vANGLE, )
  OGLM_AVAIL_CHECK(__glewGetQueryObjectui64vANGLE, glGetQueryObjectui64vANGLE)
  glGetQueryObjectui64vANGLE(id, pname, params);
  OGLM_CHECK_ERR(glGetQueryObjectui64vANGLE, )

void
glGetQueryObjectuiv_c(id, pname, params)
  GLuint id;
  GLenum pname;
  GLuint* params;
ALIAS:
  glGetQueryObjectuivARB_c = 1
CODE:
  OGLM_GLEWINIT
  OGLM_CHECK_ERR(glGetQueryObjectuiv, )
  OGLM_AVAIL_CHECK(__glewGetQueryObjectuiv, glGetQueryObjectuiv)
  glGetQueryObjectuiv(id, pname, params);
  OGLM_CHECK_ERR(glGetQueryObjectuiv, )

void
glGetQueryObjectuiv_p(id, pname)
  GLuint id;
  GLenum pname;
ALIAS:
  glGetQueryObjectuivARB_p = 1
PPCODE:
  OGLM_GLEWINIT
  OGLM_CHECK_ERR(glGetQueryObjectuiv, )
  OGLM_AVAIL_CHECK(__glewGetQueryObjectuiv, glGetQueryObjectuiv)
  OGLM_SIZE_ENUM(QueryObjectParameterName,pname,1)
  GLuint* params = OGLM_ALLOC(pname_count,GLuint,params);
  glGetQueryObjectuiv(id, pname, params);
  OGLM_CHECK_ERR(glGetQueryObjectuiv, free(params);)
  OGLM_OUT_FINISH(params,pname_count,newSVuv)
  free(params);

void
glGetQueryObjectuivANGLE_c(id, pname, params)
  GLuint id;
  GLenum pname;
  GLuint* params;
CODE:
  OGLM_GLEWINIT
  OGLM_CHECK_ERR(glGetQueryObjectuivANGLE, )
  OGLM_AVAIL_CHECK(__glewGetQueryObjectuivANGLE, glGetQueryObjectuivANGLE)
  glGetQueryObjectuivANGLE(id, pname, params);
  OGLM_CHECK_ERR(glGetQueryObjectuivANGLE, )

void
glGetQueryObjectuivEXT_c(id, pname, params)
  GLuint id;
  GLenum pname;
  GLuint* params;
CODE:
  OGLM_GLEWINIT
  OGLM_CHECK_ERR(glGetQueryObjectuivEXT, )
  OGLM_AVAIL_CHECK(__glewGetQueryObjectuivEXT, glGetQueryObjectuivEXT)
  glGetQueryObjectuivEXT(id, pname, params);
  OGLM_CHECK_ERR(glGetQueryObjectuivEXT, )

void
glGetQueryObjectuivEXT_p(id, pname)
  GLuint id;
  GLenum pname;
PPCODE:
  OGLM_GLEWINIT
  OGLM_CHECK_ERR(glGetQueryObjectuivEXT, )
  OGLM_AVAIL_CHECK(__glewGetQueryObjectuivEXT, glGetQueryObjectuivEXT)
  OGLM_SIZE_ENUM(QueryObjectParameterName,pname,1)
  GLuint* params = OGLM_ALLOC(pname_count,GLuint,params);
  glGetQueryObjectuivEXT(id, pname, params);
  OGLM_CHECK_ERR(glGetQueryObjectuivEXT, free(params);)
  OGLM_OUT_FINISH(params,pname_count,newSVuv)
  free(params);

void
glGetQueryiv_c(target, pname, params)
  GLenum target;
  GLenum pname;
  GLint* params;
ALIAS:
  glGetQueryivARB_c = 1
CODE:
  OGLM_GLEWINIT
  OGLM_CHECK_ERR(glGetQueryiv, )
  OGLM_AVAIL_CHECK(__glewGetQueryiv, glGetQueryiv)
  glGetQueryiv(target, pname, params);
  OGLM_CHECK_ERR(glGetQueryiv, )

void
glGetQueryiv_p(target, pname)
  GLenum target;
  GLenum pname;
ALIAS:
  glGetQueryivARB_p = 1
PPCODE:
  OGLM_GLEWINIT
  OGLM_CHECK_ERR(glGetQueryiv, )
  OGLM_AVAIL_CHECK(__glewGetQueryiv, glGetQueryiv)
  OGLM_SIZE_ENUM(QueryParameterName,pname,1)
  GLint* params = OGLM_ALLOC(pname_count,GLint,params);
  glGetQueryiv(target, pname, params);
  OGLM_CHECK_ERR(glGetQueryiv, free(params);)
  OGLM_OUT_FINISH(params,pname_count,newSViv)
  free(params);

void
glGetQueryivANGLE_c(target, pname, params)
  GLenum target;
  GLenum pname;
  GLint* params;
CODE:
  OGLM_GLEWINIT
  OGLM_CHECK_ERR(glGetQueryivANGLE, )
  OGLM_AVAIL_CHECK(__glewGetQueryivANGLE, glGetQueryivANGLE)
  glGetQueryivANGLE(target, pname, params);
  OGLM_CHECK_ERR(glGetQueryivANGLE, )

void
glGetQueryivEXT_c(target, pname, params)
  GLenum target;
  GLenum pname;
  GLint* params;
CODE:
  OGLM_GLEWINIT
  OGLM_CHECK_ERR(glGetQueryivEXT, )
  OGLM_AVAIL_CHECK(__glewGetQueryivEXT, glGetQueryivEXT)
  glGetQueryivEXT(target, pname, params);
  OGLM_CHECK_ERR(glGetQueryivEXT, )

void
glGetQueryivEXT_p(target, pname)
  GLenum target;
  GLenum pname;
PPCODE:
  OGLM_GLEWINIT
  OGLM_CHECK_ERR(glGetQueryivEXT, )
  OGLM_AVAIL_CHECK(__glewGetQueryivEXT, glGetQueryivEXT)
  OGLM_SIZE_ENUM(QueryParameterName,pname,1)
  GLint* params = OGLM_ALLOC(pname_count,GLint,params);
  glGetQueryivEXT(target, pname, params);
  OGLM_CHECK_ERR(glGetQueryivEXT, free(params);)
  OGLM_OUT_FINISH(params,pname_count,newSViv)
  free(params);

void
glGetRenderbufferParameteriv_c(target, pname, params)
  GLenum target;
  GLenum pname;
  GLint* params;
ALIAS:
  glGetRenderbufferParameterivEXT_c = 1
CODE:
  OGLM_GLEWINIT
  OGLM_CHECK_ERR(glGetRenderbufferParameteriv, )
  OGLM_AVAIL_CHECK(__glewGetRenderbufferParameteriv, glGetRenderbufferParameteriv)
  glGetRenderbufferParameteriv(target, pname, params);
  OGLM_CHECK_ERR(glGetRenderbufferParameteriv, )

void
glGetRenderbufferParameteriv_p(target, pname)
  GLenum target;
  GLenum pname;
ALIAS:
  glGetRenderbufferParameterivEXT_p = 1
PPCODE:
  OGLM_GLEWINIT
  OGLM_CHECK_ERR(glGetRenderbufferParameteriv, )
  OGLM_AVAIL_CHECK(__glewGetRenderbufferParameteriv, glGetRenderbufferParameteriv)
  OGLM_SIZE_ENUM(RenderbufferParameterName,pname,1)
  GLint* params = OGLM_ALLOC(pname_count,GLint,params);
  glGetRenderbufferParameteriv(target, pname, params);
  OGLM_CHECK_ERR(glGetRenderbufferParameteriv, free(params);)
  OGLM_OUT_FINISH(params,pname_count,newSViv)
  free(params);

void
glGetRenderbufferParameterivOES_c(target, pname, params)
  GLenum target;
  GLenum pname;
  GLint* params;
CODE:
  OGLM_GLEWINIT
  OGLM_CHECK_ERR(glGetRenderbufferParameterivOES, )
  OGLM_AVAIL_CHECK(__glewGetRenderbufferParameterivOES, glGetRenderbufferParameterivOES)
  glGetRenderbufferParameterivOES(target, pname, params);
  OGLM_CHECK_ERR(glGetRenderbufferParameterivOES, )

void
glGetSamplerParameterIiv_c(sampler, pname, params)
  GLuint sampler;
  GLenum pname;
  GLint* params;
ALIAS:
  glGetSamplerParameterIivEXT_c = 1
CODE:
  OGLM_GLEWINIT
  OGLM_CHECK_ERR(glGetSamplerParameterIiv, )
  OGLM_AVAIL_CHECK(__glewGetSamplerParameterIiv, glGetSamplerParameterIiv)
  glGetSamplerParameterIiv(sampler, pname, params);
  OGLM_CHECK_ERR(glGetSamplerParameterIiv, )

void
glGetSamplerParameterIiv_p(sampler, pname)
  GLuint sampler;
  GLenum pname;
ALIAS:
  glGetSamplerParameterIivEXT_p = 1
PPCODE:
  OGLM_GLEWINIT
  OGLM_CHECK_ERR(glGetSamplerParameterIiv, )
  OGLM_AVAIL_CHECK(__glewGetSamplerParameterIiv, glGetSamplerParameterIiv)
  OGLM_SIZE_ENUM(SamplerParameterI,pname,1)
  GLint* params = OGLM_ALLOC(pname_count,GLint,params);
  glGetSamplerParameterIiv(sampler, pname, params);
  OGLM_CHECK_ERR(glGetSamplerParameterIiv, free(params);)
  OGLM_OUT_FINISH(params,pname_count,newSViv)
  free(params);

void
glGetSamplerParameterIivOES_c(sampler, pname, params)
  GLuint sampler;
  GLenum pname;
  GLint* params;
CODE:
  OGLM_GLEWINIT
  OGLM_CHECK_ERR(glGetSamplerParameterIivOES, )
  OGLM_AVAIL_CHECK(__glewGetSamplerParameterIivOES, glGetSamplerParameterIivOES)
  glGetSamplerParameterIivOES(sampler, pname, params);
  OGLM_CHECK_ERR(glGetSamplerParameterIivOES, )

void
glGetSamplerParameterIuiv_c(sampler, pname, params)
  GLuint sampler;
  GLenum pname;
  GLuint* params;
ALIAS:
  glGetSamplerParameterIuivEXT_c = 1
CODE:
  OGLM_GLEWINIT
  OGLM_CHECK_ERR(glGetSamplerParameterIuiv, )
  OGLM_AVAIL_CHECK(__glewGetSamplerParameterIuiv, glGetSamplerParameterIuiv)
  glGetSamplerParameterIuiv(sampler, pname, params);
  OGLM_CHECK_ERR(glGetSamplerParameterIuiv, )

void
glGetSamplerParameterIuiv_p(sampler, pname)
  GLuint sampler;
  GLenum pname;
ALIAS:
  glGetSamplerParameterIuivEXT_p = 1
PPCODE:
  OGLM_GLEWINIT
  OGLM_CHECK_ERR(glGetSamplerParameterIuiv, )
  OGLM_AVAIL_CHECK(__glewGetSamplerParameterIuiv, glGetSamplerParameterIuiv)
  OGLM_SIZE_ENUM(SamplerParameterI,pname,1)
  GLuint* params = OGLM_ALLOC(pname_count,GLuint,params);
  glGetSamplerParameterIuiv(sampler, pname, params);
  OGLM_CHECK_ERR(glGetSamplerParameterIuiv, free(params);)
  OGLM_OUT_FINISH(params,pname_count,newSVuv)
  free(params);

void
glGetSamplerParameterIuivOES_c(sampler, pname, params)
  GLuint sampler;
  GLenum pname;
  GLuint* params;
CODE:
  OGLM_GLEWINIT
  OGLM_CHECK_ERR(glGetSamplerParameterIuivOES, )
  OGLM_AVAIL_CHECK(__glewGetSamplerParameterIuivOES, glGetSamplerParameterIuivOES)
  glGetSamplerParameterIuivOES(sampler, pname, params);
  OGLM_CHECK_ERR(glGetSamplerParameterIuivOES, )

void
glGetSamplerParameterfv_c(sampler, pname, params)
  GLuint sampler;
  GLenum pname;
  GLfloat* params;
CODE:
  OGLM_GLEWINIT
  OGLM_CHECK_ERR(glGetSamplerParameterfv, )
  OGLM_AVAIL_CHECK(__glewGetSamplerParameterfv, glGetSamplerParameterfv)
  glGetSamplerParameterfv(sampler, pname, params);
  OGLM_CHECK_ERR(glGetSamplerParameterfv, )

void
glGetSamplerParameterfv_p(sampler, pname)
  GLuint sampler;
  GLenum pname;
PPCODE:
  OGLM_GLEWINIT
  OGLM_CHECK_ERR(glGetSamplerParameterfv, )
  OGLM_AVAIL_CHECK(__glewGetSamplerParameterfv, glGetSamplerParameterfv)
  OGLM_SIZE_ENUM(SamplerParameterF,pname,1)
  GLfloat* params = OGLM_ALLOC(pname_count,GLfloat,params);
  glGetSamplerParameterfv(sampler, pname, params);
  OGLM_CHECK_ERR(glGetSamplerParameterfv, free(params);)
  OGLM_OUT_FINISH(params,pname_count,newSVnv)
  free(params);

void
glGetSamplerParameteriv_c(sampler, pname, params)
  GLuint sampler;
  GLenum pname;
  GLint* params;
CODE:
  OGLM_GLEWINIT
  OGLM_CHECK_ERR(glGetSamplerParameteriv, )
  OGLM_AVAIL_CHECK(__glewGetSamplerParameteriv, glGetSamplerParameteriv)
  glGetSamplerParameteriv(sampler, pname, params);
  OGLM_CHECK_ERR(glGetSamplerParameteriv, )

void
glGetSamplerParameteriv_p(sampler, pname)
  GLuint sampler;
  GLenum pname;
PPCODE:
  OGLM_GLEWINIT
  OGLM_CHECK_ERR(glGetSamplerParameteriv, )
  OGLM_AVAIL_CHECK(__glewGetSamplerParameteriv, glGetSamplerParameteriv)
  OGLM_SIZE_ENUM(SamplerParameterI,pname,1)
  GLint* params = OGLM_ALLOC(pname_count,GLint,params);
  glGetSamplerParameteriv(sampler, pname, params);
  OGLM_CHECK_ERR(glGetSamplerParameteriv, free(params);)
  OGLM_OUT_FINISH(params,pname_count,newSViv)
  free(params);

void
glGetSemaphoreParameterivNV_c(semaphore, pname, params)
  GLuint semaphore;
  GLenum pname;
  GLint* params;
CODE:
  OGLM_GLEWINIT
  OGLM_CHECK_ERR(glGetSemaphoreParameterivNV, )
  OGLM_AVAIL_CHECK(__glewGetSemaphoreParameterivNV, glGetSemaphoreParameterivNV)
  glGetSemaphoreParameterivNV(semaphore, pname, params);
  OGLM_CHECK_ERR(glGetSemaphoreParameterivNV, )

void
glGetSemaphoreParameterui64vEXT_c(semaphore, pname, params)
  GLuint semaphore;
  GLenum pname;
  GLuint64* params;
CODE:
  OGLM_GLEWINIT
  OGLM_CHECK_ERR(glGetSemaphoreParameterui64vEXT, )
  OGLM_AVAIL_CHECK(__glewGetSemaphoreParameterui64vEXT, glGetSemaphoreParameterui64vEXT)
  glGetSemaphoreParameterui64vEXT(semaphore, pname, params);
  OGLM_CHECK_ERR(glGetSemaphoreParameterui64vEXT, )

void
glGetSeparableFilter_c(target, format, type, row, column, span)
  GLenum target;
  GLenum format;
  GLenum type;
  void *row;
  void *column;
  void *span;
CODE:
  OGLM_GLEWINIT
  OGLM_CHECK_ERR(glGetSeparableFilter, )
  OGLM_AVAIL_CHECK(__glewGetSeparableFilter, glGetSeparableFilter)
  glGetSeparableFilter(target, format, type, row, column, span);
  OGLM_CHECK_ERR(glGetSeparableFilter, )

void
glGetSeparableFilterEXT_c(target, format, type, row, column, span)
  GLenum target;
  GLenum format;
  GLenum type;
  void *row;
  void *column;
  void *span;
CODE:
  OGLM_GLEWINIT
  OGLM_CHECK_ERR(glGetSeparableFilterEXT, )
  OGLM_AVAIL_CHECK(__glewGetSeparableFilterEXT, glGetSeparableFilterEXT)
  glGetSeparableFilterEXT(target, format, type, row, column, span);
  OGLM_CHECK_ERR(glGetSeparableFilterEXT, )

void
glGetShaderInfoLog_c(shader, bufSize, length, infoLog)
  GLuint shader;
  GLsizei bufSize;
  GLsizei* length;
  GLchar* infoLog;
CODE:
  OGLM_GLEWINIT
  OGLM_CHECK_ERR(glGetShaderInfoLog, )
  OGLM_AVAIL_CHECK(__glewGetShaderInfoLog, glGetShaderInfoLog)
  glGetShaderInfoLog(shader, bufSize, length, infoLog);
  OGLM_CHECK_ERR(glGetShaderInfoLog, )

GLchar* 
glGetShaderInfoLog_p(shader)
  GLuint shader;
CODE:
  OGLM_GLEWINIT
  OGLM_CHECK_ERR(glGetShaderInfoLog, )
  OGLM_AVAIL_CHECK(__glewGetShaderInfoLog, glGetShaderInfoLog)
  OGLM_AVAIL_CHECK(__glewGetShaderiv, glGetShaderiv)
  GLsizei bufSize;
  glGetShaderiv(shader,GL_INFO_LOG_LENGTH,&bufSize);
  GLsizei* length = NULL;
  GLchar infoLog[bufSize];
  glGetShaderInfoLog(shader, bufSize, length, infoLog);
  OGLM_CHECK_ERR(glGetShaderInfoLog, )
  RETVAL = infoLog;
OUTPUT:
  RETVAL

void
glGetShaderPrecisionFormat_c(shadertype, precisiontype, range, precision)
  GLenum shadertype;
  GLenum precisiontype;
  GLint* range;
  GLint *precision;
CODE:
  OGLM_GLEWINIT
  OGLM_CHECK_ERR(glGetShaderPrecisionFormat, )
  OGLM_AVAIL_CHECK(__glewGetShaderPrecisionFormat, glGetShaderPrecisionFormat)
  glGetShaderPrecisionFormat(shadertype, precisiontype, range, precision);
  OGLM_CHECK_ERR(glGetShaderPrecisionFormat, )

void
glGetShaderPrecisionFormat_p(shadertype, precisiontype)
  GLenum shadertype;
  GLenum precisiontype;
PPCODE:
  OGLM_GLEWINIT
  OGLM_CHECK_ERR(glGetShaderPrecisionFormat, )
  OGLM_AVAIL_CHECK(__glewGetShaderPrecisionFormat, glGetShaderPrecisionFormat)
  GLint* range = OGLM_ALLOC(2,GLint,range);
  GLint precision[1];
  glGetShaderPrecisionFormat(shadertype, precisiontype, range, precision);
  OGLM_CHECK_ERR(glGetShaderPrecisionFormat, free(range);)
  EXTEND(sp, 2);
  OGLM_PUSH_ARRAY(glGetShaderPrecisionFormat, newSViv, range, 2)
  mPUSHs(newSViv(precision[0]));
  free(range);

void
glGetShaderSource_c(shader, bufSize, length, source)
  GLuint shader;
  GLsizei bufSize;
  GLsizei* length;
  GLchar* source;
CODE:
  OGLM_GLEWINIT
  OGLM_CHECK_ERR(glGetShaderSource, )
  OGLM_AVAIL_CHECK(__glewGetShaderSource, glGetShaderSource)
  glGetShaderSource(shader, bufSize, length, source);
  OGLM_CHECK_ERR(glGetShaderSource, )

GLchar* 
glGetShaderSource_p(shader)
  GLuint shader;
CODE:
  OGLM_GLEWINIT
  OGLM_CHECK_ERR(glGetShaderSource, )
  OGLM_AVAIL_CHECK(__glewGetShaderSource, glGetShaderSource)
  OGLM_AVAIL_CHECK(__glewGetShaderiv, glGetShaderiv)
  GLsizei bufSize;
  glGetShaderiv(shader,GL_SHADER_SOURCE_LENGTH,&bufSize);
  GLsizei* length = NULL;
  GLchar source[bufSize];
  glGetShaderSource(shader, bufSize, length, source);
  OGLM_CHECK_ERR(glGetShaderSource, )
  RETVAL = source;
OUTPUT:
  RETVAL

void
glGetShaderSourceARB_c(shader, bufSize, length, source)
  GLhandleARB shader;
  GLsizei bufSize;
  GLsizei* length;
  GLcharARB *source;
CODE:
  OGLM_GLEWINIT
  OGLM_CHECK_ERR(glGetShaderSourceARB, )
  OGLM_AVAIL_CHECK(__glewGetShaderSourceARB, glGetShaderSourceARB)
  glGetShaderSourceARB(shader, bufSize, length, source);
  OGLM_CHECK_ERR(glGetShaderSourceARB, )

GLcharARB *
glGetShaderSourceARB_p(shader)
  GLhandleARB shader;
CODE:
  OGLM_GLEWINIT
  OGLM_CHECK_ERR(glGetShaderSourceARB, )
  OGLM_AVAIL_CHECK(__glewGetShaderSourceARB, glGetShaderSourceARB)
  OGLM_AVAIL_CHECK(__glewGetShaderiv, glGetShaderiv)
  GLsizei bufSize;
  glGetShaderiv(shader,GL_SHADER_SOURCE_LENGTH,&bufSize);
  GLsizei* length = NULL;
  GLcharARB source[bufSize];
  glGetShaderSourceARB(shader, bufSize, length, source);
  OGLM_CHECK_ERR(glGetShaderSourceARB, )
  RETVAL = source;
OUTPUT:
  RETVAL

void
glGetShaderiv_c(shader, pname, params)
  GLuint shader;
  GLenum pname;
  GLint* params;
CODE:
  OGLM_GLEWINIT
  OGLM_CHECK_ERR(glGetShaderiv, )
  OGLM_AVAIL_CHECK(__glewGetShaderiv, glGetShaderiv)
  glGetShaderiv(shader, pname, params);
  OGLM_CHECK_ERR(glGetShaderiv, )

void
glGetShaderiv_p(shader, pname)
  GLuint shader;
  GLenum pname;
PPCODE:
  OGLM_GLEWINIT
  OGLM_CHECK_ERR(glGetShaderiv, )
  OGLM_AVAIL_CHECK(__glewGetShaderiv, glGetShaderiv)
  OGLM_SIZE_ENUM(ShaderParameterName,pname,1)
  GLint* params = OGLM_ALLOC(pname_count,GLint,params);
  glGetShaderiv(shader, pname, params);
  OGLM_CHECK_ERR(glGetShaderiv, free(params);)
  OGLM_OUT_FINISH(params,pname_count,newSViv)
  free(params);

void
glGetShadingRateImagePaletteNV_c(viewport, entry, rate)
  GLuint viewport;
  GLuint entry;
  GLenum* rate;
CODE:
  OGLM_GLEWINIT
  OGLM_CHECK_ERR(glGetShadingRateImagePaletteNV, )
  OGLM_AVAIL_CHECK(__glewGetShadingRateImagePaletteNV, glGetShadingRateImagePaletteNV)
  glGetShadingRateImagePaletteNV(viewport, entry, rate);
  OGLM_CHECK_ERR(glGetShadingRateImagePaletteNV, )

GLenum
glGetShadingRateImagePaletteNV_p(viewport, entry)
  GLuint viewport;
  GLuint entry;
CODE:
  OGLM_GLEWINIT
  OGLM_CHECK_ERR(glGetShadingRateImagePaletteNV, )
  OGLM_AVAIL_CHECK(__glewGetShadingRateImagePaletteNV, glGetShadingRateImagePaletteNV)
  GLenum rate[1];
  glGetShadingRateImagePaletteNV(viewport, entry, rate);
  OGLM_CHECK_ERR(glGetShadingRateImagePaletteNV, )
  RETVAL = rate[0];
OUTPUT:
  RETVAL

void
glGetShadingRateSampleLocationivNV_c(rate, samples, index, location)
  GLenum rate;
  GLuint samples;
  GLuint index;
  GLint* location;
CODE:
  OGLM_GLEWINIT
  OGLM_CHECK_ERR(glGetShadingRateSampleLocationivNV, )
  OGLM_AVAIL_CHECK(__glewGetShadingRateSampleLocationivNV, glGetShadingRateSampleLocationivNV)
  glGetShadingRateSampleLocationivNV(rate, samples, index, location);
  OGLM_CHECK_ERR(glGetShadingRateSampleLocationivNV, )

void
glGetShadingRateSampleLocationivNV_p(rate, samples, index)
  GLenum rate;
  GLuint samples;
  GLuint index;
PPCODE:
  OGLM_GLEWINIT
  OGLM_CHECK_ERR(glGetShadingRateSampleLocationivNV, )
  OGLM_AVAIL_CHECK(__glewGetShadingRateSampleLocationivNV, glGetShadingRateSampleLocationivNV)
  GLint* location = OGLM_ALLOC(3,GLint,location);
  glGetShadingRateSampleLocationivNV(rate, samples, index, location);
  OGLM_CHECK_ERR(glGetShadingRateSampleLocationivNV, free(location);)
  OGLM_OUT_FINISH(location,3,newSViv)
  free(location);

void
glGetSharpenTexFuncSGIS_c(target, points)
  GLenum target;
  GLfloat* points;
CODE:
  OGLM_GLEWINIT
  OGLM_CHECK_ERR(glGetSharpenTexFuncSGIS, )
  OGLM_AVAIL_CHECK(__glewGetSharpenTexFuncSGIS, glGetSharpenTexFuncSGIS)
  glGetSharpenTexFuncSGIS(target, points);
  OGLM_CHECK_ERR(glGetSharpenTexFuncSGIS, )

void
glGetSharpenTexFuncSGIS_p(target)
  GLenum target;
PPCODE:
  OGLM_GLEWINIT
  OGLM_CHECK_ERR(glGetSharpenTexFuncSGIS, )
  OGLM_AVAIL_CHECK(__glewGetSharpenTexFuncSGIS, glGetSharpenTexFuncSGIS)
  OGLM_SIZE_ENUM(TextureTarget,target,1)
  GLfloat* points = OGLM_ALLOC(target_count,GLfloat,points);
  glGetSharpenTexFuncSGIS(target, points);
  OGLM_CHECK_ERR(glGetSharpenTexFuncSGIS, free(points);)
  OGLM_OUT_FINISH(points,target_count,newSVnv)
  free(points);

GLushort
glGetStageIndexNV(shadertype)
  GLenum shadertype;
CODE:
  OGLM_GLEWINIT
  OGLM_CHECK_ERR(glGetStageIndexNV, )
  OGLM_AVAIL_CHECK(__glewGetStageIndexNV, glGetStageIndexNV)
  RETVAL = glGetStageIndexNV(shadertype);
  OGLM_CHECK_ERR(glGetStageIndexNV, )
OUTPUT:
  RETVAL

const GLubyte *
glGetString(name)
  GLenum name;
CODE:
  OGLM_GLEWINIT
  OGLM_CHECK_ERR(glGetString, )
  RETVAL = glGetString(name);
  OGLM_CHECK_ERR(glGetString, )
OUTPUT:
  RETVAL

GLuint
glGetSubroutineIndex(program, shadertype, name)
  GLuint program;
  GLenum shadertype;
  const GLchar* name;
CODE:
  OGLM_GLEWINIT
  OGLM_CHECK_ERR(glGetSubroutineIndex, )
  OGLM_AVAIL_CHECK(__glewGetSubroutineIndex, glGetSubroutineIndex)
  RETVAL = glGetSubroutineIndex(program, shadertype, name);
  OGLM_CHECK_ERR(glGetSubroutineIndex, )
OUTPUT:
  RETVAL

GLint
glGetSubroutineUniformLocation(program, shadertype, name)
  GLuint program;
  GLenum shadertype;
  const GLchar* name;
CODE:
  OGLM_GLEWINIT
  OGLM_CHECK_ERR(glGetSubroutineUniformLocation, )
  OGLM_AVAIL_CHECK(__glewGetSubroutineUniformLocation, glGetSubroutineUniformLocation)
  RETVAL = glGetSubroutineUniformLocation(program, shadertype, name);
  OGLM_CHECK_ERR(glGetSubroutineUniformLocation, )
OUTPUT:
  RETVAL

void
glGetSynciv_c(sync, pname, count, length, values)
  GLsync sync;
  GLenum pname;
  GLsizei count;
  GLsizei* length;
  GLint *values;
ALIAS:
  glGetSyncivAPPLE_c = 1
CODE:
  OGLM_GLEWINIT
  OGLM_CHECK_ERR(glGetSynciv, )
  OGLM_AVAIL_CHECK(__glewGetSynciv, glGetSynciv)
  glGetSynciv(sync, pname, count, length, values);
  OGLM_CHECK_ERR(glGetSynciv, )

void
glGetSynciv_p(sync, pname)
  GLsync sync;
  GLenum pname;
ALIAS:
  glGetSyncivAPPLE_p = 1
PPCODE:
  OGLM_GLEWINIT
  OGLM_CHECK_ERR(glGetSynciv, )
  OGLM_AVAIL_CHECK(__glewGetSynciv, glGetSynciv)
  GLsizei count = sizeof(GLint);
  GLsizei* length = NULL;
  OGLM_SIZE_ENUM(SyncParameterName,pname,1)
  GLint *values = OGLM_ALLOC(pname_count,GLint,values);
  glGetSynciv(sync, pname, count, length, values);
  OGLM_CHECK_ERR(glGetSynciv, free(values);)
  OGLM_OUT_FINISH(values,pname_count,newSViv)
  free(values);

void
glGetTexBumpParameterfvATI_c(pname, param)
  GLenum pname;
  GLfloat *param;
CODE:
  OGLM_GLEWINIT
  OGLM_CHECK_ERR(glGetTexBumpParameterfvATI, )
  OGLM_AVAIL_CHECK(__glewGetTexBumpParameterfvATI, glGetTexBumpParameterfvATI)
  glGetTexBumpParameterfvATI(pname, param);
  OGLM_CHECK_ERR(glGetTexBumpParameterfvATI, )

void
glGetTexBumpParameterivATI_c(pname, param)
  GLenum pname;
  GLint *param;
CODE:
  OGLM_GLEWINIT
  OGLM_CHECK_ERR(glGetTexBumpParameterivATI, )
  OGLM_AVAIL_CHECK(__glewGetTexBumpParameterivATI, glGetTexBumpParameterivATI)
  glGetTexBumpParameterivATI(pname, param);
  OGLM_CHECK_ERR(glGetTexBumpParameterivATI, )

void
glGetTexEnvfv_c(target, pname, params)
  GLenum target;
  GLenum pname;
  GLfloat *params;
CODE:
  OGLM_GLEWINIT
  OGLM_CHECK_ERR(glGetTexEnvfv, )
  glGetTexEnvfv(target, pname, params);
  OGLM_CHECK_ERR(glGetTexEnvfv, )

void
glGetTexEnvfv_p(target, pname)
  GLenum target;
  GLenum pname;
PPCODE:
  OGLM_GLEWINIT
  OGLM_CHECK_ERR(glGetTexEnvfv, )
  OGLM_SIZE_ENUM(TextureEnvParameter,pname,1)
  GLfloat *params = OGLM_ALLOC(pname_count,GLfloat,params);
  glGetTexEnvfv(target, pname, params);
  OGLM_CHECK_ERR(glGetTexEnvfv, free(params);)
  OGLM_OUT_FINISH(params,pname_count,newSVnv)
  free(params);

void
glGetTexEnviv_c(target, pname, params)
  GLenum target;
  GLenum pname;
  GLint *params;
CODE:
  OGLM_GLEWINIT
  OGLM_CHECK_ERR(glGetTexEnviv, )
  glGetTexEnviv(target, pname, params);
  OGLM_CHECK_ERR(glGetTexEnviv, )

void
glGetTexEnviv_p(target, pname)
  GLenum target;
  GLenum pname;
PPCODE:
  OGLM_GLEWINIT
  OGLM_CHECK_ERR(glGetTexEnviv, )
  OGLM_SIZE_ENUM(TextureEnvParameter,pname,1)
  GLint *params = OGLM_ALLOC(pname_count,GLint,params);
  glGetTexEnviv(target, pname, params);
  OGLM_CHECK_ERR(glGetTexEnviv, free(params);)
  OGLM_OUT_FINISH(params,pname_count,newSViv)
  free(params);

void
glGetTexEnvxv_c(target, pname, params)
  GLenum target;
  GLenum pname;
  GLfixed* params;
CODE:
  OGLM_GLEWINIT
  OGLM_CHECK_ERR(glGetTexEnvxv, )
  OGLM_AVAIL_CHECK(__glewGetTexEnvxv, glGetTexEnvxv)
  glGetTexEnvxv(target, pname, params);
  OGLM_CHECK_ERR(glGetTexEnvxv, )

void
glGetTexEnvxv_p(target, pname)
  GLenum target;
  GLenum pname;
PPCODE:
  OGLM_GLEWINIT
  OGLM_CHECK_ERR(glGetTexEnvxv, )
  OGLM_AVAIL_CHECK(__glewGetTexEnvxv, glGetTexEnvxv)
  OGLM_SIZE_ENUM(TextureEnvParameter,pname,1)
  GLfixed* params = OGLM_ALLOC(pname_count,GLfixed,params);
  glGetTexEnvxv(target, pname, params);
  OGLM_CHECK_ERR(glGetTexEnvxv, free(params);)
  OGLM_OUT_FINISH(params,pname_count,newSViv)
  free(params);

void
glGetTexFilterFuncSGIS_c(target, filter, weights)
  GLenum target;
  GLenum filter;
  GLfloat* weights;
CODE:
  OGLM_GLEWINIT
  OGLM_CHECK_ERR(glGetTexFilterFuncSGIS, )
  OGLM_AVAIL_CHECK(__glewGetTexFilterFuncSGIS, glGetTexFilterFuncSGIS)
  glGetTexFilterFuncSGIS(target, filter, weights);
  OGLM_CHECK_ERR(glGetTexFilterFuncSGIS, )

void
glGetTexGendv_c(coord, pname, params)
  GLenum coord;
  GLenum pname;
  GLdouble *params;
CODE:
  OGLM_GLEWINIT
  OGLM_CHECK_ERR(glGetTexGendv, )
  glGetTexGendv(coord, pname, params);
  OGLM_CHECK_ERR(glGetTexGendv, )

void
glGetTexGendv_p(coord, pname)
  GLenum coord;
  GLenum pname;
PPCODE:
  OGLM_GLEWINIT
  OGLM_CHECK_ERR(glGetTexGendv, )
  OGLM_SIZE_ENUM(TextureGenParameter,pname,1)
  GLdouble *params = OGLM_ALLOC(pname_count,GLdouble,params);
  glGetTexGendv(coord, pname, params);
  OGLM_CHECK_ERR(glGetTexGendv, free(params);)
  OGLM_OUT_FINISH(params,pname_count,newSVnv)
  free(params);

void
glGetTexGenfv_c(coord, pname, params)
  GLenum coord;
  GLenum pname;
  GLfloat *params;
CODE:
  OGLM_GLEWINIT
  OGLM_CHECK_ERR(glGetTexGenfv, )
  glGetTexGenfv(coord, pname, params);
  OGLM_CHECK_ERR(glGetTexGenfv, )

void
glGetTexGenfv_p(coord, pname)
  GLenum coord;
  GLenum pname;
PPCODE:
  OGLM_GLEWINIT
  OGLM_CHECK_ERR(glGetTexGenfv, )
  OGLM_SIZE_ENUM(TextureGenParameter,pname,1)
  GLfloat *params = OGLM_ALLOC(pname_count,GLfloat,params);
  glGetTexGenfv(coord, pname, params);
  OGLM_CHECK_ERR(glGetTexGenfv, free(params);)
  OGLM_OUT_FINISH(params,pname_count,newSVnv)
  free(params);

void
glGetTexGenfvOES_c(coord, pname, params)
  GLenum coord;
  GLenum pname;
  GLfloat* params;
CODE:
  OGLM_GLEWINIT
  OGLM_CHECK_ERR(glGetTexGenfvOES, )
  OGLM_AVAIL_CHECK(__glewGetTexGenfvOES, glGetTexGenfvOES)
  glGetTexGenfvOES(coord, pname, params);
  OGLM_CHECK_ERR(glGetTexGenfvOES, )

void
glGetTexGeniv_c(coord, pname, params)
  GLenum coord;
  GLenum pname;
  GLint *params;
CODE:
  OGLM_GLEWINIT
  OGLM_CHECK_ERR(glGetTexGeniv, )
  glGetTexGeniv(coord, pname, params);
  OGLM_CHECK_ERR(glGetTexGeniv, )

void
glGetTexGeniv_p(coord, pname)
  GLenum coord;
  GLenum pname;
PPCODE:
  OGLM_GLEWINIT
  OGLM_CHECK_ERR(glGetTexGeniv, )
  OGLM_SIZE_ENUM(TextureGenParameter,pname,1)
  GLint *params = OGLM_ALLOC(pname_count,GLint,params);
  glGetTexGeniv(coord, pname, params);
  OGLM_CHECK_ERR(glGetTexGeniv, free(params);)
  OGLM_OUT_FINISH(params,pname_count,newSViv)
  free(params);

void
glGetTexGenivOES_c(coord, pname, params)
  GLenum coord;
  GLenum pname;
  GLint* params;
CODE:
  OGLM_GLEWINIT
  OGLM_CHECK_ERR(glGetTexGenivOES, )
  OGLM_AVAIL_CHECK(__glewGetTexGenivOES, glGetTexGenivOES)
  glGetTexGenivOES(coord, pname, params);
  OGLM_CHECK_ERR(glGetTexGenivOES, )

void
glGetTexGenxvOES_c(coord, pname, params)
  GLenum coord;
  GLenum pname;
  GLfixed* params;
CODE:
  OGLM_GLEWINIT
  OGLM_CHECK_ERR(glGetTexGenxvOES, )
  OGLM_AVAIL_CHECK(__glewGetTexGenxvOES, glGetTexGenxvOES)
  glGetTexGenxvOES(coord, pname, params);
  OGLM_CHECK_ERR(glGetTexGenxvOES, )

void
glGetTexImage_c(target, level, format, type, pixels)
  GLenum target;
  GLint level;
  GLenum format;
  GLenum type;
  void *pixels;
CODE:
  OGLM_GLEWINIT
  OGLM_CHECK_ERR(glGetTexImage, )
  glGetTexImage(target, level, format, type, pixels);
  OGLM_CHECK_ERR(glGetTexImage, )

void
glGetTexLevelParameterfv_c(target, level, pname, params)
  GLenum target;
  GLint level;
  GLenum pname;
  GLfloat *params;
CODE:
  OGLM_GLEWINIT
  OGLM_CHECK_ERR(glGetTexLevelParameterfv, )
  glGetTexLevelParameterfv(target, level, pname, params);
  OGLM_CHECK_ERR(glGetTexLevelParameterfv, )

void
glGetTexLevelParameterfv_p(target, level, pname)
  GLenum target;
  GLint level;
  GLenum pname;
PPCODE:
  OGLM_GLEWINIT
  OGLM_CHECK_ERR(glGetTexLevelParameterfv, )
  OGLM_SIZE_ENUM(GetTextureParameter,pname,1)
  GLfloat *params = OGLM_ALLOC(pname_count,GLfloat,params);
  glGetTexLevelParameterfv(target, level, pname, params);
  OGLM_CHECK_ERR(glGetTexLevelParameterfv, free(params);)
  OGLM_OUT_FINISH(params,pname_count,newSVnv)
  free(params);

void
glGetTexLevelParameteriv_c(target, level, pname, params)
  GLenum target;
  GLint level;
  GLenum pname;
  GLint *params;
CODE:
  OGLM_GLEWINIT
  OGLM_CHECK_ERR(glGetTexLevelParameteriv, )
  glGetTexLevelParameteriv(target, level, pname, params);
  OGLM_CHECK_ERR(glGetTexLevelParameteriv, )

void
glGetTexLevelParameteriv_p(target, level, pname)
  GLenum target;
  GLint level;
  GLenum pname;
PPCODE:
  OGLM_GLEWINIT
  OGLM_CHECK_ERR(glGetTexLevelParameteriv, )
  OGLM_SIZE_ENUM(GetTextureParameter,pname,1)
  GLint *params = OGLM_ALLOC(pname_count,GLint,params);
  glGetTexLevelParameteriv(target, level, pname, params);
  OGLM_CHECK_ERR(glGetTexLevelParameteriv, free(params);)
  OGLM_OUT_FINISH(params,pname_count,newSViv)
  free(params);

void
glGetTexParameterIiv_c(target, pname, params)
  GLenum target;
  GLenum pname;
  GLint* params;
ALIAS:
  glGetTexParameterIivEXT_c = 1
CODE:
  OGLM_GLEWINIT
  OGLM_CHECK_ERR(glGetTexParameterIiv, )
  OGLM_AVAIL_CHECK(__glewGetTexParameterIiv, glGetTexParameterIiv)
  glGetTexParameterIiv(target, pname, params);
  OGLM_CHECK_ERR(glGetTexParameterIiv, )

void
glGetTexParameterIiv_p(target, pname)
  GLenum target;
  GLenum pname;
ALIAS:
  glGetTexParameterIivEXT_p = 1
PPCODE:
  OGLM_GLEWINIT
  OGLM_CHECK_ERR(glGetTexParameterIiv, )
  OGLM_AVAIL_CHECK(__glewGetTexParameterIiv, glGetTexParameterIiv)
  OGLM_SIZE_ENUM(GetTextureParameter,pname,1)
  GLint* params = OGLM_ALLOC(pname_count,GLint,params);
  glGetTexParameterIiv(target, pname, params);
  OGLM_CHECK_ERR(glGetTexParameterIiv, free(params);)
  OGLM_OUT_FINISH(params,pname_count,newSViv)
  free(params);

void
glGetTexParameterIivOES_c(target, pname, params)
  GLenum target;
  GLenum pname;
  GLint* params;
CODE:
  OGLM_GLEWINIT
  OGLM_CHECK_ERR(glGetTexParameterIivOES, )
  OGLM_AVAIL_CHECK(__glewGetTexParameterIivOES, glGetTexParameterIivOES)
  glGetTexParameterIivOES(target, pname, params);
  OGLM_CHECK_ERR(glGetTexParameterIivOES, )

void
glGetTexParameterIuiv_c(target, pname, params)
  GLenum target;
  GLenum pname;
  GLuint* params;
ALIAS:
  glGetTexParameterIuivEXT_c = 1
CODE:
  OGLM_GLEWINIT
  OGLM_CHECK_ERR(glGetTexParameterIuiv, )
  OGLM_AVAIL_CHECK(__glewGetTexParameterIuiv, glGetTexParameterIuiv)
  glGetTexParameterIuiv(target, pname, params);
  OGLM_CHECK_ERR(glGetTexParameterIuiv, )

void
glGetTexParameterIuiv_p(target, pname)
  GLenum target;
  GLenum pname;
ALIAS:
  glGetTexParameterIuivEXT_p = 1
PPCODE:
  OGLM_GLEWINIT
  OGLM_CHECK_ERR(glGetTexParameterIuiv, )
  OGLM_AVAIL_CHECK(__glewGetTexParameterIuiv, glGetTexParameterIuiv)
  OGLM_SIZE_ENUM(GetTextureParameter,pname,1)
  GLuint* params = OGLM_ALLOC(pname_count,GLuint,params);
  glGetTexParameterIuiv(target, pname, params);
  OGLM_CHECK_ERR(glGetTexParameterIuiv, free(params);)
  OGLM_OUT_FINISH(params,pname_count,newSVuv)
  free(params);

void
glGetTexParameterIuivOES_c(target, pname, params)
  GLenum target;
  GLenum pname;
  GLuint* params;
CODE:
  OGLM_GLEWINIT
  OGLM_CHECK_ERR(glGetTexParameterIuivOES, )
  OGLM_AVAIL_CHECK(__glewGetTexParameterIuivOES, glGetTexParameterIuivOES)
  glGetTexParameterIuivOES(target, pname, params);
  OGLM_CHECK_ERR(glGetTexParameterIuivOES, )

void
glGetTexParameterPointervAPPLE_c(target, pname, params)
  GLenum target;
  GLenum pname;
  void **params;
CODE:
  OGLM_GLEWINIT
  OGLM_CHECK_ERR(glGetTexParameterPointervAPPLE, )
  OGLM_AVAIL_CHECK(__glewGetTexParameterPointervAPPLE, glGetTexParameterPointervAPPLE)
  glGetTexParameterPointervAPPLE(target, pname, params);
  OGLM_CHECK_ERR(glGetTexParameterPointervAPPLE, )

void
glGetTexParameterfv_c(target, pname, params)
  GLenum target;
  GLenum pname;
  GLfloat *params;
CODE:
  OGLM_GLEWINIT
  OGLM_CHECK_ERR(glGetTexParameterfv, )
  glGetTexParameterfv(target, pname, params);
  OGLM_CHECK_ERR(glGetTexParameterfv, )

void
glGetTexParameterfv_p(target, pname)
  GLenum target;
  GLenum pname;
PPCODE:
  OGLM_GLEWINIT
  OGLM_CHECK_ERR(glGetTexParameterfv, )
  OGLM_SIZE_ENUM(GetTextureParameter,pname,1)
  GLfloat *params = OGLM_ALLOC(pname_count,GLfloat,params);
  glGetTexParameterfv(target, pname, params);
  OGLM_CHECK_ERR(glGetTexParameterfv, free(params);)
  OGLM_OUT_FINISH(params,pname_count,newSVnv)
  free(params);

void
glGetTexParameteriv_c(target, pname, params)
  GLenum target;
  GLenum pname;
  GLint *params;
CODE:
  OGLM_GLEWINIT
  OGLM_CHECK_ERR(glGetTexParameteriv, )
  glGetTexParameteriv(target, pname, params);
  OGLM_CHECK_ERR(glGetTexParameteriv, )

void
glGetTexParameteriv_p(target, pname)
  GLenum target;
  GLenum pname;
PPCODE:
  OGLM_GLEWINIT
  OGLM_CHECK_ERR(glGetTexParameteriv, )
  OGLM_SIZE_ENUM(GetTextureParameter,pname,1)
  GLint *params = OGLM_ALLOC(pname_count,GLint,params);
  glGetTexParameteriv(target, pname, params);
  OGLM_CHECK_ERR(glGetTexParameteriv, free(params);)
  OGLM_OUT_FINISH(params,pname_count,newSViv)
  free(params);

void
glGetTexParameterxv_c(target, pname, params)
  GLenum target;
  GLenum pname;
  GLfixed* params;
CODE:
  OGLM_GLEWINIT
  OGLM_CHECK_ERR(glGetTexParameterxv, )
  OGLM_AVAIL_CHECK(__glewGetTexParameterxv, glGetTexParameterxv)
  glGetTexParameterxv(target, pname, params);
  OGLM_CHECK_ERR(glGetTexParameterxv, )

void
glGetTexParameterxv_p(target, pname)
  GLenum target;
  GLenum pname;
PPCODE:
  OGLM_GLEWINIT
  OGLM_CHECK_ERR(glGetTexParameterxv, )
  OGLM_AVAIL_CHECK(__glewGetTexParameterxv, glGetTexParameterxv)
  OGLM_SIZE_ENUM(GetTextureParameter,pname,1)
  GLfixed* params = OGLM_ALLOC(pname_count,GLfixed,params);
  glGetTexParameterxv(target, pname, params);
  OGLM_CHECK_ERR(glGetTexParameterxv, free(params);)
  OGLM_OUT_FINISH(params,pname_count,newSViv)
  free(params);

GLuint64
glGetTextureHandleARB(texture)
  GLuint texture;
ALIAS:
  glGetTextureHandleIMG = 1
CODE:
  OGLM_GLEWINIT
  OGLM_CHECK_ERR(glGetTextureHandleARB, )
  OGLM_AVAIL_CHECK(__glewGetTextureHandleARB, glGetTextureHandleARB)
  RETVAL = glGetTextureHandleARB(texture);
  OGLM_CHECK_ERR(glGetTextureHandleARB, )
OUTPUT:
  RETVAL

GLuint64
glGetTextureHandleNV(texture)
  GLuint texture;
CODE:
  OGLM_GLEWINIT
  OGLM_CHECK_ERR(glGetTextureHandleNV, )
  OGLM_AVAIL_CHECK(__glewGetTextureHandleNV, glGetTextureHandleNV)
  RETVAL = glGetTextureHandleNV(texture);
  OGLM_CHECK_ERR(glGetTextureHandleNV, )
OUTPUT:
  RETVAL

void
glGetTextureImage_c(texture, level, format, type, bufSize, pixels)
  GLuint texture;
  GLint level;
  GLenum format;
  GLenum type;
  GLsizei bufSize;
  void *pixels;
CODE:
  OGLM_GLEWINIT
  OGLM_CHECK_ERR(glGetTextureImage, )
  OGLM_AVAIL_CHECK(__glewGetTextureImage, glGetTextureImage)
  glGetTextureImage(texture, level, format, type, bufSize, pixels);
  OGLM_CHECK_ERR(glGetTextureImage, )

void
glGetTextureImageEXT_c(texture, target, level, format, type, pixels)
  GLuint texture;
  GLenum target;
  GLint level;
  GLenum format;
  GLenum type;
  void *pixels;
CODE:
  OGLM_GLEWINIT
  OGLM_CHECK_ERR(glGetTextureImageEXT, )
  OGLM_AVAIL_CHECK(__glewGetTextureImageEXT, glGetTextureImageEXT)
  glGetTextureImageEXT(texture, target, level, format, type, pixels);
  OGLM_CHECK_ERR(glGetTextureImageEXT, )

void
glGetTextureLevelParameterfv_c(texture, level, pname, params)
  GLuint texture;
  GLint level;
  GLenum pname;
  GLfloat* params;
CODE:
  OGLM_GLEWINIT
  OGLM_CHECK_ERR(glGetTextureLevelParameterfv, )
  OGLM_AVAIL_CHECK(__glewGetTextureLevelParameterfv, glGetTextureLevelParameterfv)
  glGetTextureLevelParameterfv(texture, level, pname, params);
  OGLM_CHECK_ERR(glGetTextureLevelParameterfv, )

void
glGetTextureLevelParameterfvEXT_c(texture, target, level, pname, params)
  GLuint texture;
  GLenum target;
  GLint level;
  GLenum pname;
  GLfloat* params;
CODE:
  OGLM_GLEWINIT
  OGLM_CHECK_ERR(glGetTextureLevelParameterfvEXT, )
  OGLM_AVAIL_CHECK(__glewGetTextureLevelParameterfvEXT, glGetTextureLevelParameterfvEXT)
  glGetTextureLevelParameterfvEXT(texture, target, level, pname, params);
  OGLM_CHECK_ERR(glGetTextureLevelParameterfvEXT, )

void
glGetTextureLevelParameterfvEXT_p(texture, target, level, pname)
  GLuint texture;
  GLenum target;
  GLint level;
  GLenum pname;
PPCODE:
  OGLM_GLEWINIT
  OGLM_CHECK_ERR(glGetTextureLevelParameterfvEXT, )
  OGLM_AVAIL_CHECK(__glewGetTextureLevelParameterfvEXT, glGetTextureLevelParameterfvEXT)
  OGLM_SIZE_ENUM(GetTextureParameter,pname,1)
  GLfloat* params = OGLM_ALLOC(pname_count,GLfloat,params);
  glGetTextureLevelParameterfvEXT(texture, target, level, pname, params);
  OGLM_CHECK_ERR(glGetTextureLevelParameterfvEXT, free(params);)
  OGLM_OUT_FINISH(params,pname_count,newSVnv)
  free(params);

void
glGetTextureLevelParameteriv_c(texture, level, pname, params)
  GLuint texture;
  GLint level;
  GLenum pname;
  GLint* params;
CODE:
  OGLM_GLEWINIT
  OGLM_CHECK_ERR(glGetTextureLevelParameteriv, )
  OGLM_AVAIL_CHECK(__glewGetTextureLevelParameteriv, glGetTextureLevelParameteriv)
  glGetTextureLevelParameteriv(texture, level, pname, params);
  OGLM_CHECK_ERR(glGetTextureLevelParameteriv, )

void
glGetTextureLevelParameterivEXT_c(texture, target, level, pname, params)
  GLuint texture;
  GLenum target;
  GLint level;
  GLenum pname;
  GLint* params;
CODE:
  OGLM_GLEWINIT
  OGLM_CHECK_ERR(glGetTextureLevelParameterivEXT, )
  OGLM_AVAIL_CHECK(__glewGetTextureLevelParameterivEXT, glGetTextureLevelParameterivEXT)
  glGetTextureLevelParameterivEXT(texture, target, level, pname, params);
  OGLM_CHECK_ERR(glGetTextureLevelParameterivEXT, )

void
glGetTextureLevelParameterivEXT_p(texture, target, level, pname)
  GLuint texture;
  GLenum target;
  GLint level;
  GLenum pname;
PPCODE:
  OGLM_GLEWINIT
  OGLM_CHECK_ERR(glGetTextureLevelParameterivEXT, )
  OGLM_AVAIL_CHECK(__glewGetTextureLevelParameterivEXT, glGetTextureLevelParameterivEXT)
  OGLM_SIZE_ENUM(GetTextureParameter,pname,1)
  GLint* params = OGLM_ALLOC(pname_count,GLint,params);
  glGetTextureLevelParameterivEXT(texture, target, level, pname, params);
  OGLM_CHECK_ERR(glGetTextureLevelParameterivEXT, free(params);)
  OGLM_OUT_FINISH(params,pname_count,newSViv)
  free(params);

void
glGetTextureParameterIiv_c(texture, pname, params)
  GLuint texture;
  GLenum pname;
  GLint* params;
CODE:
  OGLM_GLEWINIT
  OGLM_CHECK_ERR(glGetTextureParameterIiv, )
  OGLM_AVAIL_CHECK(__glewGetTextureParameterIiv, glGetTextureParameterIiv)
  glGetTextureParameterIiv(texture, pname, params);
  OGLM_CHECK_ERR(glGetTextureParameterIiv, )

void
glGetTextureParameterIivEXT_c(texture, target, pname, params)
  GLuint texture;
  GLenum target;
  GLenum pname;
  GLint* params;
CODE:
  OGLM_GLEWINIT
  OGLM_CHECK_ERR(glGetTextureParameterIivEXT, )
  OGLM_AVAIL_CHECK(__glewGetTextureParameterIivEXT, glGetTextureParameterIivEXT)
  glGetTextureParameterIivEXT(texture, target, pname, params);
  OGLM_CHECK_ERR(glGetTextureParameterIivEXT, )

void
glGetTextureParameterIivEXT_p(texture, target, pname)
  GLuint texture;
  GLenum target;
  GLenum pname;
PPCODE:
  OGLM_GLEWINIT
  OGLM_CHECK_ERR(glGetTextureParameterIivEXT, )
  OGLM_AVAIL_CHECK(__glewGetTextureParameterIivEXT, glGetTextureParameterIivEXT)
  OGLM_SIZE_ENUM(GetTextureParameter,pname,1)
  GLint* params = OGLM_ALLOC(pname_count,GLint,params);
  glGetTextureParameterIivEXT(texture, target, pname, params);
  OGLM_CHECK_ERR(glGetTextureParameterIivEXT, free(params);)
  OGLM_OUT_FINISH(params,pname_count,newSViv)
  free(params);

void
glGetTextureParameterIuiv_c(texture, pname, params)
  GLuint texture;
  GLenum pname;
  GLuint* params;
CODE:
  OGLM_GLEWINIT
  OGLM_CHECK_ERR(glGetTextureParameterIuiv, )
  OGLM_AVAIL_CHECK(__glewGetTextureParameterIuiv, glGetTextureParameterIuiv)
  glGetTextureParameterIuiv(texture, pname, params);
  OGLM_CHECK_ERR(glGetTextureParameterIuiv, )

void
glGetTextureParameterIuivEXT_c(texture, target, pname, params)
  GLuint texture;
  GLenum target;
  GLenum pname;
  GLuint* params;
CODE:
  OGLM_GLEWINIT
  OGLM_CHECK_ERR(glGetTextureParameterIuivEXT, )
  OGLM_AVAIL_CHECK(__glewGetTextureParameterIuivEXT, glGetTextureParameterIuivEXT)
  glGetTextureParameterIuivEXT(texture, target, pname, params);
  OGLM_CHECK_ERR(glGetTextureParameterIuivEXT, )

void
glGetTextureParameterIuivEXT_p(texture, target, pname)
  GLuint texture;
  GLenum target;
  GLenum pname;
PPCODE:
  OGLM_GLEWINIT
  OGLM_CHECK_ERR(glGetTextureParameterIuivEXT, )
  OGLM_AVAIL_CHECK(__glewGetTextureParameterIuivEXT, glGetTextureParameterIuivEXT)
  OGLM_SIZE_ENUM(GetTextureParameter,pname,1)
  GLuint* params = OGLM_ALLOC(pname_count,GLuint,params);
  glGetTextureParameterIuivEXT(texture, target, pname, params);
  OGLM_CHECK_ERR(glGetTextureParameterIuivEXT, free(params);)
  OGLM_OUT_FINISH(params,pname_count,newSVuv)
  free(params);

void
glGetTextureParameterfv_c(texture, pname, params)
  GLuint texture;
  GLenum pname;
  GLfloat* params;
CODE:
  OGLM_GLEWINIT
  OGLM_CHECK_ERR(glGetTextureParameterfv, )
  OGLM_AVAIL_CHECK(__glewGetTextureParameterfv, glGetTextureParameterfv)
  glGetTextureParameterfv(texture, pname, params);
  OGLM_CHECK_ERR(glGetTextureParameterfv, )

void
glGetTextureParameterfvEXT_c(texture, target, pname, params)
  GLuint texture;
  GLenum target;
  GLenum pname;
  GLfloat* params;
CODE:
  OGLM_GLEWINIT
  OGLM_CHECK_ERR(glGetTextureParameterfvEXT, )
  OGLM_AVAIL_CHECK(__glewGetTextureParameterfvEXT, glGetTextureParameterfvEXT)
  glGetTextureParameterfvEXT(texture, target, pname, params);
  OGLM_CHECK_ERR(glGetTextureParameterfvEXT, )

void
glGetTextureParameterfvEXT_p(texture, target, pname)
  GLuint texture;
  GLenum target;
  GLenum pname;
PPCODE:
  OGLM_GLEWINIT
  OGLM_CHECK_ERR(glGetTextureParameterfvEXT, )
  OGLM_AVAIL_CHECK(__glewGetTextureParameterfvEXT, glGetTextureParameterfvEXT)
  OGLM_SIZE_ENUM(GetTextureParameter,pname,1)
  GLfloat* params = OGLM_ALLOC(pname_count,GLfloat,params);
  glGetTextureParameterfvEXT(texture, target, pname, params);
  OGLM_CHECK_ERR(glGetTextureParameterfvEXT, free(params);)
  OGLM_OUT_FINISH(params,pname_count,newSVnv)
  free(params);

void
glGetTextureParameteriv_c(texture, pname, params)
  GLuint texture;
  GLenum pname;
  GLint* params;
CODE:
  OGLM_GLEWINIT
  OGLM_CHECK_ERR(glGetTextureParameteriv, )
  OGLM_AVAIL_CHECK(__glewGetTextureParameteriv, glGetTextureParameteriv)
  glGetTextureParameteriv(texture, pname, params);
  OGLM_CHECK_ERR(glGetTextureParameteriv, )

void
glGetTextureParameterivEXT_c(texture, target, pname, params)
  GLuint texture;
  GLenum target;
  GLenum pname;
  GLint* params;
CODE:
  OGLM_GLEWINIT
  OGLM_CHECK_ERR(glGetTextureParameterivEXT, )
  OGLM_AVAIL_CHECK(__glewGetTextureParameterivEXT, glGetTextureParameterivEXT)
  glGetTextureParameterivEXT(texture, target, pname, params);
  OGLM_CHECK_ERR(glGetTextureParameterivEXT, )

void
glGetTextureParameterivEXT_p(texture, target, pname)
  GLuint texture;
  GLenum target;
  GLenum pname;
PPCODE:
  OGLM_GLEWINIT
  OGLM_CHECK_ERR(glGetTextureParameterivEXT, )
  OGLM_AVAIL_CHECK(__glewGetTextureParameterivEXT, glGetTextureParameterivEXT)
  OGLM_SIZE_ENUM(GetTextureParameter,pname,1)
  GLint* params = OGLM_ALLOC(pname_count,GLint,params);
  glGetTextureParameterivEXT(texture, target, pname, params);
  OGLM_CHECK_ERR(glGetTextureParameterivEXT, free(params);)
  OGLM_OUT_FINISH(params,pname_count,newSViv)
  free(params);

GLuint64
glGetTextureSamplerHandleARB(texture, sampler)
  GLuint texture;
  GLuint sampler;
ALIAS:
  glGetTextureSamplerHandleIMG = 1
CODE:
  OGLM_GLEWINIT
  OGLM_CHECK_ERR(glGetTextureSamplerHandleARB, )
  OGLM_AVAIL_CHECK(__glewGetTextureSamplerHandleARB, glGetTextureSamplerHandleARB)
  RETVAL = glGetTextureSamplerHandleARB(texture, sampler);
  OGLM_CHECK_ERR(glGetTextureSamplerHandleARB, )
OUTPUT:
  RETVAL

GLuint64
glGetTextureSamplerHandleNV(texture, sampler)
  GLuint texture;
  GLuint sampler;
CODE:
  OGLM_GLEWINIT
  OGLM_CHECK_ERR(glGetTextureSamplerHandleNV, )
  OGLM_AVAIL_CHECK(__glewGetTextureSamplerHandleNV, glGetTextureSamplerHandleNV)
  RETVAL = glGetTextureSamplerHandleNV(texture, sampler);
  OGLM_CHECK_ERR(glGetTextureSamplerHandleNV, )
OUTPUT:
  RETVAL

void
glGetTextureSubImage_c(texture, level, xoffset, yoffset, zoffset, width, height, depth, format, type, bufSize, pixels)
  GLuint texture;
  GLint level;
  GLint xoffset;
  GLint yoffset;
  GLint zoffset;
  GLsizei width;
  GLsizei height;
  GLsizei depth;
  GLenum format;
  GLenum type;
  GLsizei bufSize;
  void *pixels;
CODE:
  OGLM_GLEWINIT
  OGLM_CHECK_ERR(glGetTextureSubImage, )
  OGLM_AVAIL_CHECK(__glewGetTextureSubImage, glGetTextureSubImage)
  glGetTextureSubImage(texture, level, xoffset, yoffset, zoffset, width, height, depth, format, type, bufSize, pixels);
  OGLM_CHECK_ERR(glGetTextureSubImage, )

void
glGetTrackMatrixivNV_c(target, address, pname, params)
  GLenum target;
  GLuint address;
  GLenum pname;
  GLint* params;
CODE:
  OGLM_GLEWINIT
  OGLM_CHECK_ERR(glGetTrackMatrixivNV, )
  OGLM_AVAIL_CHECK(__glewGetTrackMatrixivNV, glGetTrackMatrixivNV)
  glGetTrackMatrixivNV(target, address, pname, params);
  OGLM_CHECK_ERR(glGetTrackMatrixivNV, )

GLint
glGetTrackMatrixivNV_p(target, address, pname)
  GLenum target;
  GLuint address;
  GLenum pname;
CODE:
  OGLM_GLEWINIT
  OGLM_CHECK_ERR(glGetTrackMatrixivNV, )
  OGLM_AVAIL_CHECK(__glewGetTrackMatrixivNV, glGetTrackMatrixivNV)
  GLint params[1];
  glGetTrackMatrixivNV(target, address, pname, params);
  OGLM_CHECK_ERR(glGetTrackMatrixivNV, )
  RETVAL = params[0];
OUTPUT:
  RETVAL

void
glGetTransformFeedbackVarying_c(program, index, bufSize, length, size, type, name)
  GLuint program;
  GLuint index;
  GLsizei bufSize;
  GLsizei * length;
  GLsizei * size;
  GLenum * type;
  GLchar * name;
ALIAS:
  glGetTransformFeedbackVaryingEXT_c = 1
CODE:
  OGLM_GLEWINIT
  OGLM_CHECK_ERR(glGetTransformFeedbackVarying, )
  OGLM_AVAIL_CHECK(__glewGetTransformFeedbackVarying, glGetTransformFeedbackVarying)
  glGetTransformFeedbackVarying(program, index, bufSize, length, size, type, name);
  OGLM_CHECK_ERR(glGetTransformFeedbackVarying, )

void
glGetTransformFeedbackVarying_p(program, index)
  GLuint program;
  GLuint index;
ALIAS:
  glGetTransformFeedbackVaryingEXT_p = 1
PPCODE:
  OGLM_GLEWINIT
  OGLM_CHECK_ERR(glGetTransformFeedbackVarying, )
  OGLM_AVAIL_CHECK(__glewGetTransformFeedbackVarying, glGetTransformFeedbackVarying)
  OGLM_AVAIL_CHECK(__glewGetProgramiv, glGetProgramiv)
  GLsizei bufSize;
  glGetProgramiv(program,GL_TRANSFORM_FEEDBACK_VARYING_MAX_LENGTH,&bufSize);
  GLsizei * length = NULL;
  GLchar name[bufSize];
  GLsizei size[1];
  GLenum type[1];
  glGetTransformFeedbackVarying(program, index, bufSize, length, size, type, name);
  OGLM_CHECK_ERR(glGetTransformFeedbackVarying, )
  EXTEND(sp, 3);
  mPUSHs(newSViv(size[0]));
  mPUSHs(newSViv(type[0]));
  mPUSHs(newSVpv(name,0));

void
glGetTransformFeedbackVaryingNV_c(program, index, location)
  GLuint program;
  GLuint index;
  GLint *location;
CODE:
  OGLM_GLEWINIT
  OGLM_CHECK_ERR(glGetTransformFeedbackVaryingNV, )
  OGLM_AVAIL_CHECK(__glewGetTransformFeedbackVaryingNV, glGetTransformFeedbackVaryingNV)
  glGetTransformFeedbackVaryingNV(program, index, location);
  OGLM_CHECK_ERR(glGetTransformFeedbackVaryingNV, )

GLint
glGetTransformFeedbackVaryingNV_p(program, index)
  GLuint program;
  GLuint index;
CODE:
  OGLM_GLEWINIT
  OGLM_CHECK_ERR(glGetTransformFeedbackVaryingNV, )
  OGLM_AVAIL_CHECK(__glewGetTransformFeedbackVaryingNV, glGetTransformFeedbackVaryingNV)
  GLint location[1];
  glGetTransformFeedbackVaryingNV(program, index, location);
  OGLM_CHECK_ERR(glGetTransformFeedbackVaryingNV, )
  RETVAL = location[0];
OUTPUT:
  RETVAL

void
glGetTransformFeedbacki64_v_c(xfb, pname, index, param)
  GLuint xfb;
  GLenum pname;
  GLuint index;
  GLint64* param;
CODE:
  OGLM_GLEWINIT
  OGLM_CHECK_ERR(glGetTransformFeedbacki64_v, )
  OGLM_AVAIL_CHECK(__glewGetTransformFeedbacki64_v, glGetTransformFeedbacki64_v)
  glGetTransformFeedbacki64_v(xfb, pname, index, param);
  OGLM_CHECK_ERR(glGetTransformFeedbacki64_v, )

void
glGetTransformFeedbacki_v_c(xfb, pname, index, param)
  GLuint xfb;
  GLenum pname;
  GLuint index;
  GLint* param;
CODE:
  OGLM_GLEWINIT
  OGLM_CHECK_ERR(glGetTransformFeedbacki_v, )
  OGLM_AVAIL_CHECK(__glewGetTransformFeedbacki_v, glGetTransformFeedbacki_v)
  glGetTransformFeedbacki_v(xfb, pname, index, param);
  OGLM_CHECK_ERR(glGetTransformFeedbacki_v, )

void
glGetTransformFeedbackiv_c(xfb, pname, param)
  GLuint xfb;
  GLenum pname;
  GLint* param;
CODE:
  OGLM_GLEWINIT
  OGLM_CHECK_ERR(glGetTransformFeedbackiv, )
  OGLM_AVAIL_CHECK(__glewGetTransformFeedbackiv, glGetTransformFeedbackiv)
  glGetTransformFeedbackiv(xfb, pname, param);
  OGLM_CHECK_ERR(glGetTransformFeedbackiv, )

void
glGetTranslatedShaderSourceANGLE_c(shader, bufSize, length, source)
  GLuint shader;
  GLsizei bufSize;
  GLsizei* length;
  GLchar* source;
CODE:
  OGLM_GLEWINIT
  OGLM_CHECK_ERR(glGetTranslatedShaderSourceANGLE, )
  OGLM_AVAIL_CHECK(__glewGetTranslatedShaderSourceANGLE, glGetTranslatedShaderSourceANGLE)
  glGetTranslatedShaderSourceANGLE(shader, bufSize, length, source);
  OGLM_CHECK_ERR(glGetTranslatedShaderSourceANGLE, )

void
glGetTranslatedShaderSourceANGLE_p(shader, bufSize)
  GLuint shader;
  GLsizei bufSize;
PPCODE:
  OGLM_GLEWINIT
  OGLM_CHECK_ERR(glGetTranslatedShaderSourceANGLE, )
  OGLM_AVAIL_CHECK(__glewGetTranslatedShaderSourceANGLE, glGetTranslatedShaderSourceANGLE)
  GLsizei length[1];
  GLchar source[bufSize];
  glGetTranslatedShaderSourceANGLE(shader, bufSize, length, source);
  OGLM_CHECK_ERR(glGetTranslatedShaderSourceANGLE, )
  EXTEND(sp, 2);
  mPUSHs(newSViv(length[0]));
  mPUSHs(newSVpv(source,0));

GLuint
glGetUniformBlockIndex(program, uniformBlockName)
  GLuint program;
  const GLchar* uniformBlockName;
CODE:
  OGLM_GLEWINIT
  OGLM_CHECK_ERR(glGetUniformBlockIndex, )
  OGLM_AVAIL_CHECK(__glewGetUniformBlockIndex, glGetUniformBlockIndex)
  RETVAL = glGetUniformBlockIndex(program, uniformBlockName);
  OGLM_CHECK_ERR(glGetUniformBlockIndex, )
OUTPUT:
  RETVAL

GLint
glGetUniformBufferSizeEXT(program, location)
  GLuint program;
  GLint location;
CODE:
  OGLM_GLEWINIT
  OGLM_CHECK_ERR(glGetUniformBufferSizeEXT, )
  OGLM_AVAIL_CHECK(__glewGetUniformBufferSizeEXT, glGetUniformBufferSizeEXT)
  RETVAL = glGetUniformBufferSizeEXT(program, location);
  OGLM_CHECK_ERR(glGetUniformBufferSizeEXT, )
OUTPUT:
  RETVAL

void
glGetUniformIndices_c(program, uniformCount, uniformNames, uniformIndices)
  GLuint program;
  GLsizei uniformCount;
  const GLchar* const * uniformNames;
  GLuint* uniformIndices;
CODE:
  OGLM_GLEWINIT
  OGLM_CHECK_ERR(glGetUniformIndices, )
  OGLM_AVAIL_CHECK(__glewGetUniformIndices, glGetUniformIndices)
  glGetUniformIndices(program, uniformCount, uniformNames, uniformIndices);
  OGLM_CHECK_ERR(glGetUniformIndices, )

void
glGetUniformIndices_p(program, ...)
  GLuint program;
PPCODE:
  OGLM_GLEWINIT
  OGLM_CHECK_ERR(glGetUniformIndices, )
  OGLM_AVAIL_CHECK(__glewGetUniformIndices, glGetUniformIndices)
  GLsizei uniformCount = items-1;
  GLuint* uniformIndices = OGLM_ALLOC(uniformCount,GLuint,uniformIndices);
  GLchar* * uniformNames = OGLM_GET_VARARGS(uniformNames,1,GLchar*,PV_nolen,uniformCount);
  glGetUniformIndices((GLuint )program, (GLsizei )uniformCount, (const GLchar* const * )uniformNames, (GLuint* )uniformIndices);
  OGLM_CHECK_ERR(glGetUniformIndices, free(uniformIndices);free(uniformNames);)
  OGLM_OUT_FINISH(uniformIndices,uniformCount,newSVuv)
  free(uniformIndices);free(uniformNames);

GLint
glGetUniformLocation(program, name)
  GLuint program;
  const GLchar* name;
CODE:
  OGLM_GLEWINIT
  OGLM_CHECK_ERR(glGetUniformLocation, )
  OGLM_AVAIL_CHECK(__glewGetUniformLocation, glGetUniformLocation)
  RETVAL = glGetUniformLocation(program, name);
  OGLM_CHECK_ERR(glGetUniformLocation, )
OUTPUT:
  RETVAL

GLint
glGetUniformLocationARB(programObj, name)
  GLhandleARB programObj;
  const GLcharARB* name;
CODE:
  OGLM_GLEWINIT
  OGLM_CHECK_ERR(glGetUniformLocationARB, )
  OGLM_AVAIL_CHECK(__glewGetUniformLocationARB, glGetUniformLocationARB)
  RETVAL = glGetUniformLocationARB(programObj, name);
  OGLM_CHECK_ERR(glGetUniformLocationARB, )
OUTPUT:
  RETVAL

GLintptr
glGetUniformOffsetEXT(program, location)
  GLuint program;
  GLint location;
CODE:
  OGLM_GLEWINIT
  OGLM_CHECK_ERR(glGetUniformOffsetEXT, )
  OGLM_AVAIL_CHECK(__glewGetUniformOffsetEXT, glGetUniformOffsetEXT)
  RETVAL = glGetUniformOffsetEXT(program, location);
  OGLM_CHECK_ERR(glGetUniformOffsetEXT, )
OUTPUT:
  RETVAL

void
glGetUniformSubroutineuiv_c(shadertype, location, params)
  GLenum shadertype;
  GLint location;
  GLuint* params;
CODE:
  OGLM_GLEWINIT
  OGLM_CHECK_ERR(glGetUniformSubroutineuiv, )
  OGLM_AVAIL_CHECK(__glewGetUniformSubroutineuiv, glGetUniformSubroutineuiv)
  glGetUniformSubroutineuiv(shadertype, location, params);
  OGLM_CHECK_ERR(glGetUniformSubroutineuiv, )

GLuint
glGetUniformSubroutineuiv_p(shadertype, location)
  GLenum shadertype;
  GLint location;
CODE:
  OGLM_GLEWINIT
  OGLM_CHECK_ERR(glGetUniformSubroutineuiv, )
  OGLM_AVAIL_CHECK(__glewGetUniformSubroutineuiv, glGetUniformSubroutineuiv)
  GLuint params[1];
  glGetUniformSubroutineuiv(shadertype, location, params);
  OGLM_CHECK_ERR(glGetUniformSubroutineuiv, )
  RETVAL = params[0];
OUTPUT:
  RETVAL

void
glGetUniformdv_c(program, location, params)
  GLuint program;
  GLint location;
  GLdouble* params;
CODE:
  OGLM_GLEWINIT
  OGLM_CHECK_ERR(glGetUniformdv, )
  OGLM_AVAIL_CHECK(__glewGetUniformdv, glGetUniformdv)
  glGetUniformdv(program, location, params);
  OGLM_CHECK_ERR(glGetUniformdv, )

void
glGetUniformfv_c(program, location, params)
  GLuint program;
  GLint location;
  GLfloat* params;
CODE:
  OGLM_GLEWINIT
  OGLM_CHECK_ERR(glGetUniformfv, )
  OGLM_AVAIL_CHECK(__glewGetUniformfv, glGetUniformfv)
  glGetUniformfv(program, location, params);
  OGLM_CHECK_ERR(glGetUniformfv, )

void
glGetUniformfvARB_c(programObj, location, params)
  GLhandleARB programObj;
  GLint location;
  GLfloat* params;
CODE:
  OGLM_GLEWINIT
  OGLM_CHECK_ERR(glGetUniformfvARB, )
  OGLM_AVAIL_CHECK(__glewGetUniformfvARB, glGetUniformfvARB)
  glGetUniformfvARB(programObj, location, params);
  OGLM_CHECK_ERR(glGetUniformfvARB, )

void
glGetUniformi64vARB_c(program, location, params)
  GLuint program;
  GLint location;
  GLint64* params;
CODE:
  OGLM_GLEWINIT
  OGLM_CHECK_ERR(glGetUniformi64vARB, )
  OGLM_AVAIL_CHECK(__glewGetUniformi64vARB, glGetUniformi64vARB)
  glGetUniformi64vARB(program, location, params);
  OGLM_CHECK_ERR(glGetUniformi64vARB, )

void
glGetUniformi64vNV_c(program, location, params)
  GLuint program;
  GLint location;
  GLint64EXT* params;
CODE:
  OGLM_GLEWINIT
  OGLM_CHECK_ERR(glGetUniformi64vNV, )
  OGLM_AVAIL_CHECK(__glewGetUniformi64vNV, glGetUniformi64vNV)
  glGetUniformi64vNV(program, location, params);
  OGLM_CHECK_ERR(glGetUniformi64vNV, )

void
glGetUniformiv_c(program, location, params)
  GLuint program;
  GLint location;
  GLint* params;
CODE:
  OGLM_GLEWINIT
  OGLM_CHECK_ERR(glGetUniformiv, )
  OGLM_AVAIL_CHECK(__glewGetUniformiv, glGetUniformiv)
  glGetUniformiv(program, location, params);
  OGLM_CHECK_ERR(glGetUniformiv, )

void
glGetUniformivARB_c(programObj, location, params)
  GLhandleARB programObj;
  GLint location;
  GLint* params;
CODE:
  OGLM_GLEWINIT
  OGLM_CHECK_ERR(glGetUniformivARB, )
  OGLM_AVAIL_CHECK(__glewGetUniformivARB, glGetUniformivARB)
  glGetUniformivARB(programObj, location, params);
  OGLM_CHECK_ERR(glGetUniformivARB, )

void
glGetUniformui64vARB_c(program, location, params)
  GLuint program;
  GLint location;
  GLuint64* params;
CODE:
  OGLM_GLEWINIT
  OGLM_CHECK_ERR(glGetUniformui64vARB, )
  OGLM_AVAIL_CHECK(__glewGetUniformui64vARB, glGetUniformui64vARB)
  glGetUniformui64vARB(program, location, params);
  OGLM_CHECK_ERR(glGetUniformui64vARB, )

void
glGetUniformui64vNV_c(program, location, params)
  GLuint program;
  GLint location;
  GLuint64EXT* params;
CODE:
  OGLM_GLEWINIT
  OGLM_CHECK_ERR(glGetUniformui64vNV, )
  OGLM_AVAIL_CHECK(__glewGetUniformui64vNV, glGetUniformui64vNV)
  glGetUniformui64vNV(program, location, params);
  OGLM_CHECK_ERR(glGetUniformui64vNV, )

void
glGetUniformuiv_c(program, location, params)
  GLuint program;
  GLint location;
  GLuint* params;
ALIAS:
  glGetUniformuivEXT_c = 1
CODE:
  OGLM_GLEWINIT
  OGLM_CHECK_ERR(glGetUniformuiv, )
  OGLM_AVAIL_CHECK(__glewGetUniformuiv, glGetUniformuiv)
  glGetUniformuiv(program, location, params);
  OGLM_CHECK_ERR(glGetUniformuiv, )

void
glGetUnsignedBytei_vEXT_c(target, index, data)
  GLenum target;
  GLuint index;
  GLubyte* data;
CODE:
  OGLM_GLEWINIT
  OGLM_CHECK_ERR(glGetUnsignedBytei_vEXT, )
  OGLM_AVAIL_CHECK(__glewGetUnsignedBytei_vEXT, glGetUnsignedBytei_vEXT)
  glGetUnsignedBytei_vEXT(target, index, data);
  OGLM_CHECK_ERR(glGetUnsignedBytei_vEXT, )

void
glGetUnsignedBytevEXT_c(pname, data)
  GLenum pname;
  GLubyte* data;
CODE:
  OGLM_GLEWINIT
  OGLM_CHECK_ERR(glGetUnsignedBytevEXT, )
  OGLM_AVAIL_CHECK(__glewGetUnsignedBytevEXT, glGetUnsignedBytevEXT)
  glGetUnsignedBytevEXT(pname, data);
  OGLM_CHECK_ERR(glGetUnsignedBytevEXT, )

void
glGetUnsignedBytevEXT_p(pname)
  GLenum pname;
PPCODE:
  OGLM_GLEWINIT
  OGLM_CHECK_ERR(glGetUnsignedBytevEXT, )
  OGLM_AVAIL_CHECK(__glewGetUnsignedBytevEXT, glGetUnsignedBytevEXT)
  OGLM_SIZE_ENUM(GetPName,pname,1)
  GLubyte* data = OGLM_ALLOC(pname_count,GLubyte,data);
  glGetUnsignedBytevEXT(pname, data);
  OGLM_CHECK_ERR(glGetUnsignedBytevEXT, free(data);)
  OGLM_OUT_FINISH(data,pname_count,newSVuv)
  free(data);

void
glGetVariantArrayObjectfvATI_c(id, pname, params)
  GLuint id;
  GLenum pname;
  GLfloat* params;
CODE:
  OGLM_GLEWINIT
  OGLM_CHECK_ERR(glGetVariantArrayObjectfvATI, )
  OGLM_AVAIL_CHECK(__glewGetVariantArrayObjectfvATI, glGetVariantArrayObjectfvATI)
  glGetVariantArrayObjectfvATI(id, pname, params);
  OGLM_CHECK_ERR(glGetVariantArrayObjectfvATI, )

GLfloat
glGetVariantArrayObjectfvATI_p(id, pname)
  GLuint id;
  GLenum pname;
CODE:
  OGLM_GLEWINIT
  OGLM_CHECK_ERR(glGetVariantArrayObjectfvATI, )
  OGLM_AVAIL_CHECK(__glewGetVariantArrayObjectfvATI, glGetVariantArrayObjectfvATI)
  GLfloat params[1];
  glGetVariantArrayObjectfvATI(id, pname, params);
  OGLM_CHECK_ERR(glGetVariantArrayObjectfvATI, )
  RETVAL = params[0];
OUTPUT:
  RETVAL

void
glGetVariantArrayObjectivATI_c(id, pname, params)
  GLuint id;
  GLenum pname;
  GLint* params;
CODE:
  OGLM_GLEWINIT
  OGLM_CHECK_ERR(glGetVariantArrayObjectivATI, )
  OGLM_AVAIL_CHECK(__glewGetVariantArrayObjectivATI, glGetVariantArrayObjectivATI)
  glGetVariantArrayObjectivATI(id, pname, params);
  OGLM_CHECK_ERR(glGetVariantArrayObjectivATI, )

GLint
glGetVariantArrayObjectivATI_p(id, pname)
  GLuint id;
  GLenum pname;
CODE:
  OGLM_GLEWINIT
  OGLM_CHECK_ERR(glGetVariantArrayObjectivATI, )
  OGLM_AVAIL_CHECK(__glewGetVariantArrayObjectivATI, glGetVariantArrayObjectivATI)
  GLint params[1];
  glGetVariantArrayObjectivATI(id, pname, params);
  OGLM_CHECK_ERR(glGetVariantArrayObjectivATI, )
  RETVAL = params[0];
OUTPUT:
  RETVAL

void
glGetVariantBooleanvEXT_c(id, value, data)
  GLuint id;
  GLenum value;
  GLboolean *data;
CODE:
  OGLM_GLEWINIT
  OGLM_CHECK_ERR(glGetVariantBooleanvEXT, )
  OGLM_AVAIL_CHECK(__glewGetVariantBooleanvEXT, glGetVariantBooleanvEXT)
  glGetVariantBooleanvEXT(id, value, data);
  OGLM_CHECK_ERR(glGetVariantBooleanvEXT, )

void
glGetVariantFloatvEXT_c(id, value, data)
  GLuint id;
  GLenum value;
  GLfloat *data;
CODE:
  OGLM_GLEWINIT
  OGLM_CHECK_ERR(glGetVariantFloatvEXT, )
  OGLM_AVAIL_CHECK(__glewGetVariantFloatvEXT, glGetVariantFloatvEXT)
  glGetVariantFloatvEXT(id, value, data);
  OGLM_CHECK_ERR(glGetVariantFloatvEXT, )

void
glGetVariantIntegervEXT_c(id, value, data)
  GLuint id;
  GLenum value;
  GLint *data;
CODE:
  OGLM_GLEWINIT
  OGLM_CHECK_ERR(glGetVariantIntegervEXT, )
  OGLM_AVAIL_CHECK(__glewGetVariantIntegervEXT, glGetVariantIntegervEXT)
  glGetVariantIntegervEXT(id, value, data);
  OGLM_CHECK_ERR(glGetVariantIntegervEXT, )

void
glGetVariantPointervEXT_c(id, value, data)
  GLuint id;
  GLenum value;
  void **data;
CODE:
  OGLM_GLEWINIT
  OGLM_CHECK_ERR(glGetVariantPointervEXT, )
  OGLM_AVAIL_CHECK(__glewGetVariantPointervEXT, glGetVariantPointervEXT)
  glGetVariantPointervEXT(id, value, data);
  OGLM_CHECK_ERR(glGetVariantPointervEXT, )

GLint
glGetVaryingLocationNV(program, name)
  GLuint program;
  const GLchar *name;
CODE:
  OGLM_GLEWINIT
  OGLM_CHECK_ERR(glGetVaryingLocationNV, )
  OGLM_AVAIL_CHECK(__glewGetVaryingLocationNV, glGetVaryingLocationNV)
  RETVAL = glGetVaryingLocationNV(program, name);
  OGLM_CHECK_ERR(glGetVaryingLocationNV, )
OUTPUT:
  RETVAL

void
glGetVectorOperationSGIX(operation)
  GLenum operation;
CODE:
  OGLM_GLEWINIT
  OGLM_CHECK_ERR(glGetVectorOperationSGIX, )
  OGLM_AVAIL_CHECK(__glewGetVectorOperationSGIX, glGetVectorOperationSGIX)
  glGetVectorOperationSGIX(operation);
  OGLM_CHECK_ERR(glGetVectorOperationSGIX, )

void
glGetVertexArrayIndexed64iv_c(vaobj, index, pname, param)
  GLuint vaobj;
  GLuint index;
  GLenum pname;
  GLint64* param;
CODE:
  OGLM_GLEWINIT
  OGLM_CHECK_ERR(glGetVertexArrayIndexed64iv, )
  OGLM_AVAIL_CHECK(__glewGetVertexArrayIndexed64iv, glGetVertexArrayIndexed64iv)
  glGetVertexArrayIndexed64iv(vaobj, index, pname, param);
  OGLM_CHECK_ERR(glGetVertexArrayIndexed64iv, )

void
glGetVertexArrayIndexediv_c(vaobj, index, pname, param)
  GLuint vaobj;
  GLuint index;
  GLenum pname;
  GLint* param;
CODE:
  OGLM_GLEWINIT
  OGLM_CHECK_ERR(glGetVertexArrayIndexediv, )
  OGLM_AVAIL_CHECK(__glewGetVertexArrayIndexediv, glGetVertexArrayIndexediv)
  glGetVertexArrayIndexediv(vaobj, index, pname, param);
  OGLM_CHECK_ERR(glGetVertexArrayIndexediv, )

void
glGetVertexArrayIntegeri_vEXT_c(vaobj, index, pname, param)
  GLuint vaobj;
  GLuint index;
  GLenum pname;
  GLint* param;
CODE:
  OGLM_GLEWINIT
  OGLM_CHECK_ERR(glGetVertexArrayIntegeri_vEXT, )
  OGLM_AVAIL_CHECK(__glewGetVertexArrayIntegeri_vEXT, glGetVertexArrayIntegeri_vEXT)
  glGetVertexArrayIntegeri_vEXT(vaobj, index, pname, param);
  OGLM_CHECK_ERR(glGetVertexArrayIntegeri_vEXT, )

void
glGetVertexArrayIntegervEXT_c(vaobj, pname, param)
  GLuint vaobj;
  GLenum pname;
  GLint* param;
CODE:
  OGLM_GLEWINIT
  OGLM_CHECK_ERR(glGetVertexArrayIntegervEXT, )
  OGLM_AVAIL_CHECK(__glewGetVertexArrayIntegervEXT, glGetVertexArrayIntegervEXT)
  glGetVertexArrayIntegervEXT(vaobj, pname, param);
  OGLM_CHECK_ERR(glGetVertexArrayIntegervEXT, )

void
glGetVertexArrayPointeri_vEXT_c(vaobj, index, pname, param)
  GLuint vaobj;
  GLuint index;
  GLenum pname;
  void** param;
CODE:
  OGLM_GLEWINIT
  OGLM_CHECK_ERR(glGetVertexArrayPointeri_vEXT, )
  OGLM_AVAIL_CHECK(__glewGetVertexArrayPointeri_vEXT, glGetVertexArrayPointeri_vEXT)
  glGetVertexArrayPointeri_vEXT(vaobj, index, pname, param);
  OGLM_CHECK_ERR(glGetVertexArrayPointeri_vEXT, )

void
glGetVertexArrayPointervEXT_c(vaobj, pname, param)
  GLuint vaobj;
  GLenum pname;
  void** param;
CODE:
  OGLM_GLEWINIT
  OGLM_CHECK_ERR(glGetVertexArrayPointervEXT, )
  OGLM_AVAIL_CHECK(__glewGetVertexArrayPointervEXT, glGetVertexArrayPointervEXT)
  glGetVertexArrayPointervEXT(vaobj, pname, param);
  OGLM_CHECK_ERR(glGetVertexArrayPointervEXT, )

void
glGetVertexArrayiv_c(vaobj, pname, param)
  GLuint vaobj;
  GLenum pname;
  GLint* param;
CODE:
  OGLM_GLEWINIT
  OGLM_CHECK_ERR(glGetVertexArrayiv, )
  OGLM_AVAIL_CHECK(__glewGetVertexArrayiv, glGetVertexArrayiv)
  glGetVertexArrayiv(vaobj, pname, param);
  OGLM_CHECK_ERR(glGetVertexArrayiv, )

void
glGetVertexAttribArrayObjectfvATI_c(index, pname, params)
  GLuint index;
  GLenum pname;
  GLfloat* params;
CODE:
  OGLM_GLEWINIT
  OGLM_CHECK_ERR(glGetVertexAttribArrayObjectfvATI, )
  OGLM_AVAIL_CHECK(__glewGetVertexAttribArrayObjectfvATI, glGetVertexAttribArrayObjectfvATI)
  glGetVertexAttribArrayObjectfvATI(index, pname, params);
  OGLM_CHECK_ERR(glGetVertexAttribArrayObjectfvATI, )

void
glGetVertexAttribArrayObjectfvATI_p(index, pname)
  GLuint index;
  GLenum pname;
PPCODE:
  OGLM_GLEWINIT
  OGLM_CHECK_ERR(glGetVertexAttribArrayObjectfvATI, )
  OGLM_AVAIL_CHECK(__glewGetVertexAttribArrayObjectfvATI, glGetVertexAttribArrayObjectfvATI)
  OGLM_SIZE_ENUM(ArrayObjectPNameATI,pname,1)
  GLfloat* params = OGLM_ALLOC(pname_count,GLfloat,params);
  glGetVertexAttribArrayObjectfvATI(index, pname, params);
  OGLM_CHECK_ERR(glGetVertexAttribArrayObjectfvATI, free(params);)
  OGLM_OUT_FINISH(params,pname_count,newSVnv)
  free(params);

void
glGetVertexAttribArrayObjectivATI_c(index, pname, params)
  GLuint index;
  GLenum pname;
  GLint* params;
CODE:
  OGLM_GLEWINIT
  OGLM_CHECK_ERR(glGetVertexAttribArrayObjectivATI, )
  OGLM_AVAIL_CHECK(__glewGetVertexAttribArrayObjectivATI, glGetVertexAttribArrayObjectivATI)
  glGetVertexAttribArrayObjectivATI(index, pname, params);
  OGLM_CHECK_ERR(glGetVertexAttribArrayObjectivATI, )

void
glGetVertexAttribArrayObjectivATI_p(index, pname)
  GLuint index;
  GLenum pname;
PPCODE:
  OGLM_GLEWINIT
  OGLM_CHECK_ERR(glGetVertexAttribArrayObjectivATI, )
  OGLM_AVAIL_CHECK(__glewGetVertexAttribArrayObjectivATI, glGetVertexAttribArrayObjectivATI)
  OGLM_SIZE_ENUM(ArrayObjectPNameATI,pname,1)
  GLint* params = OGLM_ALLOC(pname_count,GLint,params);
  glGetVertexAttribArrayObjectivATI(index, pname, params);
  OGLM_CHECK_ERR(glGetVertexAttribArrayObjectivATI, free(params);)
  OGLM_OUT_FINISH(params,pname_count,newSViv)
  free(params);

void
glGetVertexAttribIiv_c(index, pname, params)
  GLuint index;
  GLenum pname;
  GLint* params;
ALIAS:
  glGetVertexAttribIivEXT_c = 1
CODE:
  OGLM_GLEWINIT
  OGLM_CHECK_ERR(glGetVertexAttribIiv, )
  OGLM_AVAIL_CHECK(__glewGetVertexAttribIiv, glGetVertexAttribIiv)
  glGetVertexAttribIiv(index, pname, params);
  OGLM_CHECK_ERR(glGetVertexAttribIiv, )

GLint
glGetVertexAttribIiv_p(index, pname)
  GLuint index;
  GLenum pname;
ALIAS:
  glGetVertexAttribIivEXT_p = 1
CODE:
  OGLM_GLEWINIT
  OGLM_CHECK_ERR(glGetVertexAttribIiv, )
  OGLM_AVAIL_CHECK(__glewGetVertexAttribIiv, glGetVertexAttribIiv)
  GLint params[1];
  glGetVertexAttribIiv(index, pname, params);
  OGLM_CHECK_ERR(glGetVertexAttribIiv, )
  RETVAL = params[0];
OUTPUT:
  RETVAL

void
glGetVertexAttribIuiv_c(index, pname, params)
  GLuint index;
  GLenum pname;
  GLuint* params;
ALIAS:
  glGetVertexAttribIuivEXT_c = 1
CODE:
  OGLM_GLEWINIT
  OGLM_CHECK_ERR(glGetVertexAttribIuiv, )
  OGLM_AVAIL_CHECK(__glewGetVertexAttribIuiv, glGetVertexAttribIuiv)
  glGetVertexAttribIuiv(index, pname, params);
  OGLM_CHECK_ERR(glGetVertexAttribIuiv, )

GLuint
glGetVertexAttribIuiv_p(index, pname)
  GLuint index;
  GLenum pname;
ALIAS:
  glGetVertexAttribIuivEXT_p = 1
CODE:
  OGLM_GLEWINIT
  OGLM_CHECK_ERR(glGetVertexAttribIuiv, )
  OGLM_AVAIL_CHECK(__glewGetVertexAttribIuiv, glGetVertexAttribIuiv)
  GLuint params[1];
  glGetVertexAttribIuiv(index, pname, params);
  OGLM_CHECK_ERR(glGetVertexAttribIuiv, )
  RETVAL = params[0];
OUTPUT:
  RETVAL

void
glGetVertexAttribLdv_c(index, pname, params)
  GLuint index;
  GLenum pname;
  GLdouble* params;
ALIAS:
  glGetVertexAttribLdvEXT_c = 1
CODE:
  OGLM_GLEWINIT
  OGLM_CHECK_ERR(glGetVertexAttribLdv, )
  OGLM_AVAIL_CHECK(__glewGetVertexAttribLdv, glGetVertexAttribLdv)
  glGetVertexAttribLdv(index, pname, params);
  OGLM_CHECK_ERR(glGetVertexAttribLdv, )

void
glGetVertexAttribLdv_p(index, pname)
  GLuint index;
  GLenum pname;
ALIAS:
  glGetVertexAttribLdvEXT_p = 1
PPCODE:
  OGLM_GLEWINIT
  OGLM_CHECK_ERR(glGetVertexAttribLdv, )
  OGLM_AVAIL_CHECK(__glewGetVertexAttribLdv, glGetVertexAttribLdv)
  OGLM_SIZE_ENUM(VertexAttribEnum,pname,1)
  GLdouble* params = OGLM_ALLOC(pname_count,GLdouble,params);
  glGetVertexAttribLdv(index, pname, params);
  OGLM_CHECK_ERR(glGetVertexAttribLdv, free(params);)
  OGLM_OUT_FINISH(params,pname_count,newSVnv)
  free(params);

void
glGetVertexAttribLi64vNV_c(index, pname, params)
  GLuint index;
  GLenum pname;
  GLint64EXT* params;
CODE:
  OGLM_GLEWINIT
  OGLM_CHECK_ERR(glGetVertexAttribLi64vNV, )
  OGLM_AVAIL_CHECK(__glewGetVertexAttribLi64vNV, glGetVertexAttribLi64vNV)
  glGetVertexAttribLi64vNV(index, pname, params);
  OGLM_CHECK_ERR(glGetVertexAttribLi64vNV, )

void
glGetVertexAttribLi64vNV_p(index, pname)
  GLuint index;
  GLenum pname;
PPCODE:
  OGLM_GLEWINIT
  OGLM_CHECK_ERR(glGetVertexAttribLi64vNV, )
  OGLM_AVAIL_CHECK(__glewGetVertexAttribLi64vNV, glGetVertexAttribLi64vNV)
  OGLM_SIZE_ENUM(VertexAttribEnum,pname,1)
  GLint64EXT* params = OGLM_ALLOC(pname_count,GLint64EXT,params);
  glGetVertexAttribLi64vNV(index, pname, params);
  OGLM_CHECK_ERR(glGetVertexAttribLi64vNV, free(params);)
  OGLM_OUT_FINISH(params,pname_count,newSViv)
  free(params);

void
glGetVertexAttribLui64vARB_c(index, pname, params)
  GLuint index;
  GLenum pname;
  GLuint64EXT* params;
CODE:
  OGLM_GLEWINIT
  OGLM_CHECK_ERR(glGetVertexAttribLui64vARB, )
  OGLM_AVAIL_CHECK(__glewGetVertexAttribLui64vARB, glGetVertexAttribLui64vARB)
  glGetVertexAttribLui64vARB(index, pname, params);
  OGLM_CHECK_ERR(glGetVertexAttribLui64vARB, )

void
glGetVertexAttribLui64vNV_c(index, pname, params)
  GLuint index;
  GLenum pname;
  GLuint64EXT* params;
CODE:
  OGLM_GLEWINIT
  OGLM_CHECK_ERR(glGetVertexAttribLui64vNV, )
  OGLM_AVAIL_CHECK(__glewGetVertexAttribLui64vNV, glGetVertexAttribLui64vNV)
  glGetVertexAttribLui64vNV(index, pname, params);
  OGLM_CHECK_ERR(glGetVertexAttribLui64vNV, )

void
glGetVertexAttribLui64vNV_p(index, pname)
  GLuint index;
  GLenum pname;
PPCODE:
  OGLM_GLEWINIT
  OGLM_CHECK_ERR(glGetVertexAttribLui64vNV, )
  OGLM_AVAIL_CHECK(__glewGetVertexAttribLui64vNV, glGetVertexAttribLui64vNV)
  OGLM_SIZE_ENUM(VertexAttribEnum,pname,1)
  GLuint64EXT* params = OGLM_ALLOC(pname_count,GLuint64EXT,params);
  glGetVertexAttribLui64vNV(index, pname, params);
  OGLM_CHECK_ERR(glGetVertexAttribLui64vNV, free(params);)
  OGLM_OUT_FINISH(params,pname_count,newSVuv)
  free(params);

void
glGetVertexAttribPointerv_c(index, pname, pointer)
  GLuint index;
  GLenum pname;
  void** pointer;
ALIAS:
  glGetVertexAttribPointervARB_c = 1
  glGetVertexAttribPointervNV_c = 2
CODE:
  OGLM_GLEWINIT
  OGLM_CHECK_ERR(glGetVertexAttribPointerv, )
  OGLM_AVAIL_CHECK(__glewGetVertexAttribPointerv, glGetVertexAttribPointerv)
  glGetVertexAttribPointerv(index, pname, pointer);
  OGLM_CHECK_ERR(glGetVertexAttribPointerv, )

void
glGetVertexAttribdv_c(index, pname, params)
  GLuint index;
  GLenum pname;
  GLdouble* params;
ALIAS:
  glGetVertexAttribdvARB_c = 1
  glGetVertexAttribdvNV_c = 2
CODE:
  OGLM_GLEWINIT
  OGLM_CHECK_ERR(glGetVertexAttribdv, )
  OGLM_AVAIL_CHECK(__glewGetVertexAttribdv, glGetVertexAttribdv)
  glGetVertexAttribdv(index, pname, params);
  OGLM_CHECK_ERR(glGetVertexAttribdv, )

void
glGetVertexAttribdv_p(index, pname)
  GLuint index;
  GLenum pname;
ALIAS:
  glGetVertexAttribdvARB_p = 1
  glGetVertexAttribdvNV_p = 2
PPCODE:
  OGLM_GLEWINIT
  OGLM_CHECK_ERR(glGetVertexAttribdv, )
  OGLM_AVAIL_CHECK(__glewGetVertexAttribdv, glGetVertexAttribdv)
  GLdouble* params = OGLM_ALLOC(4,GLdouble,params);
  glGetVertexAttribdv(index, pname, params);
  OGLM_CHECK_ERR(glGetVertexAttribdv, free(params);)
  OGLM_OUT_FINISH(params,4,newSVnv)
  free(params);

void
glGetVertexAttribfv_c(index, pname, params)
  GLuint index;
  GLenum pname;
  GLfloat* params;
ALIAS:
  glGetVertexAttribfvARB_c = 1
  glGetVertexAttribfvNV_c = 2
CODE:
  OGLM_GLEWINIT
  OGLM_CHECK_ERR(glGetVertexAttribfv, )
  OGLM_AVAIL_CHECK(__glewGetVertexAttribfv, glGetVertexAttribfv)
  glGetVertexAttribfv(index, pname, params);
  OGLM_CHECK_ERR(glGetVertexAttribfv, )

void
glGetVertexAttribfv_p(index, pname)
  GLuint index;
  GLenum pname;
ALIAS:
  glGetVertexAttribfvARB_p = 1
  glGetVertexAttribfvNV_p = 2
PPCODE:
  OGLM_GLEWINIT
  OGLM_CHECK_ERR(glGetVertexAttribfv, )
  OGLM_AVAIL_CHECK(__glewGetVertexAttribfv, glGetVertexAttribfv)
  GLfloat* params = OGLM_ALLOC(4,GLfloat,params);
  glGetVertexAttribfv(index, pname, params);
  OGLM_CHECK_ERR(glGetVertexAttribfv, free(params);)
  OGLM_OUT_FINISH(params,4,newSVnv)
  free(params);

void
glGetVertexAttribiv_c(index, pname, params)
  GLuint index;
  GLenum pname;
  GLint* params;
ALIAS:
  glGetVertexAttribivARB_c = 1
  glGetVertexAttribivNV_c = 2
CODE:
  OGLM_GLEWINIT
  OGLM_CHECK_ERR(glGetVertexAttribiv, )
  OGLM_AVAIL_CHECK(__glewGetVertexAttribiv, glGetVertexAttribiv)
  glGetVertexAttribiv(index, pname, params);
  OGLM_CHECK_ERR(glGetVertexAttribiv, )

void
glGetVertexAttribiv_p(index, pname)
  GLuint index;
  GLenum pname;
ALIAS:
  glGetVertexAttribivARB_p = 1
  glGetVertexAttribivNV_p = 2
PPCODE:
  OGLM_GLEWINIT
  OGLM_CHECK_ERR(glGetVertexAttribiv, )
  OGLM_AVAIL_CHECK(__glewGetVertexAttribiv, glGetVertexAttribiv)
  GLint* params = OGLM_ALLOC(4,GLint,params);
  glGetVertexAttribiv(index, pname, params);
  OGLM_CHECK_ERR(glGetVertexAttribiv, free(params);)
  OGLM_OUT_FINISH(params,4,newSViv)
  free(params);

void
glGetVideoCaptureStreamdvNV_c(video_capture_slot, stream, pname, params)
  GLuint video_capture_slot;
  GLuint stream;
  GLenum pname;
  GLdouble* params;
CODE:
  OGLM_GLEWINIT
  OGLM_CHECK_ERR(glGetVideoCaptureStreamdvNV, )
  OGLM_AVAIL_CHECK(__glewGetVideoCaptureStreamdvNV, glGetVideoCaptureStreamdvNV)
  glGetVideoCaptureStreamdvNV(video_capture_slot, stream, pname, params);
  OGLM_CHECK_ERR(glGetVideoCaptureStreamdvNV, )

void
glGetVideoCaptureStreamfvNV_c(video_capture_slot, stream, pname, params)
  GLuint video_capture_slot;
  GLuint stream;
  GLenum pname;
  GLfloat* params;
CODE:
  OGLM_GLEWINIT
  OGLM_CHECK_ERR(glGetVideoCaptureStreamfvNV, )
  OGLM_AVAIL_CHECK(__glewGetVideoCaptureStreamfvNV, glGetVideoCaptureStreamfvNV)
  glGetVideoCaptureStreamfvNV(video_capture_slot, stream, pname, params);
  OGLM_CHECK_ERR(glGetVideoCaptureStreamfvNV, )

void
glGetVideoCaptureStreamivNV_c(video_capture_slot, stream, pname, params)
  GLuint video_capture_slot;
  GLuint stream;
  GLenum pname;
  GLint* params;
CODE:
  OGLM_GLEWINIT
  OGLM_CHECK_ERR(glGetVideoCaptureStreamivNV, )
  OGLM_AVAIL_CHECK(__glewGetVideoCaptureStreamivNV, glGetVideoCaptureStreamivNV)
  glGetVideoCaptureStreamivNV(video_capture_slot, stream, pname, params);
  OGLM_CHECK_ERR(glGetVideoCaptureStreamivNV, )

void
glGetVideoCaptureivNV_c(video_capture_slot, pname, params)
  GLuint video_capture_slot;
  GLenum pname;
  GLint* params;
CODE:
  OGLM_GLEWINIT
  OGLM_CHECK_ERR(glGetVideoCaptureivNV, )
  OGLM_AVAIL_CHECK(__glewGetVideoCaptureivNV, glGetVideoCaptureivNV)
  glGetVideoCaptureivNV(video_capture_slot, pname, params);
  OGLM_CHECK_ERR(glGetVideoCaptureivNV, )

void
glGetVideoi64vNV_c(video_slot, pname, params)
  GLuint video_slot;
  GLenum pname;
  GLint64EXT* params;
CODE:
  OGLM_GLEWINIT
  OGLM_CHECK_ERR(glGetVideoi64vNV, )
  OGLM_AVAIL_CHECK(__glewGetVideoi64vNV, glGetVideoi64vNV)
  glGetVideoi64vNV(video_slot, pname, params);
  OGLM_CHECK_ERR(glGetVideoi64vNV, )

void
glGetVideoivNV_c(video_slot, pname, params)
  GLuint video_slot;
  GLenum pname;
  GLint* params;
CODE:
  OGLM_GLEWINIT
  OGLM_CHECK_ERR(glGetVideoivNV, )
  OGLM_AVAIL_CHECK(__glewGetVideoivNV, glGetVideoivNV)
  glGetVideoivNV(video_slot, pname, params);
  OGLM_CHECK_ERR(glGetVideoivNV, )

void
glGetVideoui64vNV_c(video_slot, pname, params)
  GLuint video_slot;
  GLenum pname;
  GLuint64EXT* params;
CODE:
  OGLM_GLEWINIT
  OGLM_CHECK_ERR(glGetVideoui64vNV, )
  OGLM_AVAIL_CHECK(__glewGetVideoui64vNV, glGetVideoui64vNV)
  glGetVideoui64vNV(video_slot, pname, params);
  OGLM_CHECK_ERR(glGetVideoui64vNV, )

void
glGetVideouivNV_c(video_slot, pname, params)
  GLuint video_slot;
  GLenum pname;
  GLuint* params;
CODE:
  OGLM_GLEWINIT
  OGLM_CHECK_ERR(glGetVideouivNV, )
  OGLM_AVAIL_CHECK(__glewGetVideouivNV, glGetVideouivNV)
  glGetVideouivNV(video_slot, pname, params);
  OGLM_CHECK_ERR(glGetVideouivNV, )

GLVULKANPROCNV
glGetVkProcAddrNV(name)
  const GLchar* name;
CODE:
  OGLM_GLEWINIT
  OGLM_CHECK_ERR(glGetVkProcAddrNV, )
  OGLM_AVAIL_CHECK(__glewGetVkProcAddrNV, glGetVkProcAddrNV)
  RETVAL = glGetVkProcAddrNV(name);
  OGLM_CHECK_ERR(glGetVkProcAddrNV, )
OUTPUT:
  RETVAL

void
glGetnColorTableARB_c(target, format, type, bufSize, table)
  GLenum target;
  GLenum format;
  GLenum type;
  GLsizei bufSize;
  void* table;
CODE:
  OGLM_GLEWINIT
  OGLM_CHECK_ERR(glGetnColorTableARB, )
  OGLM_AVAIL_CHECK(__glewGetnColorTableARB, glGetnColorTableARB)
  glGetnColorTableARB(target, format, type, bufSize, table);
  OGLM_CHECK_ERR(glGetnColorTableARB, )

void
glGetnCompressedTexImage_c(target, lod, bufSize, pixels)
  GLenum target;
  GLint lod;
  GLsizei bufSize;
  GLvoid *pixels;
CODE:
  OGLM_GLEWINIT
  OGLM_CHECK_ERR(glGetnCompressedTexImage, )
  OGLM_AVAIL_CHECK(__glewGetnCompressedTexImage, glGetnCompressedTexImage)
  glGetnCompressedTexImage(target, lod, bufSize, pixels);
  OGLM_CHECK_ERR(glGetnCompressedTexImage, )

void
glGetnCompressedTexImageARB_c(target, lod, bufSize, img)
  GLenum target;
  GLint lod;
  GLsizei bufSize;
  void* img;
CODE:
  OGLM_GLEWINIT
  OGLM_CHECK_ERR(glGetnCompressedTexImageARB, )
  OGLM_AVAIL_CHECK(__glewGetnCompressedTexImageARB, glGetnCompressedTexImageARB)
  glGetnCompressedTexImageARB(target, lod, bufSize, img);
  OGLM_CHECK_ERR(glGetnCompressedTexImageARB, )

void
glGetnConvolutionFilterARB_c(target, format, type, bufSize, image)
  GLenum target;
  GLenum format;
  GLenum type;
  GLsizei bufSize;
  void* image;
CODE:
  OGLM_GLEWINIT
  OGLM_CHECK_ERR(glGetnConvolutionFilterARB, )
  OGLM_AVAIL_CHECK(__glewGetnConvolutionFilterARB, glGetnConvolutionFilterARB)
  glGetnConvolutionFilterARB(target, format, type, bufSize, image);
  OGLM_CHECK_ERR(glGetnConvolutionFilterARB, )

void
glGetnHistogramARB_c(target, reset, format, type, bufSize, values)
  GLenum target;
  GLboolean reset;
  GLenum format;
  GLenum type;
  GLsizei bufSize;
  void* values;
CODE:
  OGLM_GLEWINIT
  OGLM_CHECK_ERR(glGetnHistogramARB, )
  OGLM_AVAIL_CHECK(__glewGetnHistogramARB, glGetnHistogramARB)
  glGetnHistogramARB(target, reset, format, type, bufSize, values);
  OGLM_CHECK_ERR(glGetnHistogramARB, )

void
glGetnMapdvARB_c(target, query, bufSize, v)
  GLenum target;
  GLenum query;
  GLsizei bufSize;
  GLdouble* v;
CODE:
  OGLM_GLEWINIT
  OGLM_CHECK_ERR(glGetnMapdvARB, )
  OGLM_AVAIL_CHECK(__glewGetnMapdvARB, glGetnMapdvARB)
  glGetnMapdvARB(target, query, bufSize, v);
  OGLM_CHECK_ERR(glGetnMapdvARB, )

void
glGetnMapdvARB_p(target, query, bufSize)
  GLenum target;
  GLenum query;
  GLsizei bufSize;
PPCODE:
  OGLM_GLEWINIT
  OGLM_CHECK_ERR(glGetnMapdvARB, )
  OGLM_AVAIL_CHECK(__glewGetnMapdvARB, glGetnMapdvARB)
  GLdouble* v = OGLM_ALLOC(bufSize/8,GLdouble,v);
  glGetnMapdvARB(target, query, bufSize, v);
  OGLM_CHECK_ERR(glGetnMapdvARB, free(v);)
  OGLM_OUT_FINISH(v,bufSize/8,newSVnv)
  free(v);

void
glGetnMapfvARB_c(target, query, bufSize, v)
  GLenum target;
  GLenum query;
  GLsizei bufSize;
  GLfloat* v;
CODE:
  OGLM_GLEWINIT
  OGLM_CHECK_ERR(glGetnMapfvARB, )
  OGLM_AVAIL_CHECK(__glewGetnMapfvARB, glGetnMapfvARB)
  glGetnMapfvARB(target, query, bufSize, v);
  OGLM_CHECK_ERR(glGetnMapfvARB, )

void
glGetnMapfvARB_p(target, query, bufSize)
  GLenum target;
  GLenum query;
  GLsizei bufSize;
PPCODE:
  OGLM_GLEWINIT
  OGLM_CHECK_ERR(glGetnMapfvARB, )
  OGLM_AVAIL_CHECK(__glewGetnMapfvARB, glGetnMapfvARB)
  GLfloat* v = OGLM_ALLOC(bufSize,GLfloat,v);
  glGetnMapfvARB(target, query, bufSize, v);
  OGLM_CHECK_ERR(glGetnMapfvARB, free(v);)
  OGLM_OUT_FINISH(v,bufSize,newSVnv)
  free(v);

void
glGetnMapivARB_c(target, query, bufSize, v)
  GLenum target;
  GLenum query;
  GLsizei bufSize;
  GLint* v;
CODE:
  OGLM_GLEWINIT
  OGLM_CHECK_ERR(glGetnMapivARB, )
  OGLM_AVAIL_CHECK(__glewGetnMapivARB, glGetnMapivARB)
  glGetnMapivARB(target, query, bufSize, v);
  OGLM_CHECK_ERR(glGetnMapivARB, )

void
glGetnMapivARB_p(target, query, bufSize)
  GLenum target;
  GLenum query;
  GLsizei bufSize;
PPCODE:
  OGLM_GLEWINIT
  OGLM_CHECK_ERR(glGetnMapivARB, )
  OGLM_AVAIL_CHECK(__glewGetnMapivARB, glGetnMapivARB)
  GLint* v = OGLM_ALLOC(bufSize,GLint,v);
  glGetnMapivARB(target, query, bufSize, v);
  OGLM_CHECK_ERR(glGetnMapivARB, free(v);)
  OGLM_OUT_FINISH(v,bufSize,newSViv)
  free(v);

void
glGetnMinmaxARB_c(target, reset, format, type, bufSize, values)
  GLenum target;
  GLboolean reset;
  GLenum format;
  GLenum type;
  GLsizei bufSize;
  void* values;
CODE:
  OGLM_GLEWINIT
  OGLM_CHECK_ERR(glGetnMinmaxARB, )
  OGLM_AVAIL_CHECK(__glewGetnMinmaxARB, glGetnMinmaxARB)
  glGetnMinmaxARB(target, reset, format, type, bufSize, values);
  OGLM_CHECK_ERR(glGetnMinmaxARB, )

void
glGetnPixelMapfvARB_c(map, bufSize, values)
  GLenum map;
  GLsizei bufSize;
  GLfloat* values;
CODE:
  OGLM_GLEWINIT
  OGLM_CHECK_ERR(glGetnPixelMapfvARB, )
  OGLM_AVAIL_CHECK(__glewGetnPixelMapfvARB, glGetnPixelMapfvARB)
  glGetnPixelMapfvARB(map, bufSize, values);
  OGLM_CHECK_ERR(glGetnPixelMapfvARB, )

void
glGetnPixelMapfvARB_p(map, bufSize)
  GLenum map;
  GLsizei bufSize;
PPCODE:
  OGLM_GLEWINIT
  OGLM_CHECK_ERR(glGetnPixelMapfvARB, )
  OGLM_AVAIL_CHECK(__glewGetnPixelMapfvARB, glGetnPixelMapfvARB)
  GLfloat* values = OGLM_ALLOC(bufSize/4,GLfloat,values);
  glGetnPixelMapfvARB(map, bufSize, values);
  OGLM_CHECK_ERR(glGetnPixelMapfvARB, free(values);)
  OGLM_OUT_FINISH(values,bufSize/4,newSVnv)
  free(values);

void
glGetnPixelMapuivARB_c(map, bufSize, values)
  GLenum map;
  GLsizei bufSize;
  GLuint* values;
CODE:
  OGLM_GLEWINIT
  OGLM_CHECK_ERR(glGetnPixelMapuivARB, )
  OGLM_AVAIL_CHECK(__glewGetnPixelMapuivARB, glGetnPixelMapuivARB)
  glGetnPixelMapuivARB(map, bufSize, values);
  OGLM_CHECK_ERR(glGetnPixelMapuivARB, )

void
glGetnPixelMapuivARB_p(map, bufSize)
  GLenum map;
  GLsizei bufSize;
PPCODE:
  OGLM_GLEWINIT
  OGLM_CHECK_ERR(glGetnPixelMapuivARB, )
  OGLM_AVAIL_CHECK(__glewGetnPixelMapuivARB, glGetnPixelMapuivARB)
  GLuint* values = OGLM_ALLOC(bufSize,GLuint,values);
  glGetnPixelMapuivARB(map, bufSize, values);
  OGLM_CHECK_ERR(glGetnPixelMapuivARB, free(values);)
  OGLM_OUT_FINISH(values,bufSize,newSVuv)
  free(values);

void
glGetnPixelMapusvARB_c(map, bufSize, values)
  GLenum map;
  GLsizei bufSize;
  GLushort* values;
CODE:
  OGLM_GLEWINIT
  OGLM_CHECK_ERR(glGetnPixelMapusvARB, )
  OGLM_AVAIL_CHECK(__glewGetnPixelMapusvARB, glGetnPixelMapusvARB)
  glGetnPixelMapusvARB(map, bufSize, values);
  OGLM_CHECK_ERR(glGetnPixelMapusvARB, )

void
glGetnPixelMapusvARB_p(map, bufSize)
  GLenum map;
  GLsizei bufSize;
PPCODE:
  OGLM_GLEWINIT
  OGLM_CHECK_ERR(glGetnPixelMapusvARB, )
  OGLM_AVAIL_CHECK(__glewGetnPixelMapusvARB, glGetnPixelMapusvARB)
  GLushort* values = OGLM_ALLOC(bufSize,GLushort,values);
  glGetnPixelMapusvARB(map, bufSize, values);
  OGLM_CHECK_ERR(glGetnPixelMapusvARB, free(values);)
  OGLM_OUT_FINISH(values,bufSize,newSVuv)
  free(values);

void
glGetnPolygonStippleARB_c(bufSize, pattern)
  GLsizei bufSize;
  GLubyte* pattern;
CODE:
  OGLM_GLEWINIT
  OGLM_CHECK_ERR(glGetnPolygonStippleARB, )
  OGLM_AVAIL_CHECK(__glewGetnPolygonStippleARB, glGetnPolygonStippleARB)
  glGetnPolygonStippleARB(bufSize, pattern);
  OGLM_CHECK_ERR(glGetnPolygonStippleARB, )

void
glGetnPolygonStippleARB_p(bufSize)
  GLsizei bufSize;
PPCODE:
  OGLM_GLEWINIT
  OGLM_CHECK_ERR(glGetnPolygonStippleARB, )
  OGLM_AVAIL_CHECK(__glewGetnPolygonStippleARB, glGetnPolygonStippleARB)
  GLubyte* pattern = OGLM_ALLOC(bufSize,GLubyte,pattern);
  glGetnPolygonStippleARB(bufSize, pattern);
  OGLM_CHECK_ERR(glGetnPolygonStippleARB, free(pattern);)
  OGLM_OUT_FINISH(pattern,bufSize,newSVuv)
  free(pattern);

void
glGetnSeparableFilterARB_c(target, format, type, rowBufSize, row, columnBufSize, column, span)
  GLenum target;
  GLenum format;
  GLenum type;
  GLsizei rowBufSize;
  void* row;
  GLsizei columnBufSize;
  void*column;
  void*span;
CODE:
  OGLM_GLEWINIT
  OGLM_CHECK_ERR(glGetnSeparableFilterARB, )
  OGLM_AVAIL_CHECK(__glewGetnSeparableFilterARB, glGetnSeparableFilterARB)
  glGetnSeparableFilterARB(target, format, type, rowBufSize, row, columnBufSize, column, span);
  OGLM_CHECK_ERR(glGetnSeparableFilterARB, )

void
glGetnTexImage_c(target, level, format, type, bufSize, pixels)
  GLenum target;
  GLint level;
  GLenum format;
  GLenum type;
  GLsizei bufSize;
  GLvoid *pixels;
CODE:
  OGLM_GLEWINIT
  OGLM_CHECK_ERR(glGetnTexImage, )
  OGLM_AVAIL_CHECK(__glewGetnTexImage, glGetnTexImage)
  glGetnTexImage(target, level, format, type, bufSize, pixels);
  OGLM_CHECK_ERR(glGetnTexImage, )

void
glGetnTexImageARB_c(target, level, format, type, bufSize, img)
  GLenum target;
  GLint level;
  GLenum format;
  GLenum type;
  GLsizei bufSize;
  void* img;
CODE:
  OGLM_GLEWINIT
  OGLM_CHECK_ERR(glGetnTexImageARB, )
  OGLM_AVAIL_CHECK(__glewGetnTexImageARB, glGetnTexImageARB)
  glGetnTexImageARB(target, level, format, type, bufSize, img);
  OGLM_CHECK_ERR(glGetnTexImageARB, )

void
glGetnUniformdv_c(program, location, bufSize, params)
  GLuint program;
  GLint location;
  GLsizei bufSize;
  GLdouble *params;
CODE:
  OGLM_GLEWINIT
  OGLM_CHECK_ERR(glGetnUniformdv, )
  OGLM_AVAIL_CHECK(__glewGetnUniformdv, glGetnUniformdv)
  glGetnUniformdv(program, location, bufSize, params);
  OGLM_CHECK_ERR(glGetnUniformdv, )

void
glGetnUniformdv_p(program, location, bufSize)
  GLuint program;
  GLint location;
  GLsizei bufSize;
PPCODE:
  OGLM_GLEWINIT
  OGLM_CHECK_ERR(glGetnUniformdv, )
  OGLM_AVAIL_CHECK(__glewGetnUniformdv, glGetnUniformdv)
  GLdouble *params = OGLM_ALLOC(bufSize/8,GLdouble,params);
  glGetnUniformdv(program, location, bufSize, params);
  OGLM_CHECK_ERR(glGetnUniformdv, free(params);)
  OGLM_OUT_FINISH(params,bufSize/8,newSVnv)
  free(params);

void
glGetnUniformdvARB_c(program, location, bufSize, params)
  GLuint program;
  GLint location;
  GLsizei bufSize;
  GLdouble* params;
CODE:
  OGLM_GLEWINIT
  OGLM_CHECK_ERR(glGetnUniformdvARB, )
  OGLM_AVAIL_CHECK(__glewGetnUniformdvARB, glGetnUniformdvARB)
  glGetnUniformdvARB(program, location, bufSize, params);
  OGLM_CHECK_ERR(glGetnUniformdvARB, )

void
glGetnUniformdvARB_p(program, location, bufSize)
  GLuint program;
  GLint location;
  GLsizei bufSize;
PPCODE:
  OGLM_GLEWINIT
  OGLM_CHECK_ERR(glGetnUniformdvARB, )
  OGLM_AVAIL_CHECK(__glewGetnUniformdvARB, glGetnUniformdvARB)
  GLdouble* params = OGLM_ALLOC(bufSize/8,GLdouble,params);
  glGetnUniformdvARB(program, location, bufSize, params);
  OGLM_CHECK_ERR(glGetnUniformdvARB, free(params);)
  OGLM_OUT_FINISH(params,bufSize/8,newSVnv)
  free(params);

void
glGetnUniformfv_c(program, location, bufSize, params)
  GLuint program;
  GLint location;
  GLsizei bufSize;
  GLfloat* params;
ALIAS:
  glGetnUniformfvEXT_c = 1
  glGetnUniformfvKHR_c = 2
CODE:
  OGLM_GLEWINIT
  OGLM_CHECK_ERR(glGetnUniformfv, )
  OGLM_AVAIL_CHECK(__glewGetnUniformfv, glGetnUniformfv)
  glGetnUniformfv(program, location, bufSize, params);
  OGLM_CHECK_ERR(glGetnUniformfv, )

void
glGetnUniformfv_p(program, location, bufSize)
  GLuint program;
  GLint location;
  GLsizei bufSize;
ALIAS:
  glGetnUniformfvEXT_p = 1
  glGetnUniformfvKHR_p = 2
PPCODE:
  OGLM_GLEWINIT
  OGLM_CHECK_ERR(glGetnUniformfv, )
  OGLM_AVAIL_CHECK(__glewGetnUniformfv, glGetnUniformfv)
  GLfloat* params = OGLM_ALLOC(bufSize/4,GLfloat,params);
  glGetnUniformfv(program, location, bufSize, params);
  OGLM_CHECK_ERR(glGetnUniformfv, free(params);)
  OGLM_OUT_FINISH(params,bufSize/4,newSVnv)
  free(params);

void
glGetnUniformfvARB_c(program, location, bufSize, params)
  GLuint program;
  GLint location;
  GLsizei bufSize;
  GLfloat* params;
CODE:
  OGLM_GLEWINIT
  OGLM_CHECK_ERR(glGetnUniformfvARB, )
  OGLM_AVAIL_CHECK(__glewGetnUniformfvARB, glGetnUniformfvARB)
  glGetnUniformfvARB(program, location, bufSize, params);
  OGLM_CHECK_ERR(glGetnUniformfvARB, )

void
glGetnUniformfvARB_p(program, location, bufSize)
  GLuint program;
  GLint location;
  GLsizei bufSize;
PPCODE:
  OGLM_GLEWINIT
  OGLM_CHECK_ERR(glGetnUniformfvARB, )
  OGLM_AVAIL_CHECK(__glewGetnUniformfvARB, glGetnUniformfvARB)
  GLfloat* params = OGLM_ALLOC(bufSize/4,GLfloat,params);
  glGetnUniformfvARB(program, location, bufSize, params);
  OGLM_CHECK_ERR(glGetnUniformfvARB, free(params);)
  OGLM_OUT_FINISH(params,bufSize/4,newSVnv)
  free(params);

void
glGetnUniformi64vARB_c(program, location, bufSize, params)
  GLuint program;
  GLint location;
  GLsizei bufSize;
  GLint64* params;
CODE:
  OGLM_GLEWINIT
  OGLM_CHECK_ERR(glGetnUniformi64vARB, )
  OGLM_AVAIL_CHECK(__glewGetnUniformi64vARB, glGetnUniformi64vARB)
  glGetnUniformi64vARB(program, location, bufSize, params);
  OGLM_CHECK_ERR(glGetnUniformi64vARB, )

void
glGetnUniformi64vARB_p(program, location, bufSize)
  GLuint program;
  GLint location;
  GLsizei bufSize;
PPCODE:
  OGLM_GLEWINIT
  OGLM_CHECK_ERR(glGetnUniformi64vARB, )
  OGLM_AVAIL_CHECK(__glewGetnUniformi64vARB, glGetnUniformi64vARB)
  GLint64* params = OGLM_ALLOC(bufSize/8,GLint64,params);
  glGetnUniformi64vARB(program, location, bufSize, params);
  OGLM_CHECK_ERR(glGetnUniformi64vARB, free(params);)
  OGLM_OUT_FINISH(params,bufSize/8,newSViv)
  free(params);

void
glGetnUniformiv_c(program, location, bufSize, params)
  GLuint program;
  GLint location;
  GLsizei bufSize;
  GLint* params;
ALIAS:
  glGetnUniformivEXT_c = 1
  glGetnUniformivKHR_c = 2
CODE:
  OGLM_GLEWINIT
  OGLM_CHECK_ERR(glGetnUniformiv, )
  OGLM_AVAIL_CHECK(__glewGetnUniformiv, glGetnUniformiv)
  glGetnUniformiv(program, location, bufSize, params);
  OGLM_CHECK_ERR(glGetnUniformiv, )

void
glGetnUniformiv_p(program, location, bufSize)
  GLuint program;
  GLint location;
  GLsizei bufSize;
ALIAS:
  glGetnUniformivEXT_p = 1
  glGetnUniformivKHR_p = 2
PPCODE:
  OGLM_GLEWINIT
  OGLM_CHECK_ERR(glGetnUniformiv, )
  OGLM_AVAIL_CHECK(__glewGetnUniformiv, glGetnUniformiv)
  GLint* params = OGLM_ALLOC(bufSize/4,GLint,params);
  glGetnUniformiv(program, location, bufSize, params);
  OGLM_CHECK_ERR(glGetnUniformiv, free(params);)
  OGLM_OUT_FINISH(params,bufSize/4,newSViv)
  free(params);

void
glGetnUniformivARB_c(program, location, bufSize, params)
  GLuint program;
  GLint location;
  GLsizei bufSize;
  GLint* params;
CODE:
  OGLM_GLEWINIT
  OGLM_CHECK_ERR(glGetnUniformivARB, )
  OGLM_AVAIL_CHECK(__glewGetnUniformivARB, glGetnUniformivARB)
  glGetnUniformivARB(program, location, bufSize, params);
  OGLM_CHECK_ERR(glGetnUniformivARB, )

void
glGetnUniformivARB_p(program, location, bufSize)
  GLuint program;
  GLint location;
  GLsizei bufSize;
PPCODE:
  OGLM_GLEWINIT
  OGLM_CHECK_ERR(glGetnUniformivARB, )
  OGLM_AVAIL_CHECK(__glewGetnUniformivARB, glGetnUniformivARB)
  GLint* params = OGLM_ALLOC(bufSize/4,GLint,params);
  glGetnUniformivARB(program, location, bufSize, params);
  OGLM_CHECK_ERR(glGetnUniformivARB, free(params);)
  OGLM_OUT_FINISH(params,bufSize/4,newSViv)
  free(params);

void
glGetnUniformui64vARB_c(program, location, bufSize, params)
  GLuint program;
  GLint location;
  GLsizei bufSize;
  GLuint64* params;
CODE:
  OGLM_GLEWINIT
  OGLM_CHECK_ERR(glGetnUniformui64vARB, )
  OGLM_AVAIL_CHECK(__glewGetnUniformui64vARB, glGetnUniformui64vARB)
  glGetnUniformui64vARB(program, location, bufSize, params);
  OGLM_CHECK_ERR(glGetnUniformui64vARB, )

void
glGetnUniformui64vARB_p(program, location, bufSize)
  GLuint program;
  GLint location;
  GLsizei bufSize;
PPCODE:
  OGLM_GLEWINIT
  OGLM_CHECK_ERR(glGetnUniformui64vARB, )
  OGLM_AVAIL_CHECK(__glewGetnUniformui64vARB, glGetnUniformui64vARB)
  GLuint64* params = OGLM_ALLOC(bufSize/8,GLuint64,params);
  glGetnUniformui64vARB(program, location, bufSize, params);
  OGLM_CHECK_ERR(glGetnUniformui64vARB, free(params);)
  OGLM_OUT_FINISH(params,bufSize/8,newSVuv)
  free(params);

void
glGetnUniformuiv_c(program, location, bufSize, params)
  GLuint program;
  GLint location;
  GLsizei bufSize;
  GLuint* params;
ALIAS:
  glGetnUniformuivKHR_c = 1
CODE:
  OGLM_GLEWINIT
  OGLM_CHECK_ERR(glGetnUniformuiv, )
  OGLM_AVAIL_CHECK(__glewGetnUniformuiv, glGetnUniformuiv)
  glGetnUniformuiv(program, location, bufSize, params);
  OGLM_CHECK_ERR(glGetnUniformuiv, )

void
glGetnUniformuiv_p(program, location, bufSize)
  GLuint program;
  GLint location;
  GLsizei bufSize;
ALIAS:
  glGetnUniformuivKHR_p = 1
PPCODE:
  OGLM_GLEWINIT
  OGLM_CHECK_ERR(glGetnUniformuiv, )
  OGLM_AVAIL_CHECK(__glewGetnUniformuiv, glGetnUniformuiv)
  GLuint* params = OGLM_ALLOC(bufSize/4,GLuint,params);
  glGetnUniformuiv(program, location, bufSize, params);
  OGLM_CHECK_ERR(glGetnUniformuiv, free(params);)
  OGLM_OUT_FINISH(params,bufSize/4,newSVuv)
  free(params);

void
glGetnUniformuivARB_c(program, location, bufSize, params)
  GLuint program;
  GLint location;
  GLsizei bufSize;
  GLuint* params;
CODE:
  OGLM_GLEWINIT
  OGLM_CHECK_ERR(glGetnUniformuivARB, )
  OGLM_AVAIL_CHECK(__glewGetnUniformuivARB, glGetnUniformuivARB)
  glGetnUniformuivARB(program, location, bufSize, params);
  OGLM_CHECK_ERR(glGetnUniformuivARB, )

void
glGetnUniformuivARB_p(program, location, bufSize)
  GLuint program;
  GLint location;
  GLsizei bufSize;
PPCODE:
  OGLM_GLEWINIT
  OGLM_CHECK_ERR(glGetnUniformuivARB, )
  OGLM_AVAIL_CHECK(__glewGetnUniformuivARB, glGetnUniformuivARB)
  GLuint* params = OGLM_ALLOC(bufSize/4,GLuint,params);
  glGetnUniformuivARB(program, location, bufSize, params);
  OGLM_CHECK_ERR(glGetnUniformuivARB, free(params);)
  OGLM_OUT_FINISH(params,bufSize/4,newSVuv)
  free(params);

void
glGlobalAlphaFactorbSUN(factor)
  GLbyte factor;
CODE:
  OGLM_GLEWINIT
  OGLM_CHECK_ERR(glGlobalAlphaFactorbSUN, )
  OGLM_AVAIL_CHECK(__glewGlobalAlphaFactorbSUN, glGlobalAlphaFactorbSUN)
  glGlobalAlphaFactorbSUN(factor);
  OGLM_CHECK_ERR(glGlobalAlphaFactorbSUN, )

void
glGlobalAlphaFactordSUN(factor)
  GLdouble factor;
CODE:
  OGLM_GLEWINIT
  OGLM_CHECK_ERR(glGlobalAlphaFactordSUN, )
  OGLM_AVAIL_CHECK(__glewGlobalAlphaFactordSUN, glGlobalAlphaFactordSUN)
  glGlobalAlphaFactordSUN(factor);
  OGLM_CHECK_ERR(glGlobalAlphaFactordSUN, )

void
glGlobalAlphaFactorfSUN(factor)
  GLfloat factor;
CODE:
  OGLM_GLEWINIT
  OGLM_CHECK_ERR(glGlobalAlphaFactorfSUN, )
  OGLM_AVAIL_CHECK(__glewGlobalAlphaFactorfSUN, glGlobalAlphaFactorfSUN)
  glGlobalAlphaFactorfSUN(factor);
  OGLM_CHECK_ERR(glGlobalAlphaFactorfSUN, )

void
glGlobalAlphaFactoriSUN(factor)
  GLint factor;
CODE:
  OGLM_GLEWINIT
  OGLM_CHECK_ERR(glGlobalAlphaFactoriSUN, )
  OGLM_AVAIL_CHECK(__glewGlobalAlphaFactoriSUN, glGlobalAlphaFactoriSUN)
  glGlobalAlphaFactoriSUN(factor);
  OGLM_CHECK_ERR(glGlobalAlphaFactoriSUN, )

void
glGlobalAlphaFactorsSUN(factor)
  GLshort factor;
CODE:
  OGLM_GLEWINIT
  OGLM_CHECK_ERR(glGlobalAlphaFactorsSUN, )
  OGLM_AVAIL_CHECK(__glewGlobalAlphaFactorsSUN, glGlobalAlphaFactorsSUN)
  glGlobalAlphaFactorsSUN(factor);
  OGLM_CHECK_ERR(glGlobalAlphaFactorsSUN, )

void
glGlobalAlphaFactorubSUN(factor)
  GLubyte factor;
CODE:
  OGLM_GLEWINIT
  OGLM_CHECK_ERR(glGlobalAlphaFactorubSUN, )
  OGLM_AVAIL_CHECK(__glewGlobalAlphaFactorubSUN, glGlobalAlphaFactorubSUN)
  glGlobalAlphaFactorubSUN(factor);
  OGLM_CHECK_ERR(glGlobalAlphaFactorubSUN, )

void
glGlobalAlphaFactoruiSUN(factor)
  GLuint factor;
CODE:
  OGLM_GLEWINIT
  OGLM_CHECK_ERR(glGlobalAlphaFactoruiSUN, )
  OGLM_AVAIL_CHECK(__glewGlobalAlphaFactoruiSUN, glGlobalAlphaFactoruiSUN)
  glGlobalAlphaFactoruiSUN(factor);
  OGLM_CHECK_ERR(glGlobalAlphaFactoruiSUN, )

void
glGlobalAlphaFactorusSUN(factor)
  GLushort factor;
CODE:
  OGLM_GLEWINIT
  OGLM_CHECK_ERR(glGlobalAlphaFactorusSUN, )
  OGLM_AVAIL_CHECK(__glewGlobalAlphaFactorusSUN, glGlobalAlphaFactorusSUN)
  glGlobalAlphaFactorusSUN(factor);
  OGLM_CHECK_ERR(glGlobalAlphaFactorusSUN, )

void
glHint(target, mode)
  GLenum target;
  GLenum mode;
CODE:
  OGLM_GLEWINIT
  OGLM_CHECK_ERR(glHint, )
  glHint(target, mode);
  OGLM_CHECK_ERR(glHint, )

void
glHistogram(target, width, internalformat, sink)
  GLenum target;
  GLsizei width;
  GLenum internalformat;
  GLboolean sink;
ALIAS:
  glHistogramEXT = 1
CODE:
  OGLM_GLEWINIT
  OGLM_CHECK_ERR(glHistogram, )
  OGLM_AVAIL_CHECK(__glewHistogram, glHistogram)
  glHistogram(target, width, internalformat, sink);
  OGLM_CHECK_ERR(glHistogram, )

void
glIglooInterfaceSGIX_c(pname, params)
  GLenum pname;
  void *params;
CODE:
  OGLM_GLEWINIT
  OGLM_CHECK_ERR(glIglooInterfaceSGIX, )
  OGLM_AVAIL_CHECK(__glewIglooInterfaceSGIX, glIglooInterfaceSGIX)
  glIglooInterfaceSGIX(pname, params);
  OGLM_CHECK_ERR(glIglooInterfaceSGIX, )

void
glImageTransformParameterfHP(target, pname, param)
  GLenum target;
  GLenum pname;
  const GLfloat param;
CODE:
  OGLM_GLEWINIT
  OGLM_CHECK_ERR(glImageTransformParameterfHP, )
  OGLM_AVAIL_CHECK(__glewImageTransformParameterfHP, glImageTransformParameterfHP)
  glImageTransformParameterfHP(target, pname, param);
  OGLM_CHECK_ERR(glImageTransformParameterfHP, )

void
glImageTransformParameterfvHP_c(target, pname, params)
  GLenum target;
  GLenum pname;
  const GLfloat* params;
CODE:
  OGLM_GLEWINIT
  OGLM_CHECK_ERR(glImageTransformParameterfvHP, )
  OGLM_AVAIL_CHECK(__glewImageTransformParameterfvHP, glImageTransformParameterfvHP)
  glImageTransformParameterfvHP(target, pname, params);
  OGLM_CHECK_ERR(glImageTransformParameterfvHP, )

void
glImageTransformParameteriHP(target, pname, param)
  GLenum target;
  GLenum pname;
  const GLint param;
CODE:
  OGLM_GLEWINIT
  OGLM_CHECK_ERR(glImageTransformParameteriHP, )
  OGLM_AVAIL_CHECK(__glewImageTransformParameteriHP, glImageTransformParameteriHP)
  glImageTransformParameteriHP(target, pname, param);
  OGLM_CHECK_ERR(glImageTransformParameteriHP, )

void
glImageTransformParameterivHP_c(target, pname, params)
  GLenum target;
  GLenum pname;
  const GLint* params;
CODE:
  OGLM_GLEWINIT
  OGLM_CHECK_ERR(glImageTransformParameterivHP, )
  OGLM_AVAIL_CHECK(__glewImageTransformParameterivHP, glImageTransformParameterivHP)
  glImageTransformParameterivHP(target, pname, params);
  OGLM_CHECK_ERR(glImageTransformParameterivHP, )

void
glImportMemoryFdEXT(memory, size, handleType, fd)
  GLuint memory;
  GLuint64 size;
  GLenum handleType;
  GLint fd;
CODE:
  OGLM_GLEWINIT
  OGLM_CHECK_ERR(glImportMemoryFdEXT, )
  OGLM_AVAIL_CHECK(__glewImportMemoryFdEXT, glImportMemoryFdEXT)
  glImportMemoryFdEXT(memory, size, handleType, fd);
  OGLM_CHECK_ERR(glImportMemoryFdEXT, )

void
glImportMemoryWin32HandleEXT_c(memory, size, handleType, handle)
  GLuint memory;
  GLuint64 size;
  GLenum handleType;
  void *handle;
CODE:
  OGLM_GLEWINIT
  OGLM_CHECK_ERR(glImportMemoryWin32HandleEXT, )
  OGLM_AVAIL_CHECK(__glewImportMemoryWin32HandleEXT, glImportMemoryWin32HandleEXT)
  glImportMemoryWin32HandleEXT(memory, size, handleType, handle);
  OGLM_CHECK_ERR(glImportMemoryWin32HandleEXT, )

void
glImportMemoryWin32NameEXT_c(memory, size, handleType, name)
  GLuint memory;
  GLuint64 size;
  GLenum handleType;
  const void *name;
CODE:
  OGLM_GLEWINIT
  OGLM_CHECK_ERR(glImportMemoryWin32NameEXT, )
  OGLM_AVAIL_CHECK(__glewImportMemoryWin32NameEXT, glImportMemoryWin32NameEXT)
  glImportMemoryWin32NameEXT(memory, size, handleType, name);
  OGLM_CHECK_ERR(glImportMemoryWin32NameEXT, )

void
glImportSemaphoreFdEXT(semaphore, handleType, fd)
  GLuint semaphore;
  GLenum handleType;
  GLint fd;
CODE:
  OGLM_GLEWINIT
  OGLM_CHECK_ERR(glImportSemaphoreFdEXT, )
  OGLM_AVAIL_CHECK(__glewImportSemaphoreFdEXT, glImportSemaphoreFdEXT)
  glImportSemaphoreFdEXT(semaphore, handleType, fd);
  OGLM_CHECK_ERR(glImportSemaphoreFdEXT, )

void
glImportSemaphoreWin32HandleEXT_c(semaphore, handleType, handle)
  GLuint semaphore;
  GLenum handleType;
  void *handle;
CODE:
  OGLM_GLEWINIT
  OGLM_CHECK_ERR(glImportSemaphoreWin32HandleEXT, )
  OGLM_AVAIL_CHECK(__glewImportSemaphoreWin32HandleEXT, glImportSemaphoreWin32HandleEXT)
  glImportSemaphoreWin32HandleEXT(semaphore, handleType, handle);
  OGLM_CHECK_ERR(glImportSemaphoreWin32HandleEXT, )

void
glImportSemaphoreWin32NameEXT_c(semaphore, handleType, name)
  GLuint semaphore;
  GLenum handleType;
  const void *name;
CODE:
  OGLM_GLEWINIT
  OGLM_CHECK_ERR(glImportSemaphoreWin32NameEXT, )
  OGLM_AVAIL_CHECK(__glewImportSemaphoreWin32NameEXT, glImportSemaphoreWin32NameEXT)
  glImportSemaphoreWin32NameEXT(semaphore, handleType, name);
  OGLM_CHECK_ERR(glImportSemaphoreWin32NameEXT, )

GLsync
glImportSyncEXT(external_sync_type, external_sync, flags)
  GLenum external_sync_type;
  GLintptr external_sync;
  GLbitfield flags;
CODE:
  OGLM_GLEWINIT
  OGLM_CHECK_ERR(glImportSyncEXT, )
  OGLM_AVAIL_CHECK(__glewImportSyncEXT, glImportSyncEXT)
  RETVAL = glImportSyncEXT(external_sync_type, external_sync, flags);
  OGLM_CHECK_ERR(glImportSyncEXT, )
OUTPUT:
  RETVAL

void
glIndexFormatNV(type, stride)
  GLenum type;
  GLsizei stride;
CODE:
  OGLM_GLEWINIT
  OGLM_CHECK_ERR(glIndexFormatNV, )
  OGLM_AVAIL_CHECK(__glewIndexFormatNV, glIndexFormatNV)
  glIndexFormatNV(type, stride);
  OGLM_CHECK_ERR(glIndexFormatNV, )

void
glIndexFuncEXT(func, ref)
  GLenum func;
  GLfloat ref;
CODE:
  OGLM_GLEWINIT
  OGLM_CHECK_ERR(glIndexFuncEXT, )
  OGLM_AVAIL_CHECK(__glewIndexFuncEXT, glIndexFuncEXT)
  glIndexFuncEXT(func, ref);
  OGLM_CHECK_ERR(glIndexFuncEXT, )

void
glIndexMask(mask)
  GLuint mask;
CODE:
  OGLM_GLEWINIT
  OGLM_CHECK_ERR(glIndexMask, )
  glIndexMask(mask);
  OGLM_CHECK_ERR(glIndexMask, )

void
glIndexMaterialEXT(face, mode)
  GLenum face;
  GLenum mode;
CODE:
  OGLM_GLEWINIT
  OGLM_CHECK_ERR(glIndexMaterialEXT, )
  OGLM_AVAIL_CHECK(__glewIndexMaterialEXT, glIndexMaterialEXT)
  glIndexMaterialEXT(face, mode);
  OGLM_CHECK_ERR(glIndexMaterialEXT, )

void
glIndexPointer_c(type, stride, pointer)
  GLenum type;
  GLsizei stride;
  const void *pointer;
CODE:
  OGLM_GLEWINIT
  OGLM_CHECK_ERR(glIndexPointer, )
  glIndexPointer(type, stride, pointer);
  OGLM_CHECK_ERR(glIndexPointer, )

void
glIndexPointerEXT_c(type, stride, count, pointer)
  GLenum type;
  GLsizei stride;
  GLsizei count;
  const void *pointer;
CODE:
  OGLM_GLEWINIT
  OGLM_CHECK_ERR(glIndexPointerEXT, )
  OGLM_AVAIL_CHECK(__glewIndexPointerEXT, glIndexPointerEXT)
  glIndexPointerEXT(type, stride, count, pointer);
  OGLM_CHECK_ERR(glIndexPointerEXT, )

void
glIndexPointerListIBM_c(type, stride, pointer, ptrstride)
  GLenum type;
  GLint stride;
  const void** pointer;
  GLint ptrstride;
CODE:
  OGLM_GLEWINIT
  OGLM_CHECK_ERR(glIndexPointerListIBM, )
  OGLM_AVAIL_CHECK(__glewIndexPointerListIBM, glIndexPointerListIBM)
  glIndexPointerListIBM(type, stride, pointer, ptrstride);
  OGLM_CHECK_ERR(glIndexPointerListIBM, )

void
glIndexd(c)
  GLdouble c;
CODE:
  OGLM_GLEWINIT
  OGLM_CHECK_ERR(glIndexd, )
  glIndexd(c);
  OGLM_CHECK_ERR(glIndexd, )

void
glIndexdv_c(c)
  const GLdouble *c;
CODE:
  OGLM_GLEWINIT
  OGLM_CHECK_ERR(glIndexdv, )
  glIndexdv(c);
  OGLM_CHECK_ERR(glIndexdv, )

void
glIndexdv_p(...)
CODE:
  OGLM_GLEWINIT
  OGLM_CHECK_ERR(glIndexdv, )
  GLdouble *c = OGLM_GET_VARARGS(c,0,GLdouble,NV,1);
  glIndexdv((const GLdouble *)c);
  OGLM_CHECK_ERR(glIndexdv, free(c);)
  free(c);

void
glIndexf(c)
  GLfloat c;
CODE:
  OGLM_GLEWINIT
  OGLM_CHECK_ERR(glIndexf, )
  glIndexf(c);
  OGLM_CHECK_ERR(glIndexf, )

void
glIndexfv_c(c)
  const GLfloat *c;
CODE:
  OGLM_GLEWINIT
  OGLM_CHECK_ERR(glIndexfv, )
  glIndexfv(c);
  OGLM_CHECK_ERR(glIndexfv, )

void
glIndexfv_p(...)
CODE:
  OGLM_GLEWINIT
  OGLM_CHECK_ERR(glIndexfv, )
  GLfloat *c = OGLM_GET_VARARGS(c,0,GLfloat,NV,1);
  glIndexfv((const GLfloat *)c);
  OGLM_CHECK_ERR(glIndexfv, free(c);)
  free(c);

void
glIndexi(c)
  GLint c;
CODE:
  OGLM_GLEWINIT
  OGLM_CHECK_ERR(glIndexi, )
  glIndexi(c);
  OGLM_CHECK_ERR(glIndexi, )

void
glIndexiv_c(c)
  const GLint *c;
CODE:
  OGLM_GLEWINIT
  OGLM_CHECK_ERR(glIndexiv, )
  glIndexiv(c);
  OGLM_CHECK_ERR(glIndexiv, )

void
glIndexiv_p(...)
CODE:
  OGLM_GLEWINIT
  OGLM_CHECK_ERR(glIndexiv, )
  GLint *c = OGLM_GET_VARARGS(c,0,GLint,IV,1);
  glIndexiv((const GLint *)c);
  OGLM_CHECK_ERR(glIndexiv, free(c);)
  free(c);

void
glIndexs(c)
  GLshort c;
CODE:
  OGLM_GLEWINIT
  OGLM_CHECK_ERR(glIndexs, )
  glIndexs(c);
  OGLM_CHECK_ERR(glIndexs, )

void
glIndexsv_c(c)
  const GLshort *c;
CODE:
  OGLM_GLEWINIT
  OGLM_CHECK_ERR(glIndexsv, )
  glIndexsv(c);
  OGLM_CHECK_ERR(glIndexsv, )

void
glIndexsv_p(...)
CODE:
  OGLM_GLEWINIT
  OGLM_CHECK_ERR(glIndexsv, )
  GLshort *c = OGLM_GET_VARARGS(c,0,GLshort,IV,1);
  glIndexsv((const GLshort *)c);
  OGLM_CHECK_ERR(glIndexsv, free(c);)
  free(c);

void
glIndexub(c)
  GLubyte c;
CODE:
  OGLM_GLEWINIT
  OGLM_CHECK_ERR(glIndexub, )
  glIndexub(c);
  OGLM_CHECK_ERR(glIndexub, )

void
glIndexubv_c(c)
  const GLubyte *c;
CODE:
  OGLM_GLEWINIT
  OGLM_CHECK_ERR(glIndexubv, )
  glIndexubv(c);
  OGLM_CHECK_ERR(glIndexubv, )

void
glIndexubv_p(...)
CODE:
  OGLM_GLEWINIT
  OGLM_CHECK_ERR(glIndexubv, )
  GLubyte *c = OGLM_GET_VARARGS(c,0,GLubyte,UV,1);
  glIndexubv((const GLubyte *)c);
  OGLM_CHECK_ERR(glIndexubv, free(c);)
  free(c);

void
glInitNames()
CODE:
  OGLM_GLEWINIT
  OGLM_CHECK_ERR(glInitNames, )
  glInitNames();
  OGLM_CHECK_ERR(glInitNames, )

void
glInsertComponentEXT(res, src, num)
  GLuint res;
  GLuint src;
  GLuint num;
CODE:
  OGLM_GLEWINIT
  OGLM_CHECK_ERR(glInsertComponentEXT, )
  OGLM_AVAIL_CHECK(__glewInsertComponentEXT, glInsertComponentEXT)
  glInsertComponentEXT(res, src, num);
  OGLM_CHECK_ERR(glInsertComponentEXT, )

void
glInsertEventMarkerEXT(length, marker)
  GLsizei length;
  const GLchar* marker;
CODE:
  OGLM_GLEWINIT
  OGLM_CHECK_ERR(glInsertEventMarkerEXT, )
  OGLM_AVAIL_CHECK(__glewInsertEventMarkerEXT, glInsertEventMarkerEXT)
  glInsertEventMarkerEXT(length, marker);
  OGLM_CHECK_ERR(glInsertEventMarkerEXT, )

void
glInterleavedArrays_c(format, stride, pointer)
  GLenum format;
  GLsizei stride;
  const void *pointer;
CODE:
  OGLM_GLEWINIT
  OGLM_CHECK_ERR(glInterleavedArrays, )
  glInterleavedArrays(format, stride, pointer);
  OGLM_CHECK_ERR(glInterleavedArrays, )

void
glInterleavedTextureCoordSetsSGIS(factor)
  GLint factor;
CODE:
  OGLM_GLEWINIT
  OGLM_CHECK_ERR(glInterleavedTextureCoordSetsSGIS, )
  OGLM_AVAIL_CHECK(__glewInterleavedTextureCoordSetsSGIS, glInterleavedTextureCoordSetsSGIS)
  glInterleavedTextureCoordSetsSGIS(factor);
  OGLM_CHECK_ERR(glInterleavedTextureCoordSetsSGIS, )

void
glInterpolatePathsNV(resultPath, pathA, pathB, weight)
  GLuint resultPath;
  GLuint pathA;
  GLuint pathB;
  GLfloat weight;
CODE:
  OGLM_GLEWINIT
  OGLM_CHECK_ERR(glInterpolatePathsNV, )
  OGLM_AVAIL_CHECK(__glewInterpolatePathsNV, glInterpolatePathsNV)
  glInterpolatePathsNV(resultPath, pathA, pathB, weight);
  OGLM_CHECK_ERR(glInterpolatePathsNV, )

void
glInvalidateBufferData(buffer)
  GLuint buffer;
CODE:
  OGLM_GLEWINIT
  OGLM_CHECK_ERR(glInvalidateBufferData, )
  OGLM_AVAIL_CHECK(__glewInvalidateBufferData, glInvalidateBufferData)
  glInvalidateBufferData(buffer);
  OGLM_CHECK_ERR(glInvalidateBufferData, )

void
glInvalidateBufferSubData(buffer, offset, length)
  GLuint buffer;
  GLintptr offset;
  GLsizeiptr length;
CODE:
  OGLM_GLEWINIT
  OGLM_CHECK_ERR(glInvalidateBufferSubData, )
  OGLM_AVAIL_CHECK(__glewInvalidateBufferSubData, glInvalidateBufferSubData)
  glInvalidateBufferSubData(buffer, offset, length);
  OGLM_CHECK_ERR(glInvalidateBufferSubData, )

void
glInvalidateFramebuffer_c(target, numAttachments, attachments)
  GLenum target;
  GLsizei numAttachments;
  const GLenum* attachments;
CODE:
  OGLM_GLEWINIT
  OGLM_CHECK_ERR(glInvalidateFramebuffer, )
  OGLM_AVAIL_CHECK(__glewInvalidateFramebuffer, glInvalidateFramebuffer)
  glInvalidateFramebuffer(target, numAttachments, attachments);
  OGLM_CHECK_ERR(glInvalidateFramebuffer, )

void
glInvalidateFramebuffer_p(target, ...)
  GLenum target;
CODE:
  OGLM_GLEWINIT
  OGLM_CHECK_ERR(glInvalidateFramebuffer, )
  OGLM_AVAIL_CHECK(__glewInvalidateFramebuffer, glInvalidateFramebuffer)
  GLsizei numAttachments = items-1;
  GLenum* attachments = OGLM_GET_VARARGS(attachments,1,GLenum,IV,numAttachments);
  glInvalidateFramebuffer((GLenum )target, (GLsizei )numAttachments, (const GLenum* )attachments);
  OGLM_CHECK_ERR(glInvalidateFramebuffer, free(attachments);)
  free(attachments);

void
glInvalidateNamedFramebufferData_c(framebuffer, numAttachments, attachments)
  GLuint framebuffer;
  GLsizei numAttachments;
  const GLenum* attachments;
CODE:
  OGLM_GLEWINIT
  OGLM_CHECK_ERR(glInvalidateNamedFramebufferData, )
  OGLM_AVAIL_CHECK(__glewInvalidateNamedFramebufferData, glInvalidateNamedFramebufferData)
  glInvalidateNamedFramebufferData(framebuffer, numAttachments, attachments);
  OGLM_CHECK_ERR(glInvalidateNamedFramebufferData, )

void
glInvalidateNamedFramebufferData_p(framebuffer, ...)
  GLuint framebuffer;
CODE:
  OGLM_GLEWINIT
  OGLM_CHECK_ERR(glInvalidateNamedFramebufferData, )
  OGLM_AVAIL_CHECK(__glewInvalidateNamedFramebufferData, glInvalidateNamedFramebufferData)
  GLsizei numAttachments = items-1;
  GLenum* attachments = OGLM_GET_VARARGS(attachments,1,GLenum,IV,numAttachments);
  glInvalidateNamedFramebufferData((GLuint )framebuffer, (GLsizei )numAttachments, (const GLenum* )attachments);
  OGLM_CHECK_ERR(glInvalidateNamedFramebufferData, free(attachments);)
  free(attachments);

void
glInvalidateNamedFramebufferSubData_c(framebuffer, numAttachments, attachments, x, y, width, height)
  GLuint framebuffer;
  GLsizei numAttachments;
  const GLenum* attachments;
  GLint x;
  GLint y;
  GLsizei width;
  GLsizei height;
CODE:
  OGLM_GLEWINIT
  OGLM_CHECK_ERR(glInvalidateNamedFramebufferSubData, )
  OGLM_AVAIL_CHECK(__glewInvalidateNamedFramebufferSubData, glInvalidateNamedFramebufferSubData)
  glInvalidateNamedFramebufferSubData(framebuffer, numAttachments, attachments, x, y, width, height);
  OGLM_CHECK_ERR(glInvalidateNamedFramebufferSubData, )

void
glInvalidateNamedFramebufferSubData_p(framebuffer, x, y, width, height, ...)
  GLuint framebuffer;
  GLint x;
  GLint y;
  GLsizei width;
  GLsizei height;
CODE:
  OGLM_GLEWINIT
  OGLM_CHECK_ERR(glInvalidateNamedFramebufferSubData, )
  OGLM_AVAIL_CHECK(__glewInvalidateNamedFramebufferSubData, glInvalidateNamedFramebufferSubData)
  GLsizei numAttachments = items-5;
  GLenum* attachments = OGLM_GET_VARARGS(attachments,5,GLenum,IV,numAttachments);
  glInvalidateNamedFramebufferSubData((GLuint )framebuffer, (GLsizei )numAttachments, (const GLenum* )attachments, (GLint )x, (GLint )y, (GLsizei )width, (GLsizei )height);
  OGLM_CHECK_ERR(glInvalidateNamedFramebufferSubData, free(attachments);)
  free(attachments);

void
glInvalidateSubFramebuffer_c(target, numAttachments, attachments, x, y, width, height)
  GLenum target;
  GLsizei numAttachments;
  const GLenum* attachments;
  GLint x;
  GLint y;
  GLsizei width;
  GLsizei height;
CODE:
  OGLM_GLEWINIT
  OGLM_CHECK_ERR(glInvalidateSubFramebuffer, )
  OGLM_AVAIL_CHECK(__glewInvalidateSubFramebuffer, glInvalidateSubFramebuffer)
  glInvalidateSubFramebuffer(target, numAttachments, attachments, x, y, width, height);
  OGLM_CHECK_ERR(glInvalidateSubFramebuffer, )

void
glInvalidateSubFramebuffer_p(target, x, y, width, height, ...)
  GLenum target;
  GLint x;
  GLint y;
  GLsizei width;
  GLsizei height;
CODE:
  OGLM_GLEWINIT
  OGLM_CHECK_ERR(glInvalidateSubFramebuffer, )
  OGLM_AVAIL_CHECK(__glewInvalidateSubFramebuffer, glInvalidateSubFramebuffer)
  GLsizei numAttachments = items-5;
  GLenum* attachments = OGLM_GET_VARARGS(attachments,5,GLenum,IV,numAttachments);
  glInvalidateSubFramebuffer((GLenum )target, (GLsizei )numAttachments, (const GLenum* )attachments, (GLint )x, (GLint )y, (GLsizei )width, (GLsizei )height);
  OGLM_CHECK_ERR(glInvalidateSubFramebuffer, free(attachments);)
  free(attachments);

void
glInvalidateTexImage(texture, level)
  GLuint texture;
  GLint level;
CODE:
  OGLM_GLEWINIT
  OGLM_CHECK_ERR(glInvalidateTexImage, )
  OGLM_AVAIL_CHECK(__glewInvalidateTexImage, glInvalidateTexImage)
  glInvalidateTexImage(texture, level);
  OGLM_CHECK_ERR(glInvalidateTexImage, )

void
glInvalidateTexSubImage(texture, level, xoffset, yoffset, zoffset, width, height, depth)
  GLuint texture;
  GLint level;
  GLint xoffset;
  GLint yoffset;
  GLint zoffset;
  GLsizei width;
  GLsizei height;
  GLsizei depth;
CODE:
  OGLM_GLEWINIT
  OGLM_CHECK_ERR(glInvalidateTexSubImage, )
  OGLM_AVAIL_CHECK(__glewInvalidateTexSubImage, glInvalidateTexSubImage)
  glInvalidateTexSubImage(texture, level, xoffset, yoffset, zoffset, width, height, depth);
  OGLM_CHECK_ERR(glInvalidateTexSubImage, )

GLboolean
glIsAsyncMarkerSGIX(marker)
  GLuint marker;
CODE:
  OGLM_GLEWINIT
  OGLM_CHECK_ERR(glIsAsyncMarkerSGIX, )
  OGLM_AVAIL_CHECK(__glewIsAsyncMarkerSGIX, glIsAsyncMarkerSGIX)
  RETVAL = glIsAsyncMarkerSGIX(marker);
  OGLM_CHECK_ERR(glIsAsyncMarkerSGIX, )
OUTPUT:
  RETVAL

GLboolean
glIsBuffer(buffer)
  GLuint buffer;
ALIAS:
  glIsBufferARB = 1
CODE:
  OGLM_GLEWINIT
  OGLM_CHECK_ERR(glIsBuffer, )
  OGLM_AVAIL_CHECK(__glewIsBuffer, glIsBuffer)
  RETVAL = glIsBuffer(buffer);
  OGLM_CHECK_ERR(glIsBuffer, )
OUTPUT:
  RETVAL

GLboolean
glIsBufferResidentNV(target)
  GLenum target;
CODE:
  OGLM_GLEWINIT
  OGLM_CHECK_ERR(glIsBufferResidentNV, )
  OGLM_AVAIL_CHECK(__glewIsBufferResidentNV, glIsBufferResidentNV)
  RETVAL = glIsBufferResidentNV(target);
  OGLM_CHECK_ERR(glIsBufferResidentNV, )
OUTPUT:
  RETVAL

GLboolean
glIsCommandListNV(list)
  GLuint list;
CODE:
  OGLM_GLEWINIT
  OGLM_CHECK_ERR(glIsCommandListNV, )
  OGLM_AVAIL_CHECK(__glewIsCommandListNV, glIsCommandListNV)
  RETVAL = glIsCommandListNV(list);
  OGLM_CHECK_ERR(glIsCommandListNV, )
OUTPUT:
  RETVAL

GLboolean
glIsEnabled(cap)
  GLenum cap;
CODE:
  OGLM_GLEWINIT
  OGLM_CHECK_ERR(glIsEnabled, )
  RETVAL = glIsEnabled(cap);
  OGLM_CHECK_ERR(glIsEnabled, )
OUTPUT:
  RETVAL

GLboolean
glIsEnabledi(target, index)
  GLenum target;
  GLuint index;
ALIAS:
  glIsEnabledIndexedEXT = 1
  glIsEnablediEXT = 2
  glIsEnablediNV = 3
CODE:
  OGLM_GLEWINIT
  OGLM_CHECK_ERR(glIsEnabledi, )
  OGLM_AVAIL_CHECK(__glewIsEnabledi, glIsEnabledi)
  RETVAL = glIsEnabledi(target, index);
  OGLM_CHECK_ERR(glIsEnabledi, )
OUTPUT:
  RETVAL

GLboolean
glIsEnablediOES(target, index)
  GLenum target;
  GLuint index;
CODE:
  OGLM_GLEWINIT
  OGLM_CHECK_ERR(glIsEnablediOES, )
  OGLM_AVAIL_CHECK(__glewIsEnablediOES, glIsEnablediOES)
  RETVAL = glIsEnablediOES(target, index);
  OGLM_CHECK_ERR(glIsEnablediOES, )
OUTPUT:
  RETVAL

GLboolean
glIsFenceAPPLE(fence)
  GLuint fence;
CODE:
  OGLM_GLEWINIT
  OGLM_CHECK_ERR(glIsFenceAPPLE, )
  OGLM_AVAIL_CHECK(__glewIsFenceAPPLE, glIsFenceAPPLE)
  RETVAL = glIsFenceAPPLE(fence);
  OGLM_CHECK_ERR(glIsFenceAPPLE, )
OUTPUT:
  RETVAL

GLboolean
glIsFenceNV(fence)
  GLuint fence;
CODE:
  OGLM_GLEWINIT
  OGLM_CHECK_ERR(glIsFenceNV, )
  OGLM_AVAIL_CHECK(__glewIsFenceNV, glIsFenceNV)
  RETVAL = glIsFenceNV(fence);
  OGLM_CHECK_ERR(glIsFenceNV, )
OUTPUT:
  RETVAL

GLboolean
glIsFramebuffer(framebuffer)
  GLuint framebuffer;
ALIAS:
  glIsFramebufferEXT = 1
CODE:
  OGLM_GLEWINIT
  OGLM_CHECK_ERR(glIsFramebuffer, )
  OGLM_AVAIL_CHECK(__glewIsFramebuffer, glIsFramebuffer)
  RETVAL = glIsFramebuffer(framebuffer);
  OGLM_CHECK_ERR(glIsFramebuffer, )
OUTPUT:
  RETVAL

GLboolean
glIsFramebufferOES(framebuffer)
  GLuint framebuffer;
CODE:
  OGLM_GLEWINIT
  OGLM_CHECK_ERR(glIsFramebufferOES, )
  OGLM_AVAIL_CHECK(__glewIsFramebufferOES, glIsFramebufferOES)
  RETVAL = glIsFramebufferOES(framebuffer);
  OGLM_CHECK_ERR(glIsFramebufferOES, )
OUTPUT:
  RETVAL

GLboolean
glIsImageHandleResidentARB(handle)
  GLuint64 handle;
CODE:
  OGLM_GLEWINIT
  OGLM_CHECK_ERR(glIsImageHandleResidentARB, )
  OGLM_AVAIL_CHECK(__glewIsImageHandleResidentARB, glIsImageHandleResidentARB)
  RETVAL = glIsImageHandleResidentARB(handle);
  OGLM_CHECK_ERR(glIsImageHandleResidentARB, )
OUTPUT:
  RETVAL

GLboolean
glIsImageHandleResidentNV(handle)
  GLuint64 handle;
CODE:
  OGLM_GLEWINIT
  OGLM_CHECK_ERR(glIsImageHandleResidentNV, )
  OGLM_AVAIL_CHECK(__glewIsImageHandleResidentNV, glIsImageHandleResidentNV)
  RETVAL = glIsImageHandleResidentNV(handle);
  OGLM_CHECK_ERR(glIsImageHandleResidentNV, )
OUTPUT:
  RETVAL

GLboolean
glIsList(list)
  GLuint list;
CODE:
  OGLM_GLEWINIT
  OGLM_CHECK_ERR(glIsList, )
  RETVAL = glIsList(list);
  OGLM_CHECK_ERR(glIsList, )
OUTPUT:
  RETVAL

GLboolean
glIsMPEGPredictorSGIX(predictor)
  GLuint predictor;
CODE:
  OGLM_GLEWINIT
  OGLM_CHECK_ERR(glIsMPEGPredictorSGIX, )
  OGLM_AVAIL_CHECK(__glewIsMPEGPredictorSGIX, glIsMPEGPredictorSGIX)
  RETVAL = glIsMPEGPredictorSGIX(predictor);
  OGLM_CHECK_ERR(glIsMPEGPredictorSGIX, )
OUTPUT:
  RETVAL

GLboolean
glIsMemoryObjectEXT(memoryObject)
  GLuint memoryObject;
CODE:
  OGLM_GLEWINIT
  OGLM_CHECK_ERR(glIsMemoryObjectEXT, )
  OGLM_AVAIL_CHECK(__glewIsMemoryObjectEXT, glIsMemoryObjectEXT)
  RETVAL = glIsMemoryObjectEXT(memoryObject);
  OGLM_CHECK_ERR(glIsMemoryObjectEXT, )
OUTPUT:
  RETVAL

GLboolean
glIsNameAMD(identifier, name)
  GLenum identifier;
  GLuint name;
CODE:
  OGLM_GLEWINIT
  OGLM_CHECK_ERR(glIsNameAMD, )
  OGLM_AVAIL_CHECK(__glewIsNameAMD, glIsNameAMD)
  RETVAL = glIsNameAMD(identifier, name);
  OGLM_CHECK_ERR(glIsNameAMD, )
OUTPUT:
  RETVAL

GLboolean
glIsNamedBufferResidentNV(buffer)
  GLuint buffer;
CODE:
  OGLM_GLEWINIT
  OGLM_CHECK_ERR(glIsNamedBufferResidentNV, )
  OGLM_AVAIL_CHECK(__glewIsNamedBufferResidentNV, glIsNamedBufferResidentNV)
  RETVAL = glIsNamedBufferResidentNV(buffer);
  OGLM_CHECK_ERR(glIsNamedBufferResidentNV, )
OUTPUT:
  RETVAL

GLboolean
glIsNamedStringARB(namelen, name)
  GLint namelen;
  const GLchar* name;
CODE:
  OGLM_GLEWINIT
  OGLM_CHECK_ERR(glIsNamedStringARB, )
  OGLM_AVAIL_CHECK(__glewIsNamedStringARB, glIsNamedStringARB)
  RETVAL = glIsNamedStringARB(namelen, name);
  OGLM_CHECK_ERR(glIsNamedStringARB, )
OUTPUT:
  RETVAL

GLboolean
glIsObjectBufferATI(buffer)
  GLuint buffer;
CODE:
  OGLM_GLEWINIT
  OGLM_CHECK_ERR(glIsObjectBufferATI, )
  OGLM_AVAIL_CHECK(__glewIsObjectBufferATI, glIsObjectBufferATI)
  RETVAL = glIsObjectBufferATI(buffer);
  OGLM_CHECK_ERR(glIsObjectBufferATI, )
OUTPUT:
  RETVAL

GLboolean
glIsOcclusionQueryNV(id)
  GLuint id;
CODE:
  OGLM_GLEWINIT
  OGLM_CHECK_ERR(glIsOcclusionQueryNV, )
  OGLM_AVAIL_CHECK(__glewIsOcclusionQueryNV, glIsOcclusionQueryNV)
  RETVAL = glIsOcclusionQueryNV(id);
  OGLM_CHECK_ERR(glIsOcclusionQueryNV, )
OUTPUT:
  RETVAL

GLboolean
glIsPathNV(path)
  GLuint path;
CODE:
  OGLM_GLEWINIT
  OGLM_CHECK_ERR(glIsPathNV, )
  OGLM_AVAIL_CHECK(__glewIsPathNV, glIsPathNV)
  RETVAL = glIsPathNV(path);
  OGLM_CHECK_ERR(glIsPathNV, )
OUTPUT:
  RETVAL

GLboolean
glIsPointInFillPathNV(path, mask, x, y)
  GLuint path;
  GLuint mask;
  GLfloat x;
  GLfloat y;
CODE:
  OGLM_GLEWINIT
  OGLM_CHECK_ERR(glIsPointInFillPathNV, )
  OGLM_AVAIL_CHECK(__glewIsPointInFillPathNV, glIsPointInFillPathNV)
  RETVAL = glIsPointInFillPathNV(path, mask, x, y);
  OGLM_CHECK_ERR(glIsPointInFillPathNV, )
OUTPUT:
  RETVAL

GLboolean
glIsPointInStrokePathNV(path, x, y)
  GLuint path;
  GLfloat x;
  GLfloat y;
CODE:
  OGLM_GLEWINIT
  OGLM_CHECK_ERR(glIsPointInStrokePathNV, )
  OGLM_AVAIL_CHECK(__glewIsPointInStrokePathNV, glIsPointInStrokePathNV)
  RETVAL = glIsPointInStrokePathNV(path, x, y);
  OGLM_CHECK_ERR(glIsPointInStrokePathNV, )
OUTPUT:
  RETVAL

GLboolean
glIsProgram(program)
  GLuint program;
CODE:
  OGLM_GLEWINIT
  OGLM_CHECK_ERR(glIsProgram, )
  OGLM_AVAIL_CHECK(__glewIsProgram, glIsProgram)
  RETVAL = glIsProgram(program);
  OGLM_CHECK_ERR(glIsProgram, )
OUTPUT:
  RETVAL

GLboolean
glIsProgramARB(program)
  GLuint program;
ALIAS:
  glIsProgramNV = 1
CODE:
  OGLM_GLEWINIT
  OGLM_CHECK_ERR(glIsProgramARB, )
  OGLM_AVAIL_CHECK(__glewIsProgramARB, glIsProgramARB)
  RETVAL = glIsProgramARB(program);
  OGLM_CHECK_ERR(glIsProgramARB, )
OUTPUT:
  RETVAL

GLboolean
glIsProgramPipeline(pipeline)
  GLuint pipeline;
CODE:
  OGLM_GLEWINIT
  OGLM_CHECK_ERR(glIsProgramPipeline, )
  OGLM_AVAIL_CHECK(__glewIsProgramPipeline, glIsProgramPipeline)
  RETVAL = glIsProgramPipeline(pipeline);
  OGLM_CHECK_ERR(glIsProgramPipeline, )
OUTPUT:
  RETVAL

GLboolean
glIsQuery(id)
  GLuint id;
ALIAS:
  glIsQueryARB = 1
CODE:
  OGLM_GLEWINIT
  OGLM_CHECK_ERR(glIsQuery, )
  OGLM_AVAIL_CHECK(__glewIsQuery, glIsQuery)
  RETVAL = glIsQuery(id);
  OGLM_CHECK_ERR(glIsQuery, )
OUTPUT:
  RETVAL

GLboolean
glIsQueryANGLE(id)
  GLuint id;
CODE:
  OGLM_GLEWINIT
  OGLM_CHECK_ERR(glIsQueryANGLE, )
  OGLM_AVAIL_CHECK(__glewIsQueryANGLE, glIsQueryANGLE)
  RETVAL = glIsQueryANGLE(id);
  OGLM_CHECK_ERR(glIsQueryANGLE, )
OUTPUT:
  RETVAL

GLboolean
glIsQueryEXT(id)
  GLuint id;
CODE:
  OGLM_GLEWINIT
  OGLM_CHECK_ERR(glIsQueryEXT, )
  OGLM_AVAIL_CHECK(__glewIsQueryEXT, glIsQueryEXT)
  RETVAL = glIsQueryEXT(id);
  OGLM_CHECK_ERR(glIsQueryEXT, )
OUTPUT:
  RETVAL

GLboolean
glIsRenderbuffer(renderbuffer)
  GLuint renderbuffer;
ALIAS:
  glIsRenderbufferEXT = 1
CODE:
  OGLM_GLEWINIT
  OGLM_CHECK_ERR(glIsRenderbuffer, )
  OGLM_AVAIL_CHECK(__glewIsRenderbuffer, glIsRenderbuffer)
  RETVAL = glIsRenderbuffer(renderbuffer);
  OGLM_CHECK_ERR(glIsRenderbuffer, )
OUTPUT:
  RETVAL

GLboolean
glIsRenderbufferOES(renderbuffer)
  GLuint renderbuffer;
CODE:
  OGLM_GLEWINIT
  OGLM_CHECK_ERR(glIsRenderbufferOES, )
  OGLM_AVAIL_CHECK(__glewIsRenderbufferOES, glIsRenderbufferOES)
  RETVAL = glIsRenderbufferOES(renderbuffer);
  OGLM_CHECK_ERR(glIsRenderbufferOES, )
OUTPUT:
  RETVAL

GLboolean
glIsSampler(sampler)
  GLuint sampler;
CODE:
  OGLM_GLEWINIT
  OGLM_CHECK_ERR(glIsSampler, )
  OGLM_AVAIL_CHECK(__glewIsSampler, glIsSampler)
  RETVAL = glIsSampler(sampler);
  OGLM_CHECK_ERR(glIsSampler, )
OUTPUT:
  RETVAL

GLboolean
glIsSemaphoreEXT(semaphore)
  GLuint semaphore;
CODE:
  OGLM_GLEWINIT
  OGLM_CHECK_ERR(glIsSemaphoreEXT, )
  OGLM_AVAIL_CHECK(__glewIsSemaphoreEXT, glIsSemaphoreEXT)
  RETVAL = glIsSemaphoreEXT(semaphore);
  OGLM_CHECK_ERR(glIsSemaphoreEXT, )
OUTPUT:
  RETVAL

GLboolean
glIsShader(shader)
  GLuint shader;
CODE:
  OGLM_GLEWINIT
  OGLM_CHECK_ERR(glIsShader, )
  OGLM_AVAIL_CHECK(__glewIsShader, glIsShader)
  RETVAL = glIsShader(shader);
  OGLM_CHECK_ERR(glIsShader, )
OUTPUT:
  RETVAL

GLboolean
glIsStateNV(state)
  GLuint state;
CODE:
  OGLM_GLEWINIT
  OGLM_CHECK_ERR(glIsStateNV, )
  OGLM_AVAIL_CHECK(__glewIsStateNV, glIsStateNV)
  RETVAL = glIsStateNV(state);
  OGLM_CHECK_ERR(glIsStateNV, )
OUTPUT:
  RETVAL

GLboolean
glIsSupportedREGAL(ext)
  const GLchar* ext;
CODE:
  OGLM_GLEWINIT
  OGLM_CHECK_ERR(glIsSupportedREGAL, )
  OGLM_AVAIL_CHECK(__glewIsSupportedREGAL, glIsSupportedREGAL)
  RETVAL = glIsSupportedREGAL(ext);
  OGLM_CHECK_ERR(glIsSupportedREGAL, )
OUTPUT:
  RETVAL

GLboolean
glIsSync(myGLsync)
  GLsync myGLsync;
ALIAS:
  glIsSyncAPPLE = 1
CODE:
  OGLM_GLEWINIT
  OGLM_CHECK_ERR(glIsSync, )
  OGLM_AVAIL_CHECK(__glewIsSync, glIsSync)
  RETVAL = glIsSync(myGLsync);
  OGLM_CHECK_ERR(glIsSync, )
OUTPUT:
  RETVAL

GLboolean
glIsTexture(texture)
  GLuint texture;
CODE:
  OGLM_GLEWINIT
  OGLM_CHECK_ERR(glIsTexture, )
  RETVAL = glIsTexture(texture);
  OGLM_CHECK_ERR(glIsTexture, )
OUTPUT:
  RETVAL

GLboolean
glIsTextureEXT(texture)
  GLuint texture;
CODE:
  OGLM_GLEWINIT
  OGLM_CHECK_ERR(glIsTextureEXT, )
  OGLM_AVAIL_CHECK(__glewIsTextureEXT, glIsTextureEXT)
  RETVAL = glIsTextureEXT(texture);
  OGLM_CHECK_ERR(glIsTextureEXT, )
OUTPUT:
  RETVAL

GLboolean
glIsTextureHandleResidentARB(handle)
  GLuint64 handle;
CODE:
  OGLM_GLEWINIT
  OGLM_CHECK_ERR(glIsTextureHandleResidentARB, )
  OGLM_AVAIL_CHECK(__glewIsTextureHandleResidentARB, glIsTextureHandleResidentARB)
  RETVAL = glIsTextureHandleResidentARB(handle);
  OGLM_CHECK_ERR(glIsTextureHandleResidentARB, )
OUTPUT:
  RETVAL

GLboolean
glIsTextureHandleResidentNV(handle)
  GLuint64 handle;
CODE:
  OGLM_GLEWINIT
  OGLM_CHECK_ERR(glIsTextureHandleResidentNV, )
  OGLM_AVAIL_CHECK(__glewIsTextureHandleResidentNV, glIsTextureHandleResidentNV)
  RETVAL = glIsTextureHandleResidentNV(handle);
  OGLM_CHECK_ERR(glIsTextureHandleResidentNV, )
OUTPUT:
  RETVAL

GLboolean
glIsTransformFeedback(id)
  GLuint id;
ALIAS:
  glIsTransformFeedbackNV = 1
CODE:
  OGLM_GLEWINIT
  OGLM_CHECK_ERR(glIsTransformFeedback, )
  OGLM_AVAIL_CHECK(__glewIsTransformFeedback, glIsTransformFeedback)
  RETVAL = glIsTransformFeedback(id);
  OGLM_CHECK_ERR(glIsTransformFeedback, )
OUTPUT:
  RETVAL

GLboolean
glIsVariantEnabledEXT(id, cap)
  GLuint id;
  GLenum cap;
CODE:
  OGLM_GLEWINIT
  OGLM_CHECK_ERR(glIsVariantEnabledEXT, )
  OGLM_AVAIL_CHECK(__glewIsVariantEnabledEXT, glIsVariantEnabledEXT)
  RETVAL = glIsVariantEnabledEXT(id, cap);
  OGLM_CHECK_ERR(glIsVariantEnabledEXT, )
OUTPUT:
  RETVAL

GLboolean
glIsVertexArray(array)
  GLuint array;
ALIAS:
  glIsVertexArrayAPPLE = 1
CODE:
  OGLM_GLEWINIT
  OGLM_CHECK_ERR(glIsVertexArray, )
  OGLM_AVAIL_CHECK(__glewIsVertexArray, glIsVertexArray)
  RETVAL = glIsVertexArray(array);
  OGLM_CHECK_ERR(glIsVertexArray, )
OUTPUT:
  RETVAL

GLboolean
glIsVertexArrayOES(array)
  GLuint array;
CODE:
  OGLM_GLEWINIT
  OGLM_CHECK_ERR(glIsVertexArrayOES, )
  OGLM_AVAIL_CHECK(__glewIsVertexArrayOES, glIsVertexArrayOES)
  RETVAL = glIsVertexArrayOES(array);
  OGLM_CHECK_ERR(glIsVertexArrayOES, )
OUTPUT:
  RETVAL

GLboolean
glIsVertexArraySGIX(array)
  GLuint array;
CODE:
  OGLM_GLEWINIT
  OGLM_CHECK_ERR(glIsVertexArraySGIX, )
  OGLM_AVAIL_CHECK(__glewIsVertexArraySGIX, glIsVertexArraySGIX)
  RETVAL = glIsVertexArraySGIX(array);
  OGLM_CHECK_ERR(glIsVertexArraySGIX, )
OUTPUT:
  RETVAL

GLboolean
glIsVertexAttribEnabledAPPLE(index, pname)
  GLuint index;
  GLenum pname;
CODE:
  OGLM_GLEWINIT
  OGLM_CHECK_ERR(glIsVertexAttribEnabledAPPLE, )
  OGLM_AVAIL_CHECK(__glewIsVertexAttribEnabledAPPLE, glIsVertexAttribEnabledAPPLE)
  RETVAL = glIsVertexAttribEnabledAPPLE(index, pname);
  OGLM_CHECK_ERR(glIsVertexAttribEnabledAPPLE, )
OUTPUT:
  RETVAL

void
glLGPUCopyImageSubDataNVX(sourceGpu, destinationGpuMask, srcName, srcTarget, srcLevel, srcX, srxY, srcZ, dstName, dstTarget, dstLevel, dstX, dstY, dstZ, width, height, depth)
  GLuint sourceGpu;
  GLbitfield destinationGpuMask;
  GLuint srcName;
  GLenum srcTarget;
  GLint srcLevel;
  GLint srcX;
  GLint srxY;
  GLint srcZ;
  GLuint dstName;
  GLenum dstTarget;
  GLint dstLevel;
  GLint dstX;
  GLint dstY;
  GLint dstZ;
  GLsizei width;
  GLsizei height;
  GLsizei depth;
CODE:
  OGLM_GLEWINIT
  OGLM_CHECK_ERR(glLGPUCopyImageSubDataNVX, )
  OGLM_AVAIL_CHECK(__glewLGPUCopyImageSubDataNVX, glLGPUCopyImageSubDataNVX)
  glLGPUCopyImageSubDataNVX(sourceGpu, destinationGpuMask, srcName, srcTarget, srcLevel, srcX, srxY, srcZ, dstName, dstTarget, dstLevel, dstX, dstY, dstZ, width, height, depth);
  OGLM_CHECK_ERR(glLGPUCopyImageSubDataNVX, )

void
glLGPUInterlockNVX()
CODE:
  OGLM_GLEWINIT
  OGLM_CHECK_ERR(glLGPUInterlockNVX, )
  OGLM_AVAIL_CHECK(__glewLGPUInterlockNVX, glLGPUInterlockNVX)
  glLGPUInterlockNVX();
  OGLM_CHECK_ERR(glLGPUInterlockNVX, )

void
glLGPUNamedBufferSubDataNVX_c(gpuMask, buffer, offset, size, data)
  GLbitfield gpuMask;
  GLuint buffer;
  GLintptr offset;
  GLsizeiptr size;
  const void *data;
CODE:
  OGLM_GLEWINIT
  OGLM_CHECK_ERR(glLGPUNamedBufferSubDataNVX, )
  OGLM_AVAIL_CHECK(__glewLGPUNamedBufferSubDataNVX, glLGPUNamedBufferSubDataNVX)
  glLGPUNamedBufferSubDataNVX(gpuMask, buffer, offset, size, data);
  OGLM_CHECK_ERR(glLGPUNamedBufferSubDataNVX, )

void
glLabelObjectEXT(type, object, length, label)
  GLenum type;
  GLuint object;
  GLsizei length;
  const GLchar* label;
CODE:
  OGLM_GLEWINIT
  OGLM_CHECK_ERR(glLabelObjectEXT, )
  OGLM_AVAIL_CHECK(__glewLabelObjectEXT, glLabelObjectEXT)
  glLabelObjectEXT(type, object, length, label);
  OGLM_CHECK_ERR(glLabelObjectEXT, )

void
glLightEnviEXT(pname, param)
  GLenum pname;
  GLint param;
CODE:
  OGLM_GLEWINIT
  OGLM_CHECK_ERR(glLightEnviEXT, )
  OGLM_AVAIL_CHECK(__glewLightEnviEXT, glLightEnviEXT)
  glLightEnviEXT(pname, param);
  OGLM_CHECK_ERR(glLightEnviEXT, )

void
glLightModelf(pname, param)
  GLenum pname;
  GLfloat param;
CODE:
  OGLM_GLEWINIT
  OGLM_CHECK_ERR(glLightModelf, )
  glLightModelf(pname, param);
  OGLM_CHECK_ERR(glLightModelf, )

void
glLightModelfv_c(pname, params)
  GLenum pname;
  const GLfloat *params;
CODE:
  OGLM_GLEWINIT
  OGLM_CHECK_ERR(glLightModelfv, )
  glLightModelfv(pname, params);
  OGLM_CHECK_ERR(glLightModelfv, )

void
glLightModelfv_p(pname, ...)
  GLenum pname;
CODE:
  OGLM_GLEWINIT
  OGLM_CHECK_ERR(glLightModelfv, )
  OGLM_SIZE_ENUM(LightModelParameter,pname,1)
  GLfloat *params = OGLM_GET_VARARGS(params,1,GLfloat,NV,pname_count);
  glLightModelfv((GLenum )pname, (const GLfloat *)params);
  OGLM_CHECK_ERR(glLightModelfv, free(params);)
  free(params);

void
glLightModeli(pname, param)
  GLenum pname;
  GLint param;
CODE:
  OGLM_GLEWINIT
  OGLM_CHECK_ERR(glLightModeli, )
  glLightModeli(pname, param);
  OGLM_CHECK_ERR(glLightModeli, )

void
glLightModeliv_c(pname, params)
  GLenum pname;
  const GLint *params;
CODE:
  OGLM_GLEWINIT
  OGLM_CHECK_ERR(glLightModeliv, )
  glLightModeliv(pname, params);
  OGLM_CHECK_ERR(glLightModeliv, )

void
glLightModeliv_p(pname, ...)
  GLenum pname;
CODE:
  OGLM_GLEWINIT
  OGLM_CHECK_ERR(glLightModeliv, )
  OGLM_SIZE_ENUM(LightModelParameter,pname,1)
  GLint *params = OGLM_GET_VARARGS(params,1,GLint,IV,pname_count);
  glLightModeliv((GLenum )pname, (const GLint *)params);
  OGLM_CHECK_ERR(glLightModeliv, free(params);)
  free(params);

void
glLightModelx(pname, param)
  GLenum pname;
  GLfixed param;
CODE:
  OGLM_GLEWINIT
  OGLM_CHECK_ERR(glLightModelx, )
  OGLM_AVAIL_CHECK(__glewLightModelx, glLightModelx)
  glLightModelx(pname, param);
  OGLM_CHECK_ERR(glLightModelx, )

void
glLightModelxv_c(pname, param)
  GLenum pname;
  const GLfixed* param;
CODE:
  OGLM_GLEWINIT
  OGLM_CHECK_ERR(glLightModelxv, )
  OGLM_AVAIL_CHECK(__glewLightModelxv, glLightModelxv)
  glLightModelxv(pname, param);
  OGLM_CHECK_ERR(glLightModelxv, )

void
glLightModelxv_p(pname, ...)
  GLenum pname;
CODE:
  OGLM_GLEWINIT
  OGLM_CHECK_ERR(glLightModelxv, )
  OGLM_AVAIL_CHECK(__glewLightModelxv, glLightModelxv)
  OGLM_SIZE_ENUM(LightModelParameter,pname,1)
  GLfixed* param = OGLM_GET_VARARGS(param,1,GLfixed,IV,pname_count);
  glLightModelxv((GLenum )pname, (const GLfixed* )param);
  OGLM_CHECK_ERR(glLightModelxv, free(param);)
  free(param);

void
glLightf(light, pname, param)
  GLenum light;
  GLenum pname;
  GLfloat param;
CODE:
  OGLM_GLEWINIT
  OGLM_CHECK_ERR(glLightf, )
  glLightf(light, pname, param);
  OGLM_CHECK_ERR(glLightf, )

void
glLightfv_c(light, pname, params)
  GLenum light;
  GLenum pname;
  const GLfloat *params;
CODE:
  OGLM_GLEWINIT
  OGLM_CHECK_ERR(glLightfv, )
  glLightfv(light, pname, params);
  OGLM_CHECK_ERR(glLightfv, )

void
glLightfv_p(light, pname, ...)
  GLenum light;
  GLenum pname;
CODE:
  OGLM_GLEWINIT
  OGLM_CHECK_ERR(glLightfv, )
  OGLM_SIZE_ENUM(LightParameter,pname,1)
  GLfloat *params = OGLM_GET_VARARGS(params,2,GLfloat,NV,pname_count);
  glLightfv((GLenum )light, (GLenum )pname, (const GLfloat *)params);
  OGLM_CHECK_ERR(glLightfv, free(params);)
  free(params);

void
glLighti(light, pname, param)
  GLenum light;
  GLenum pname;
  GLint param;
CODE:
  OGLM_GLEWINIT
  OGLM_CHECK_ERR(glLighti, )
  glLighti(light, pname, param);
  OGLM_CHECK_ERR(glLighti, )

void
glLightiv_c(light, pname, params)
  GLenum light;
  GLenum pname;
  const GLint *params;
CODE:
  OGLM_GLEWINIT
  OGLM_CHECK_ERR(glLightiv, )
  glLightiv(light, pname, params);
  OGLM_CHECK_ERR(glLightiv, )

void
glLightiv_p(light, pname, ...)
  GLenum light;
  GLenum pname;
CODE:
  OGLM_GLEWINIT
  OGLM_CHECK_ERR(glLightiv, )
  OGLM_SIZE_ENUM(LightParameter,pname,1)
  GLint *params = OGLM_GET_VARARGS(params,2,GLint,IV,pname_count);
  glLightiv((GLenum )light, (GLenum )pname, (const GLint *)params);
  OGLM_CHECK_ERR(glLightiv, free(params);)
  free(params);

void
glLightx(light, pname, param)
  GLenum light;
  GLenum pname;
  GLfixed param;
CODE:
  OGLM_GLEWINIT
  OGLM_CHECK_ERR(glLightx, )
  OGLM_AVAIL_CHECK(__glewLightx, glLightx)
  glLightx(light, pname, param);
  OGLM_CHECK_ERR(glLightx, )

void
glLightxv_c(light, pname, params)
  GLenum light;
  GLenum pname;
  const GLfixed* params;
CODE:
  OGLM_GLEWINIT
  OGLM_CHECK_ERR(glLightxv, )
  OGLM_AVAIL_CHECK(__glewLightxv, glLightxv)
  glLightxv(light, pname, params);
  OGLM_CHECK_ERR(glLightxv, )

void
glLightxv_p(light, pname, ...)
  GLenum light;
  GLenum pname;
CODE:
  OGLM_GLEWINIT
  OGLM_CHECK_ERR(glLightxv, )
  OGLM_AVAIL_CHECK(__glewLightxv, glLightxv)
  OGLM_SIZE_ENUM(LightParameter,pname,1)
  GLfixed* params = OGLM_GET_VARARGS(params,2,GLfixed,IV,pname_count);
  glLightxv((GLenum )light, (GLenum )pname, (const GLfixed* )params);
  OGLM_CHECK_ERR(glLightxv, free(params);)
  free(params);

void
glLineStipple(factor, pattern)
  GLint factor;
  GLushort pattern;
CODE:
  OGLM_GLEWINIT
  OGLM_CHECK_ERR(glLineStipple, )
  glLineStipple(factor, pattern);
  OGLM_CHECK_ERR(glLineStipple, )

void
glLineWidth(width)
  GLfloat width;
CODE:
  OGLM_GLEWINIT
  OGLM_CHECK_ERR(glLineWidth, )
  glLineWidth(width);
  OGLM_CHECK_ERR(glLineWidth, )

void
glLineWidthx(width)
  GLfixed width;
CODE:
  OGLM_GLEWINIT
  OGLM_CHECK_ERR(glLineWidthx, )
  OGLM_AVAIL_CHECK(__glewLineWidthx, glLineWidthx)
  glLineWidthx(width);
  OGLM_CHECK_ERR(glLineWidthx, )

void
glLinkProgram(program)
  GLuint program;
CODE:
  OGLM_GLEWINIT
  OGLM_CHECK_ERR(glLinkProgram, )
  OGLM_AVAIL_CHECK(__glewLinkProgram, glLinkProgram)
  glLinkProgram(program);
  OGLM_CHECK_ERR(glLinkProgram, )

void
glLinkProgramARB(programObj)
  GLhandleARB programObj;
CODE:
  OGLM_GLEWINIT
  OGLM_CHECK_ERR(glLinkProgramARB, )
  OGLM_AVAIL_CHECK(__glewLinkProgramARB, glLinkProgramARB)
  glLinkProgramARB(programObj);
  OGLM_CHECK_ERR(glLinkProgramARB, )

void
glListBase(base)
  GLuint base;
CODE:
  OGLM_GLEWINIT
  OGLM_CHECK_ERR(glListBase, )
  glListBase(base);
  OGLM_CHECK_ERR(glListBase, )

void
glListDrawCommandsStatesClientNV_c(list, segment, indirects, sizes, states, fbos, count)
  GLuint list;
  GLuint segment;
  const void** indirects;
  const GLsizei* sizes;
  const GLuint* states;
  const GLuint* fbos;
  GLuint count;
CODE:
  OGLM_GLEWINIT
  OGLM_CHECK_ERR(glListDrawCommandsStatesClientNV, )
  OGLM_AVAIL_CHECK(__glewListDrawCommandsStatesClientNV, glListDrawCommandsStatesClientNV)
  glListDrawCommandsStatesClientNV(list, segment, indirects, sizes, states, fbos, count);
  OGLM_CHECK_ERR(glListDrawCommandsStatesClientNV, )

void
glLoadIdentity()
CODE:
  OGLM_GLEWINIT
  OGLM_CHECK_ERR(glLoadIdentity, )
  glLoadIdentity();
  OGLM_CHECK_ERR(glLoadIdentity, )

void
glLoadIdentityDeformationMapSGIX(mask)
  GLbitfield mask;
CODE:
  OGLM_GLEWINIT
  OGLM_CHECK_ERR(glLoadIdentityDeformationMapSGIX, )
  OGLM_AVAIL_CHECK(__glewLoadIdentityDeformationMapSGIX, glLoadIdentityDeformationMapSGIX)
  glLoadIdentityDeformationMapSGIX(mask);
  OGLM_CHECK_ERR(glLoadIdentityDeformationMapSGIX, )

void
glLoadMatrixd_c(m)
  const GLdouble *m;
CODE:
  OGLM_GLEWINIT
  OGLM_CHECK_ERR(glLoadMatrixd, )
  glLoadMatrixd(m);
  OGLM_CHECK_ERR(glLoadMatrixd, )

void
glLoadMatrixd_p(...)
CODE:
  OGLM_GLEWINIT
  OGLM_CHECK_ERR(glLoadMatrixd, )
  GLdouble *m = OGLM_GET_VARARGS(m,0,GLdouble,NV,16);
  glLoadMatrixd((const GLdouble *)m);
  OGLM_CHECK_ERR(glLoadMatrixd, free(m);)
  free(m);

void
glLoadMatrixf_c(m)
  const GLfloat *m;
CODE:
  OGLM_GLEWINIT
  OGLM_CHECK_ERR(glLoadMatrixf, )
  glLoadMatrixf(m);
  OGLM_CHECK_ERR(glLoadMatrixf, )

void
glLoadMatrixf_p(...)
CODE:
  OGLM_GLEWINIT
  OGLM_CHECK_ERR(glLoadMatrixf, )
  GLfloat *m = OGLM_GET_VARARGS(m,0,GLfloat,NV,16);
  glLoadMatrixf((const GLfloat *)m);
  OGLM_CHECK_ERR(glLoadMatrixf, free(m);)
  free(m);

void
glLoadMatrixx_c(m)
  const GLfixed* m;
CODE:
  OGLM_GLEWINIT
  OGLM_CHECK_ERR(glLoadMatrixx, )
  OGLM_AVAIL_CHECK(__glewLoadMatrixx, glLoadMatrixx)
  glLoadMatrixx(m);
  OGLM_CHECK_ERR(glLoadMatrixx, )

void
glLoadMatrixx_p(...)
CODE:
  OGLM_GLEWINIT
  OGLM_CHECK_ERR(glLoadMatrixx, )
  OGLM_AVAIL_CHECK(__glewLoadMatrixx, glLoadMatrixx)
  GLfixed* m = OGLM_GET_VARARGS(m,0,GLfixed,IV,16);
  glLoadMatrixx((const GLfixed* )m);
  OGLM_CHECK_ERR(glLoadMatrixx, free(m);)
  free(m);

void
glLoadName(name)
  GLuint name;
CODE:
  OGLM_GLEWINIT
  OGLM_CHECK_ERR(glLoadName, )
  glLoadName(name);
  OGLM_CHECK_ERR(glLoadName, )

void
glLoadPaletteFromModelViewMatrixOES()
CODE:
  OGLM_GLEWINIT
  OGLM_CHECK_ERR(glLoadPaletteFromModelViewMatrixOES, )
  OGLM_AVAIL_CHECK(__glewLoadPaletteFromModelViewMatrixOES, glLoadPaletteFromModelViewMatrixOES)
  glLoadPaletteFromModelViewMatrixOES();
  OGLM_CHECK_ERR(glLoadPaletteFromModelViewMatrixOES, )

void
glLoadProgramNV(target, id, len, program)
  GLenum target;
  GLuint id;
  GLsizei len;
  const GLubyte* program;
CODE:
  OGLM_GLEWINIT
  OGLM_CHECK_ERR(glLoadProgramNV, )
  OGLM_AVAIL_CHECK(__glewLoadProgramNV, glLoadProgramNV)
  glLoadProgramNV(target, id, len, program);
  OGLM_CHECK_ERR(glLoadProgramNV, )

void
glLoadTransposeMatrixd_c(m)
  const GLdouble * m;
ALIAS:
  glLoadTransposeMatrixdARB_c = 1
CODE:
  OGLM_GLEWINIT
  OGLM_CHECK_ERR(glLoadTransposeMatrixd, )
  OGLM_AVAIL_CHECK(__glewLoadTransposeMatrixd, glLoadTransposeMatrixd)
  glLoadTransposeMatrixd(m);
  OGLM_CHECK_ERR(glLoadTransposeMatrixd, )

void
glLoadTransposeMatrixd_p(...)
ALIAS:
  glLoadTransposeMatrixdARB_p = 1
CODE:
  OGLM_GLEWINIT
  OGLM_CHECK_ERR(glLoadTransposeMatrixd, )
  OGLM_AVAIL_CHECK(__glewLoadTransposeMatrixd, glLoadTransposeMatrixd)
  GLdouble * m = OGLM_GET_VARARGS(m,0,GLdouble,NV,16);
  glLoadTransposeMatrixd((const GLdouble * )m);
  OGLM_CHECK_ERR(glLoadTransposeMatrixd, free(m);)
  free(m);

void
glLoadTransposeMatrixf_c(m)
  const GLfloat * m;
ALIAS:
  glLoadTransposeMatrixfARB_c = 1
CODE:
  OGLM_GLEWINIT
  OGLM_CHECK_ERR(glLoadTransposeMatrixf, )
  OGLM_AVAIL_CHECK(__glewLoadTransposeMatrixf, glLoadTransposeMatrixf)
  glLoadTransposeMatrixf(m);
  OGLM_CHECK_ERR(glLoadTransposeMatrixf, )

void
glLoadTransposeMatrixf_p(...)
ALIAS:
  glLoadTransposeMatrixfARB_p = 1
CODE:
  OGLM_GLEWINIT
  OGLM_CHECK_ERR(glLoadTransposeMatrixf, )
  OGLM_AVAIL_CHECK(__glewLoadTransposeMatrixf, glLoadTransposeMatrixf)
  GLfloat * m = OGLM_GET_VARARGS(m,0,GLfloat,NV,16);
  glLoadTransposeMatrixf((const GLfloat * )m);
  OGLM_CHECK_ERR(glLoadTransposeMatrixf, free(m);)
  free(m);

void
glLockArraysEXT(first, count)
  GLint first;
  GLsizei count;
CODE:
  OGLM_GLEWINIT
  OGLM_CHECK_ERR(glLockArraysEXT, )
  OGLM_AVAIL_CHECK(__glewLockArraysEXT, glLockArraysEXT)
  glLockArraysEXT(first, count);
  OGLM_CHECK_ERR(glLockArraysEXT, )

void
glLogMessageCallbackREGAL(callback)
  GLLOGPROCREGAL callback;
CODE:
  OGLM_GLEWINIT
  OGLM_CHECK_ERR(glLogMessageCallbackREGAL, )
  OGLM_AVAIL_CHECK(__glewLogMessageCallbackREGAL, glLogMessageCallbackREGAL)
  glLogMessageCallbackREGAL(callback);
  OGLM_CHECK_ERR(glLogMessageCallbackREGAL, )

void
glLogicOp(opcode)
  GLenum opcode;
CODE:
  OGLM_GLEWINIT
  OGLM_CHECK_ERR(glLogicOp, )
  glLogicOp(opcode);
  OGLM_CHECK_ERR(glLogicOp, )

void
glMPEGPredictorSGIX_c(target, format, type, pixels)
  GLenum target;
  GLenum format;
  GLenum type;
  void *pixels;
CODE:
  OGLM_GLEWINIT
  OGLM_CHECK_ERR(glMPEGPredictorSGIX, )
  OGLM_AVAIL_CHECK(__glewMPEGPredictorSGIX, glMPEGPredictorSGIX)
  glMPEGPredictorSGIX(target, format, type, pixels);
  OGLM_CHECK_ERR(glMPEGPredictorSGIX, )

void
glMPEGQuantTableubv_c(target, values)
  GLenum target;
  GLubyte* values;
CODE:
  OGLM_GLEWINIT
  OGLM_CHECK_ERR(glMPEGQuantTableubv, )
  OGLM_AVAIL_CHECK(__glewMPEGQuantTableubv, glMPEGQuantTableubv)
  glMPEGQuantTableubv(target, values);
  OGLM_CHECK_ERR(glMPEGQuantTableubv, )

void
glMakeBufferNonResidentNV(target)
  GLenum target;
CODE:
  OGLM_GLEWINIT
  OGLM_CHECK_ERR(glMakeBufferNonResidentNV, )
  OGLM_AVAIL_CHECK(__glewMakeBufferNonResidentNV, glMakeBufferNonResidentNV)
  glMakeBufferNonResidentNV(target);
  OGLM_CHECK_ERR(glMakeBufferNonResidentNV, )

void
glMakeBufferResidentNV(target, access)
  GLenum target;
  GLenum access;
CODE:
  OGLM_GLEWINIT
  OGLM_CHECK_ERR(glMakeBufferResidentNV, )
  OGLM_AVAIL_CHECK(__glewMakeBufferResidentNV, glMakeBufferResidentNV)
  glMakeBufferResidentNV(target, access);
  OGLM_CHECK_ERR(glMakeBufferResidentNV, )

void
glMakeImageHandleNonResidentARB(handle)
  GLuint64 handle;
CODE:
  OGLM_GLEWINIT
  OGLM_CHECK_ERR(glMakeImageHandleNonResidentARB, )
  OGLM_AVAIL_CHECK(__glewMakeImageHandleNonResidentARB, glMakeImageHandleNonResidentARB)
  glMakeImageHandleNonResidentARB(handle);
  OGLM_CHECK_ERR(glMakeImageHandleNonResidentARB, )

void
glMakeImageHandleNonResidentNV(handle)
  GLuint64 handle;
CODE:
  OGLM_GLEWINIT
  OGLM_CHECK_ERR(glMakeImageHandleNonResidentNV, )
  OGLM_AVAIL_CHECK(__glewMakeImageHandleNonResidentNV, glMakeImageHandleNonResidentNV)
  glMakeImageHandleNonResidentNV(handle);
  OGLM_CHECK_ERR(glMakeImageHandleNonResidentNV, )

void
glMakeImageHandleResidentARB(handle, access)
  GLuint64 handle;
  GLenum access;
CODE:
  OGLM_GLEWINIT
  OGLM_CHECK_ERR(glMakeImageHandleResidentARB, )
  OGLM_AVAIL_CHECK(__glewMakeImageHandleResidentARB, glMakeImageHandleResidentARB)
  glMakeImageHandleResidentARB(handle, access);
  OGLM_CHECK_ERR(glMakeImageHandleResidentARB, )

void
glMakeImageHandleResidentNV(handle, access)
  GLuint64 handle;
  GLenum access;
CODE:
  OGLM_GLEWINIT
  OGLM_CHECK_ERR(glMakeImageHandleResidentNV, )
  OGLM_AVAIL_CHECK(__glewMakeImageHandleResidentNV, glMakeImageHandleResidentNV)
  glMakeImageHandleResidentNV(handle, access);
  OGLM_CHECK_ERR(glMakeImageHandleResidentNV, )

void
glMakeNamedBufferNonResidentNV(buffer)
  GLuint buffer;
CODE:
  OGLM_GLEWINIT
  OGLM_CHECK_ERR(glMakeNamedBufferNonResidentNV, )
  OGLM_AVAIL_CHECK(__glewMakeNamedBufferNonResidentNV, glMakeNamedBufferNonResidentNV)
  glMakeNamedBufferNonResidentNV(buffer);
  OGLM_CHECK_ERR(glMakeNamedBufferNonResidentNV, )

void
glMakeNamedBufferResidentNV(buffer, access)
  GLuint buffer;
  GLenum access;
CODE:
  OGLM_GLEWINIT
  OGLM_CHECK_ERR(glMakeNamedBufferResidentNV, )
  OGLM_AVAIL_CHECK(__glewMakeNamedBufferResidentNV, glMakeNamedBufferResidentNV)
  glMakeNamedBufferResidentNV(buffer, access);
  OGLM_CHECK_ERR(glMakeNamedBufferResidentNV, )

void
glMakeTextureHandleNonResidentARB(handle)
  GLuint64 handle;
CODE:
  OGLM_GLEWINIT
  OGLM_CHECK_ERR(glMakeTextureHandleNonResidentARB, )
  OGLM_AVAIL_CHECK(__glewMakeTextureHandleNonResidentARB, glMakeTextureHandleNonResidentARB)
  glMakeTextureHandleNonResidentARB(handle);
  OGLM_CHECK_ERR(glMakeTextureHandleNonResidentARB, )

void
glMakeTextureHandleNonResidentNV(handle)
  GLuint64 handle;
CODE:
  OGLM_GLEWINIT
  OGLM_CHECK_ERR(glMakeTextureHandleNonResidentNV, )
  OGLM_AVAIL_CHECK(__glewMakeTextureHandleNonResidentNV, glMakeTextureHandleNonResidentNV)
  glMakeTextureHandleNonResidentNV(handle);
  OGLM_CHECK_ERR(glMakeTextureHandleNonResidentNV, )

void
glMakeTextureHandleResidentARB(handle)
  GLuint64 handle;
CODE:
  OGLM_GLEWINIT
  OGLM_CHECK_ERR(glMakeTextureHandleResidentARB, )
  OGLM_AVAIL_CHECK(__glewMakeTextureHandleResidentARB, glMakeTextureHandleResidentARB)
  glMakeTextureHandleResidentARB(handle);
  OGLM_CHECK_ERR(glMakeTextureHandleResidentARB, )

void
glMakeTextureHandleResidentNV(handle)
  GLuint64 handle;
CODE:
  OGLM_GLEWINIT
  OGLM_CHECK_ERR(glMakeTextureHandleResidentNV, )
  OGLM_AVAIL_CHECK(__glewMakeTextureHandleResidentNV, glMakeTextureHandleResidentNV)
  glMakeTextureHandleResidentNV(handle);
  OGLM_CHECK_ERR(glMakeTextureHandleResidentNV, )

void
glMap1d_c(target, u1, u2, stride, order, points)
  GLenum target;
  GLdouble u1;
  GLdouble u2;
  GLint stride;
  GLint order;
  const GLdouble *points;
CODE:
  OGLM_GLEWINIT
  OGLM_CHECK_ERR(glMap1d, )
  glMap1d(target, u1, u2, stride, order, points);
  OGLM_CHECK_ERR(glMap1d, )

void
glMap1f_c(target, u1, u2, stride, order, points)
  GLenum target;
  GLfloat u1;
  GLfloat u2;
  GLint stride;
  GLint order;
  const GLfloat *points;
CODE:
  OGLM_GLEWINIT
  OGLM_CHECK_ERR(glMap1f, )
  glMap1f(target, u1, u2, stride, order, points);
  OGLM_CHECK_ERR(glMap1f, )

void
glMap2d_c(target, u1, u2, ustride, uorder, v1, v2, vstride, vorder, points)
  GLenum target;
  GLdouble u1;
  GLdouble u2;
  GLint ustride;
  GLint uorder;
  GLdouble v1;
  GLdouble v2;
  GLint vstride;
  GLint vorder;
  const GLdouble *points;
CODE:
  OGLM_GLEWINIT
  OGLM_CHECK_ERR(glMap2d, )
  glMap2d(target, u1, u2, ustride, uorder, v1, v2, vstride, vorder, points);
  OGLM_CHECK_ERR(glMap2d, )

void
glMap2f_c(target, u1, u2, ustride, uorder, v1, v2, vstride, vorder, points)
  GLenum target;
  GLfloat u1;
  GLfloat u2;
  GLint ustride;
  GLint uorder;
  GLfloat v1;
  GLfloat v2;
  GLint vstride;
  GLint vorder;
  const GLfloat *points;
CODE:
  OGLM_GLEWINIT
  OGLM_CHECK_ERR(glMap2f, )
  glMap2f(target, u1, u2, ustride, uorder, v1, v2, vstride, vorder, points);
  OGLM_CHECK_ERR(glMap2f, )

void*
glMapBuffer_c(target, access)
  GLenum target;
  GLenum access;
ALIAS:
  glMapBufferARB_c = 1
CODE:
  OGLM_GLEWINIT
  OGLM_CHECK_ERR(glMapBuffer, )
  OGLM_AVAIL_CHECK(__glewMapBuffer, glMapBuffer)
  RETVAL = glMapBuffer(target, access);
  OGLM_CHECK_ERR(glMapBuffer, )
OUTPUT:
  RETVAL

void *
glMapBufferOES_c(target, access)
  GLenum target;
  GLenum access;
CODE:
  OGLM_GLEWINIT
  OGLM_CHECK_ERR(glMapBufferOES, )
  OGLM_AVAIL_CHECK(__glewMapBufferOES, glMapBufferOES)
  RETVAL = glMapBufferOES(target, access);
  OGLM_CHECK_ERR(glMapBufferOES, )
OUTPUT:
  RETVAL

void *
glMapBufferRange_c(target, offset, length, access)
  GLenum target;
  GLintptr offset;
  GLsizeiptr length;
  GLbitfield access;
ALIAS:
  glMapBufferRangeEXT_c = 1
CODE:
  OGLM_GLEWINIT
  OGLM_CHECK_ERR(glMapBufferRange, )
  OGLM_AVAIL_CHECK(__glewMapBufferRange, glMapBufferRange)
  RETVAL = glMapBufferRange(target, offset, length, access);
  OGLM_CHECK_ERR(glMapBufferRange, )
OUTPUT:
  RETVAL

void
glMapControlPointsNV_c(target, index, type, ustride, vstride, uorder, vorder, packed, points)
  GLenum target;
  GLuint index;
  GLenum type;
  GLsizei ustride;
  GLsizei vstride;
  GLint uorder;
  GLint vorder;
  GLboolean packed;
  const void *points;
CODE:
  OGLM_GLEWINIT
  OGLM_CHECK_ERR(glMapControlPointsNV, )
  OGLM_AVAIL_CHECK(__glewMapControlPointsNV, glMapControlPointsNV)
  glMapControlPointsNV(target, index, type, ustride, vstride, uorder, vorder, packed, points);
  OGLM_CHECK_ERR(glMapControlPointsNV, )

void
glMapGrid1d(un, u1, u2)
  GLint un;
  GLdouble u1;
  GLdouble u2;
CODE:
  OGLM_GLEWINIT
  OGLM_CHECK_ERR(glMapGrid1d, )
  glMapGrid1d(un, u1, u2);
  OGLM_CHECK_ERR(glMapGrid1d, )

void
glMapGrid1f(un, u1, u2)
  GLint un;
  GLfloat u1;
  GLfloat u2;
CODE:
  OGLM_GLEWINIT
  OGLM_CHECK_ERR(glMapGrid1f, )
  glMapGrid1f(un, u1, u2);
  OGLM_CHECK_ERR(glMapGrid1f, )

void
glMapGrid2d(un, u1, u2, vn, v1, v2)
  GLint un;
  GLdouble u1;
  GLdouble u2;
  GLint vn;
  GLdouble v1;
  GLdouble v2;
CODE:
  OGLM_GLEWINIT
  OGLM_CHECK_ERR(glMapGrid2d, )
  glMapGrid2d(un, u1, u2, vn, v1, v2);
  OGLM_CHECK_ERR(glMapGrid2d, )

void
glMapGrid2f(un, u1, u2, vn, v1, v2)
  GLint un;
  GLfloat u1;
  GLfloat u2;
  GLint vn;
  GLfloat v1;
  GLfloat v2;
CODE:
  OGLM_GLEWINIT
  OGLM_CHECK_ERR(glMapGrid2f, )
  glMapGrid2f(un, u1, u2, vn, v1, v2);
  OGLM_CHECK_ERR(glMapGrid2f, )

void *
glMapNamedBuffer_c(buffer, access)
  GLuint buffer;
  GLenum access;
CODE:
  OGLM_GLEWINIT
  OGLM_CHECK_ERR(glMapNamedBuffer, )
  OGLM_AVAIL_CHECK(__glewMapNamedBuffer, glMapNamedBuffer)
  RETVAL = glMapNamedBuffer(buffer, access);
  OGLM_CHECK_ERR(glMapNamedBuffer, )
OUTPUT:
  RETVAL

void *
glMapNamedBufferEXT_c(buffer, access)
  GLuint buffer;
  GLenum access;
CODE:
  OGLM_GLEWINIT
  OGLM_CHECK_ERR(glMapNamedBufferEXT, )
  OGLM_AVAIL_CHECK(__glewMapNamedBufferEXT, glMapNamedBufferEXT)
  RETVAL = glMapNamedBufferEXT(buffer, access);
  OGLM_CHECK_ERR(glMapNamedBufferEXT, )
OUTPUT:
  RETVAL

void *
glMapNamedBufferRange_c(buffer, offset, length, access)
  GLuint buffer;
  GLintptr offset;
  GLsizeiptr length;
  GLbitfield access;
CODE:
  OGLM_GLEWINIT
  OGLM_CHECK_ERR(glMapNamedBufferRange, )
  OGLM_AVAIL_CHECK(__glewMapNamedBufferRange, glMapNamedBufferRange)
  RETVAL = glMapNamedBufferRange(buffer, offset, length, access);
  OGLM_CHECK_ERR(glMapNamedBufferRange, )
OUTPUT:
  RETVAL

void *
glMapNamedBufferRangeEXT_c(buffer, offset, length, access)
  GLuint buffer;
  GLintptr offset;
  GLsizeiptr length;
  GLbitfield access;
CODE:
  OGLM_GLEWINIT
  OGLM_CHECK_ERR(glMapNamedBufferRangeEXT, )
  OGLM_AVAIL_CHECK(__glewMapNamedBufferRangeEXT, glMapNamedBufferRangeEXT)
  RETVAL = glMapNamedBufferRangeEXT(buffer, offset, length, access);
  OGLM_CHECK_ERR(glMapNamedBufferRangeEXT, )
OUTPUT:
  RETVAL

void *
glMapObjectBufferATI_c(buffer)
  GLuint buffer;
CODE:
  OGLM_GLEWINIT
  OGLM_CHECK_ERR(glMapObjectBufferATI, )
  OGLM_AVAIL_CHECK(__glewMapObjectBufferATI, glMapObjectBufferATI)
  RETVAL = glMapObjectBufferATI(buffer);
  OGLM_CHECK_ERR(glMapObjectBufferATI, )
OUTPUT:
  RETVAL

void
glMapParameterfvNV_c(target, pname, params)
  GLenum target;
  GLenum pname;
  const GLfloat* params;
CODE:
  OGLM_GLEWINIT
  OGLM_CHECK_ERR(glMapParameterfvNV, )
  OGLM_AVAIL_CHECK(__glewMapParameterfvNV, glMapParameterfvNV)
  glMapParameterfvNV(target, pname, params);
  OGLM_CHECK_ERR(glMapParameterfvNV, )

void
glMapParameterivNV_c(target, pname, params)
  GLenum target;
  GLenum pname;
  const GLint* params;
CODE:
  OGLM_GLEWINIT
  OGLM_CHECK_ERR(glMapParameterivNV, )
  OGLM_AVAIL_CHECK(__glewMapParameterivNV, glMapParameterivNV)
  glMapParameterivNV(target, pname, params);
  OGLM_CHECK_ERR(glMapParameterivNV, )

void *
glMapTexture2DINTEL_c(texture, level, access, stride, layout)
  GLuint texture;
  GLint level;
  GLbitfield access;
  GLint* stride;
  GLenum *layout;
CODE:
  OGLM_GLEWINIT
  OGLM_CHECK_ERR(glMapTexture2DINTEL, )
  OGLM_AVAIL_CHECK(__glewMapTexture2DINTEL, glMapTexture2DINTEL)
  RETVAL = glMapTexture2DINTEL(texture, level, access, stride, layout);
  OGLM_CHECK_ERR(glMapTexture2DINTEL, )
OUTPUT:
  RETVAL

void *
glMapTexture2DINTEL_p(texture, level, access)
  GLuint texture;
  GLint level;
  GLbitfield access;
PPCODE:
  OGLM_GLEWINIT
  OGLM_CHECK_ERR(glMapTexture2DINTEL, )
  OGLM_AVAIL_CHECK(__glewMapTexture2DINTEL, glMapTexture2DINTEL)
  GLenum layout[1];
  GLint stride[1];
  RETVAL = glMapTexture2DINTEL(texture, level, access, stride, layout);
  OGLM_CHECK_ERR(glMapTexture2DINTEL, )
  EXTEND(sp, 3);
  mPUSHs(newSViv(PTR2IV(RETVAL)));
  mPUSHs(newSViv(stride[0]));
  mPUSHs(newSViv(layout[0]));

void
glMapVertexAttrib1dAPPLE_c(index, size, u1, u2, stride, order, points)
  GLuint index;
  GLuint size;
  GLdouble u1;
  GLdouble u2;
  GLint stride;
  GLint order;
  const GLdouble* points;
CODE:
  OGLM_GLEWINIT
  OGLM_CHECK_ERR(glMapVertexAttrib1dAPPLE, )
  OGLM_AVAIL_CHECK(__glewMapVertexAttrib1dAPPLE, glMapVertexAttrib1dAPPLE)
  glMapVertexAttrib1dAPPLE(index, size, u1, u2, stride, order, points);
  OGLM_CHECK_ERR(glMapVertexAttrib1dAPPLE, )

void
glMapVertexAttrib1fAPPLE_c(index, size, u1, u2, stride, order, points)
  GLuint index;
  GLuint size;
  GLfloat u1;
  GLfloat u2;
  GLint stride;
  GLint order;
  const GLfloat* points;
CODE:
  OGLM_GLEWINIT
  OGLM_CHECK_ERR(glMapVertexAttrib1fAPPLE, )
  OGLM_AVAIL_CHECK(__glewMapVertexAttrib1fAPPLE, glMapVertexAttrib1fAPPLE)
  glMapVertexAttrib1fAPPLE(index, size, u1, u2, stride, order, points);
  OGLM_CHECK_ERR(glMapVertexAttrib1fAPPLE, )

void
glMapVertexAttrib2dAPPLE_c(index, size, u1, u2, ustride, uorder, v1, v2, vstride, vorder, points)
  GLuint index;
  GLuint size;
  GLdouble u1;
  GLdouble u2;
  GLint ustride;
  GLint uorder;
  GLdouble v1;
  GLdouble v2;
  GLint vstride;
  GLint vorder;
  const GLdouble* points;
CODE:
  OGLM_GLEWINIT
  OGLM_CHECK_ERR(glMapVertexAttrib2dAPPLE, )
  OGLM_AVAIL_CHECK(__glewMapVertexAttrib2dAPPLE, glMapVertexAttrib2dAPPLE)
  glMapVertexAttrib2dAPPLE(index, size, u1, u2, ustride, uorder, v1, v2, vstride, vorder, points);
  OGLM_CHECK_ERR(glMapVertexAttrib2dAPPLE, )

void
glMapVertexAttrib2fAPPLE_c(index, size, u1, u2, ustride, uorder, v1, v2, vstride, vorder, points)
  GLuint index;
  GLuint size;
  GLfloat u1;
  GLfloat u2;
  GLint ustride;
  GLint uorder;
  GLfloat v1;
  GLfloat v2;
  GLint vstride;
  GLint vorder;
  const GLfloat* points;
CODE:
  OGLM_GLEWINIT
  OGLM_CHECK_ERR(glMapVertexAttrib2fAPPLE, )
  OGLM_AVAIL_CHECK(__glewMapVertexAttrib2fAPPLE, glMapVertexAttrib2fAPPLE)
  glMapVertexAttrib2fAPPLE(index, size, u1, u2, ustride, uorder, v1, v2, vstride, vorder, points);
  OGLM_CHECK_ERR(glMapVertexAttrib2fAPPLE, )

void
glMaterialf(face, pname, param)
  GLenum face;
  GLenum pname;
  GLfloat param;
CODE:
  OGLM_GLEWINIT
  OGLM_CHECK_ERR(glMaterialf, )
  glMaterialf(face, pname, param);
  OGLM_CHECK_ERR(glMaterialf, )

void
glMaterialfv_c(face, pname, params)
  GLenum face;
  GLenum pname;
  const GLfloat *params;
CODE:
  OGLM_GLEWINIT
  OGLM_CHECK_ERR(glMaterialfv, )
  glMaterialfv(face, pname, params);
  OGLM_CHECK_ERR(glMaterialfv, )

void
glMaterialfv_p(face, pname, ...)
  GLenum face;
  GLenum pname;
CODE:
  OGLM_GLEWINIT
  OGLM_CHECK_ERR(glMaterialfv, )
  OGLM_SIZE_ENUM(MaterialParameter,pname,1)
  GLfloat *params = OGLM_GET_VARARGS(params,2,GLfloat,NV,pname_count);
  glMaterialfv((GLenum )face, (GLenum )pname, (const GLfloat *)params);
  OGLM_CHECK_ERR(glMaterialfv, free(params);)
  free(params);

void
glMateriali(face, pname, param)
  GLenum face;
  GLenum pname;
  GLint param;
CODE:
  OGLM_GLEWINIT
  OGLM_CHECK_ERR(glMateriali, )
  glMateriali(face, pname, param);
  OGLM_CHECK_ERR(glMateriali, )

void
glMaterialiv_c(face, pname, params)
  GLenum face;
  GLenum pname;
  const GLint *params;
CODE:
  OGLM_GLEWINIT
  OGLM_CHECK_ERR(glMaterialiv, )
  glMaterialiv(face, pname, params);
  OGLM_CHECK_ERR(glMaterialiv, )

void
glMaterialiv_p(face, pname, ...)
  GLenum face;
  GLenum pname;
CODE:
  OGLM_GLEWINIT
  OGLM_CHECK_ERR(glMaterialiv, )
  OGLM_SIZE_ENUM(MaterialParameter,pname,1)
  GLint *params = OGLM_GET_VARARGS(params,2,GLint,IV,pname_count);
  glMaterialiv((GLenum )face, (GLenum )pname, (const GLint *)params);
  OGLM_CHECK_ERR(glMaterialiv, free(params);)
  free(params);

void
glMaterialx(face, pname, param)
  GLenum face;
  GLenum pname;
  GLfixed param;
CODE:
  OGLM_GLEWINIT
  OGLM_CHECK_ERR(glMaterialx, )
  OGLM_AVAIL_CHECK(__glewMaterialx, glMaterialx)
  glMaterialx(face, pname, param);
  OGLM_CHECK_ERR(glMaterialx, )

void
glMaterialxv_c(face, pname, param)
  GLenum face;
  GLenum pname;
  const GLfixed* param;
CODE:
  OGLM_GLEWINIT
  OGLM_CHECK_ERR(glMaterialxv, )
  OGLM_AVAIL_CHECK(__glewMaterialxv, glMaterialxv)
  glMaterialxv(face, pname, param);
  OGLM_CHECK_ERR(glMaterialxv, )

void
glMaterialxv_p(face, pname, ...)
  GLenum face;
  GLenum pname;
CODE:
  OGLM_GLEWINIT
  OGLM_CHECK_ERR(glMaterialxv, )
  OGLM_AVAIL_CHECK(__glewMaterialxv, glMaterialxv)
  OGLM_SIZE_ENUM(MaterialParameter,pname,1)
  GLfixed* param = OGLM_GET_VARARGS(param,2,GLfixed,IV,pname_count);
  glMaterialxv((GLenum )face, (GLenum )pname, (const GLfixed* )param);
  OGLM_CHECK_ERR(glMaterialxv, free(param);)
  free(param);

void
glMatrixFrustumEXT(mode, left, right, bottom, top, zNear, zFar)
  GLenum mode;
  GLdouble left;
  GLdouble right;
  GLdouble bottom;
  GLdouble top;
  GLdouble zNear;
  GLdouble zFar;
CODE:
  OGLM_GLEWINIT
  OGLM_CHECK_ERR(glMatrixFrustumEXT, )
  OGLM_AVAIL_CHECK(__glewMatrixFrustumEXT, glMatrixFrustumEXT)
  glMatrixFrustumEXT(mode, left, right, bottom, top, zNear, zFar);
  OGLM_CHECK_ERR(glMatrixFrustumEXT, )

void
glMatrixIndexPointerARB_c(size, type, stride, pointer)
  GLint size;
  GLenum type;
  GLsizei stride;
  void *pointer;
CODE:
  OGLM_GLEWINIT
  OGLM_CHECK_ERR(glMatrixIndexPointerARB, )
  OGLM_AVAIL_CHECK(__glewMatrixIndexPointerARB, glMatrixIndexPointerARB)
  glMatrixIndexPointerARB(size, type, stride, pointer);
  OGLM_CHECK_ERR(glMatrixIndexPointerARB, )

void
glMatrixIndexPointerOES_c(size, type, stride, pointer)
  GLint size;
  GLenum type;
  GLsizei stride;
  void *pointer;
CODE:
  OGLM_GLEWINIT
  OGLM_CHECK_ERR(glMatrixIndexPointerOES, )
  OGLM_AVAIL_CHECK(__glewMatrixIndexPointerOES, glMatrixIndexPointerOES)
  glMatrixIndexPointerOES(size, type, stride, pointer);
  OGLM_CHECK_ERR(glMatrixIndexPointerOES, )

void
glMatrixIndexubvARB_c(size, indices)
  GLint size;
  GLubyte *indices;
CODE:
  OGLM_GLEWINIT
  OGLM_CHECK_ERR(glMatrixIndexubvARB, )
  OGLM_AVAIL_CHECK(__glewMatrixIndexubvARB, glMatrixIndexubvARB)
  glMatrixIndexubvARB(size, indices);
  OGLM_CHECK_ERR(glMatrixIndexubvARB, )

void
glMatrixIndexubvARB_p(size)
  GLint size;
PPCODE:
  OGLM_GLEWINIT
  OGLM_CHECK_ERR(glMatrixIndexubvARB, )
  OGLM_AVAIL_CHECK(__glewMatrixIndexubvARB, glMatrixIndexubvARB)
  GLubyte *indices = OGLM_ALLOC(size,GLubyte,indices);
  glMatrixIndexubvARB(size, indices);
  OGLM_CHECK_ERR(glMatrixIndexubvARB, free(indices);)
  OGLM_OUT_FINISH(indices,size,newSVuv)
  free(indices);

void
glMatrixIndexuivARB_c(size, indices)
  GLint size;
  GLuint *indices;
CODE:
  OGLM_GLEWINIT
  OGLM_CHECK_ERR(glMatrixIndexuivARB, )
  OGLM_AVAIL_CHECK(__glewMatrixIndexuivARB, glMatrixIndexuivARB)
  glMatrixIndexuivARB(size, indices);
  OGLM_CHECK_ERR(glMatrixIndexuivARB, )

void
glMatrixIndexuivARB_p(size)
  GLint size;
PPCODE:
  OGLM_GLEWINIT
  OGLM_CHECK_ERR(glMatrixIndexuivARB, )
  OGLM_AVAIL_CHECK(__glewMatrixIndexuivARB, glMatrixIndexuivARB)
  GLuint *indices = OGLM_ALLOC(size,GLuint,indices);
  glMatrixIndexuivARB(size, indices);
  OGLM_CHECK_ERR(glMatrixIndexuivARB, free(indices);)
  OGLM_OUT_FINISH(indices,size,newSVuv)
  free(indices);

void
glMatrixIndexusvARB_c(size, indices)
  GLint size;
  GLushort *indices;
CODE:
  OGLM_GLEWINIT
  OGLM_CHECK_ERR(glMatrixIndexusvARB, )
  OGLM_AVAIL_CHECK(__glewMatrixIndexusvARB, glMatrixIndexusvARB)
  glMatrixIndexusvARB(size, indices);
  OGLM_CHECK_ERR(glMatrixIndexusvARB, )

void
glMatrixIndexusvARB_p(size)
  GLint size;
PPCODE:
  OGLM_GLEWINIT
  OGLM_CHECK_ERR(glMatrixIndexusvARB, )
  OGLM_AVAIL_CHECK(__glewMatrixIndexusvARB, glMatrixIndexusvARB)
  GLushort *indices = OGLM_ALLOC(size,GLushort,indices);
  glMatrixIndexusvARB(size, indices);
  OGLM_CHECK_ERR(glMatrixIndexusvARB, free(indices);)
  OGLM_OUT_FINISH(indices,size,newSVuv)
  free(indices);

void
glMatrixLoad3x2fNV_c(matrixMode, m)
  GLenum matrixMode;
  const GLfloat* m;
CODE:
  OGLM_GLEWINIT
  OGLM_CHECK_ERR(glMatrixLoad3x2fNV, )
  OGLM_AVAIL_CHECK(__glewMatrixLoad3x2fNV, glMatrixLoad3x2fNV)
  glMatrixLoad3x2fNV(matrixMode, m);
  OGLM_CHECK_ERR(glMatrixLoad3x2fNV, )

void
glMatrixLoad3x3fNV_c(matrixMode, m)
  GLenum matrixMode;
  const GLfloat* m;
CODE:
  OGLM_GLEWINIT
  OGLM_CHECK_ERR(glMatrixLoad3x3fNV, )
  OGLM_AVAIL_CHECK(__glewMatrixLoad3x3fNV, glMatrixLoad3x3fNV)
  glMatrixLoad3x3fNV(matrixMode, m);
  OGLM_CHECK_ERR(glMatrixLoad3x3fNV, )

void
glMatrixLoadIdentityEXT(mode)
  GLenum mode;
CODE:
  OGLM_GLEWINIT
  OGLM_CHECK_ERR(glMatrixLoadIdentityEXT, )
  OGLM_AVAIL_CHECK(__glewMatrixLoadIdentityEXT, glMatrixLoadIdentityEXT)
  glMatrixLoadIdentityEXT(mode);
  OGLM_CHECK_ERR(glMatrixLoadIdentityEXT, )

void
glMatrixLoadTranspose3x3fNV_c(matrixMode, m)
  GLenum matrixMode;
  const GLfloat* m;
CODE:
  OGLM_GLEWINIT
  OGLM_CHECK_ERR(glMatrixLoadTranspose3x3fNV, )
  OGLM_AVAIL_CHECK(__glewMatrixLoadTranspose3x3fNV, glMatrixLoadTranspose3x3fNV)
  glMatrixLoadTranspose3x3fNV(matrixMode, m);
  OGLM_CHECK_ERR(glMatrixLoadTranspose3x3fNV, )

void
glMatrixLoadTransposedEXT_c(mode, m)
  GLenum mode;
  const GLdouble* m;
CODE:
  OGLM_GLEWINIT
  OGLM_CHECK_ERR(glMatrixLoadTransposedEXT, )
  OGLM_AVAIL_CHECK(__glewMatrixLoadTransposedEXT, glMatrixLoadTransposedEXT)
  glMatrixLoadTransposedEXT(mode, m);
  OGLM_CHECK_ERR(glMatrixLoadTransposedEXT, )

void
glMatrixLoadTransposedEXT_p(mode, ...)
  GLenum mode;
CODE:
  OGLM_GLEWINIT
  OGLM_CHECK_ERR(glMatrixLoadTransposedEXT, )
  OGLM_AVAIL_CHECK(__glewMatrixLoadTransposedEXT, glMatrixLoadTransposedEXT)
  GLdouble* m = OGLM_GET_VARARGS(m,1,GLdouble,NV,16);
  glMatrixLoadTransposedEXT((GLenum )mode, (const GLdouble* )m);
  OGLM_CHECK_ERR(glMatrixLoadTransposedEXT, free(m);)
  free(m);

void
glMatrixLoadTransposefEXT_c(mode, m)
  GLenum mode;
  const GLfloat* m;
CODE:
  OGLM_GLEWINIT
  OGLM_CHECK_ERR(glMatrixLoadTransposefEXT, )
  OGLM_AVAIL_CHECK(__glewMatrixLoadTransposefEXT, glMatrixLoadTransposefEXT)
  glMatrixLoadTransposefEXT(mode, m);
  OGLM_CHECK_ERR(glMatrixLoadTransposefEXT, )

void
glMatrixLoadTransposefEXT_p(mode, ...)
  GLenum mode;
CODE:
  OGLM_GLEWINIT
  OGLM_CHECK_ERR(glMatrixLoadTransposefEXT, )
  OGLM_AVAIL_CHECK(__glewMatrixLoadTransposefEXT, glMatrixLoadTransposefEXT)
  GLfloat* m = OGLM_GET_VARARGS(m,1,GLfloat,NV,16);
  glMatrixLoadTransposefEXT((GLenum )mode, (const GLfloat* )m);
  OGLM_CHECK_ERR(glMatrixLoadTransposefEXT, free(m);)
  free(m);

void
glMatrixLoaddEXT_c(mode, m)
  GLenum mode;
  const GLdouble* m;
CODE:
  OGLM_GLEWINIT
  OGLM_CHECK_ERR(glMatrixLoaddEXT, )
  OGLM_AVAIL_CHECK(__glewMatrixLoaddEXT, glMatrixLoaddEXT)
  glMatrixLoaddEXT(mode, m);
  OGLM_CHECK_ERR(glMatrixLoaddEXT, )

void
glMatrixLoaddEXT_p(mode, ...)
  GLenum mode;
CODE:
  OGLM_GLEWINIT
  OGLM_CHECK_ERR(glMatrixLoaddEXT, )
  OGLM_AVAIL_CHECK(__glewMatrixLoaddEXT, glMatrixLoaddEXT)
  GLdouble* m = OGLM_GET_VARARGS(m,1,GLdouble,NV,16);
  glMatrixLoaddEXT((GLenum )mode, (const GLdouble* )m);
  OGLM_CHECK_ERR(glMatrixLoaddEXT, free(m);)
  free(m);

void
glMatrixLoadfEXT_c(mode, m)
  GLenum mode;
  const GLfloat* m;
CODE:
  OGLM_GLEWINIT
  OGLM_CHECK_ERR(glMatrixLoadfEXT, )
  OGLM_AVAIL_CHECK(__glewMatrixLoadfEXT, glMatrixLoadfEXT)
  glMatrixLoadfEXT(mode, m);
  OGLM_CHECK_ERR(glMatrixLoadfEXT, )

void
glMatrixLoadfEXT_p(mode, ...)
  GLenum mode;
CODE:
  OGLM_GLEWINIT
  OGLM_CHECK_ERR(glMatrixLoadfEXT, )
  OGLM_AVAIL_CHECK(__glewMatrixLoadfEXT, glMatrixLoadfEXT)
  GLfloat* m = OGLM_GET_VARARGS(m,1,GLfloat,NV,16);
  glMatrixLoadfEXT((GLenum )mode, (const GLfloat* )m);
  OGLM_CHECK_ERR(glMatrixLoadfEXT, free(m);)
  free(m);

void
glMatrixMode(mode)
  GLenum mode;
CODE:
  OGLM_GLEWINIT
  OGLM_CHECK_ERR(glMatrixMode, )
  glMatrixMode(mode);
  OGLM_CHECK_ERR(glMatrixMode, )

void
glMatrixMult3x2fNV_c(matrixMode, m)
  GLenum matrixMode;
  const GLfloat* m;
CODE:
  OGLM_GLEWINIT
  OGLM_CHECK_ERR(glMatrixMult3x2fNV, )
  OGLM_AVAIL_CHECK(__glewMatrixMult3x2fNV, glMatrixMult3x2fNV)
  glMatrixMult3x2fNV(matrixMode, m);
  OGLM_CHECK_ERR(glMatrixMult3x2fNV, )

void
glMatrixMult3x3fNV_c(matrixMode, m)
  GLenum matrixMode;
  const GLfloat* m;
CODE:
  OGLM_GLEWINIT
  OGLM_CHECK_ERR(glMatrixMult3x3fNV, )
  OGLM_AVAIL_CHECK(__glewMatrixMult3x3fNV, glMatrixMult3x3fNV)
  glMatrixMult3x3fNV(matrixMode, m);
  OGLM_CHECK_ERR(glMatrixMult3x3fNV, )

void
glMatrixMultTranspose3x3fNV_c(matrixMode, m)
  GLenum matrixMode;
  const GLfloat* m;
CODE:
  OGLM_GLEWINIT
  OGLM_CHECK_ERR(glMatrixMultTranspose3x3fNV, )
  OGLM_AVAIL_CHECK(__glewMatrixMultTranspose3x3fNV, glMatrixMultTranspose3x3fNV)
  glMatrixMultTranspose3x3fNV(matrixMode, m);
  OGLM_CHECK_ERR(glMatrixMultTranspose3x3fNV, )

void
glMatrixMultTransposedEXT_c(mode, m)
  GLenum mode;
  const GLdouble* m;
CODE:
  OGLM_GLEWINIT
  OGLM_CHECK_ERR(glMatrixMultTransposedEXT, )
  OGLM_AVAIL_CHECK(__glewMatrixMultTransposedEXT, glMatrixMultTransposedEXT)
  glMatrixMultTransposedEXT(mode, m);
  OGLM_CHECK_ERR(glMatrixMultTransposedEXT, )

void
glMatrixMultTransposedEXT_p(mode, ...)
  GLenum mode;
CODE:
  OGLM_GLEWINIT
  OGLM_CHECK_ERR(glMatrixMultTransposedEXT, )
  OGLM_AVAIL_CHECK(__glewMatrixMultTransposedEXT, glMatrixMultTransposedEXT)
  GLdouble* m = OGLM_GET_VARARGS(m,1,GLdouble,NV,16);
  glMatrixMultTransposedEXT((GLenum )mode, (const GLdouble* )m);
  OGLM_CHECK_ERR(glMatrixMultTransposedEXT, free(m);)
  free(m);

void
glMatrixMultTransposefEXT_c(mode, m)
  GLenum mode;
  const GLfloat* m;
CODE:
  OGLM_GLEWINIT
  OGLM_CHECK_ERR(glMatrixMultTransposefEXT, )
  OGLM_AVAIL_CHECK(__glewMatrixMultTransposefEXT, glMatrixMultTransposefEXT)
  glMatrixMultTransposefEXT(mode, m);
  OGLM_CHECK_ERR(glMatrixMultTransposefEXT, )

void
glMatrixMultTransposefEXT_p(mode, ...)
  GLenum mode;
CODE:
  OGLM_GLEWINIT
  OGLM_CHECK_ERR(glMatrixMultTransposefEXT, )
  OGLM_AVAIL_CHECK(__glewMatrixMultTransposefEXT, glMatrixMultTransposefEXT)
  GLfloat* m = OGLM_GET_VARARGS(m,1,GLfloat,NV,16);
  glMatrixMultTransposefEXT((GLenum )mode, (const GLfloat* )m);
  OGLM_CHECK_ERR(glMatrixMultTransposefEXT, free(m);)
  free(m);

void
glMatrixMultdEXT_c(mode, m)
  GLenum mode;
  const GLdouble* m;
CODE:
  OGLM_GLEWINIT
  OGLM_CHECK_ERR(glMatrixMultdEXT, )
  OGLM_AVAIL_CHECK(__glewMatrixMultdEXT, glMatrixMultdEXT)
  glMatrixMultdEXT(mode, m);
  OGLM_CHECK_ERR(glMatrixMultdEXT, )

void
glMatrixMultdEXT_p(mode, ...)
  GLenum mode;
CODE:
  OGLM_GLEWINIT
  OGLM_CHECK_ERR(glMatrixMultdEXT, )
  OGLM_AVAIL_CHECK(__glewMatrixMultdEXT, glMatrixMultdEXT)
  GLdouble* m = OGLM_GET_VARARGS(m,1,GLdouble,NV,16);
  glMatrixMultdEXT((GLenum )mode, (const GLdouble* )m);
  OGLM_CHECK_ERR(glMatrixMultdEXT, free(m);)
  free(m);

void
glMatrixMultfEXT_c(mode, m)
  GLenum mode;
  const GLfloat* m;
CODE:
  OGLM_GLEWINIT
  OGLM_CHECK_ERR(glMatrixMultfEXT, )
  OGLM_AVAIL_CHECK(__glewMatrixMultfEXT, glMatrixMultfEXT)
  glMatrixMultfEXT(mode, m);
  OGLM_CHECK_ERR(glMatrixMultfEXT, )

void
glMatrixMultfEXT_p(mode, ...)
  GLenum mode;
CODE:
  OGLM_GLEWINIT
  OGLM_CHECK_ERR(glMatrixMultfEXT, )
  OGLM_AVAIL_CHECK(__glewMatrixMultfEXT, glMatrixMultfEXT)
  GLfloat* m = OGLM_GET_VARARGS(m,1,GLfloat,NV,16);
  glMatrixMultfEXT((GLenum )mode, (const GLfloat* )m);
  OGLM_CHECK_ERR(glMatrixMultfEXT, free(m);)
  free(m);

void
glMatrixOrthoEXT(mode, left, right, bottom, top, zNear, zFar)
  GLenum mode;
  GLdouble left;
  GLdouble right;
  GLdouble bottom;
  GLdouble top;
  GLdouble zNear;
  GLdouble zFar;
CODE:
  OGLM_GLEWINIT
  OGLM_CHECK_ERR(glMatrixOrthoEXT, )
  OGLM_AVAIL_CHECK(__glewMatrixOrthoEXT, glMatrixOrthoEXT)
  glMatrixOrthoEXT(mode, left, right, bottom, top, zNear, zFar);
  OGLM_CHECK_ERR(glMatrixOrthoEXT, )

void
glMatrixPopEXT(mode)
  GLenum mode;
CODE:
  OGLM_GLEWINIT
  OGLM_CHECK_ERR(glMatrixPopEXT, )
  OGLM_AVAIL_CHECK(__glewMatrixPopEXT, glMatrixPopEXT)
  glMatrixPopEXT(mode);
  OGLM_CHECK_ERR(glMatrixPopEXT, )

void
glMatrixPushEXT(mode)
  GLenum mode;
CODE:
  OGLM_GLEWINIT
  OGLM_CHECK_ERR(glMatrixPushEXT, )
  OGLM_AVAIL_CHECK(__glewMatrixPushEXT, glMatrixPushEXT)
  glMatrixPushEXT(mode);
  OGLM_CHECK_ERR(glMatrixPushEXT, )

void
glMatrixRotatedEXT(mode, angle, x, y, z)
  GLenum mode;
  GLdouble angle;
  GLdouble x;
  GLdouble y;
  GLdouble z;
CODE:
  OGLM_GLEWINIT
  OGLM_CHECK_ERR(glMatrixRotatedEXT, )
  OGLM_AVAIL_CHECK(__glewMatrixRotatedEXT, glMatrixRotatedEXT)
  glMatrixRotatedEXT(mode, angle, x, y, z);
  OGLM_CHECK_ERR(glMatrixRotatedEXT, )

void
glMatrixRotatefEXT(mode, angle, x, y, z)
  GLenum mode;
  GLfloat angle;
  GLfloat x;
  GLfloat y;
  GLfloat z;
CODE:
  OGLM_GLEWINIT
  OGLM_CHECK_ERR(glMatrixRotatefEXT, )
  OGLM_AVAIL_CHECK(__glewMatrixRotatefEXT, glMatrixRotatefEXT)
  glMatrixRotatefEXT(mode, angle, x, y, z);
  OGLM_CHECK_ERR(glMatrixRotatefEXT, )

void
glMatrixScaledEXT(mode, x, y, z)
  GLenum mode;
  GLdouble x;
  GLdouble y;
  GLdouble z;
CODE:
  OGLM_GLEWINIT
  OGLM_CHECK_ERR(glMatrixScaledEXT, )
  OGLM_AVAIL_CHECK(__glewMatrixScaledEXT, glMatrixScaledEXT)
  glMatrixScaledEXT(mode, x, y, z);
  OGLM_CHECK_ERR(glMatrixScaledEXT, )

void
glMatrixScalefEXT(mode, x, y, z)
  GLenum mode;
  GLfloat x;
  GLfloat y;
  GLfloat z;
CODE:
  OGLM_GLEWINIT
  OGLM_CHECK_ERR(glMatrixScalefEXT, )
  OGLM_AVAIL_CHECK(__glewMatrixScalefEXT, glMatrixScalefEXT)
  glMatrixScalefEXT(mode, x, y, z);
  OGLM_CHECK_ERR(glMatrixScalefEXT, )

void
glMatrixTranslatedEXT(mode, x, y, z)
  GLenum mode;
  GLdouble x;
  GLdouble y;
  GLdouble z;
CODE:
  OGLM_GLEWINIT
  OGLM_CHECK_ERR(glMatrixTranslatedEXT, )
  OGLM_AVAIL_CHECK(__glewMatrixTranslatedEXT, glMatrixTranslatedEXT)
  glMatrixTranslatedEXT(mode, x, y, z);
  OGLM_CHECK_ERR(glMatrixTranslatedEXT, )

void
glMatrixTranslatefEXT(mode, x, y, z)
  GLenum mode;
  GLfloat x;
  GLfloat y;
  GLfloat z;
CODE:
  OGLM_GLEWINIT
  OGLM_CHECK_ERR(glMatrixTranslatefEXT, )
  OGLM_AVAIL_CHECK(__glewMatrixTranslatefEXT, glMatrixTranslatefEXT)
  glMatrixTranslatefEXT(mode, x, y, z);
  OGLM_CHECK_ERR(glMatrixTranslatefEXT, )

void
glMaxActiveShaderCoresARM(count)
  GLuint count;
CODE:
  OGLM_GLEWINIT
  OGLM_CHECK_ERR(glMaxActiveShaderCoresARM, )
  OGLM_AVAIL_CHECK(__glewMaxActiveShaderCoresARM, glMaxActiveShaderCoresARM)
  glMaxActiveShaderCoresARM(count);
  OGLM_CHECK_ERR(glMaxActiveShaderCoresARM, )

void
glMaxShaderCompilerThreadsKHR(count)
  GLuint count;
ALIAS:
  glMaxShaderCompilerThreadsARB = 1
CODE:
  OGLM_GLEWINIT
  OGLM_CHECK_ERR(glMaxShaderCompilerThreadsKHR, )
  OGLM_AVAIL_CHECK(__glewMaxShaderCompilerThreadsKHR, glMaxShaderCompilerThreadsKHR)
  glMaxShaderCompilerThreadsKHR(count);
  OGLM_CHECK_ERR(glMaxShaderCompilerThreadsKHR, )

void
glMemoryBarrier(barriers)
  GLbitfield barriers;
ALIAS:
  glMemoryBarrierEXT = 1
CODE:
  OGLM_GLEWINIT
  OGLM_CHECK_ERR(glMemoryBarrier, )
  OGLM_AVAIL_CHECK(__glewMemoryBarrier, glMemoryBarrier)
  glMemoryBarrier(barriers);
  OGLM_CHECK_ERR(glMemoryBarrier, )

void
glMemoryBarrierByRegion(barriers)
  GLbitfield barriers;
CODE:
  OGLM_GLEWINIT
  OGLM_CHECK_ERR(glMemoryBarrierByRegion, )
  OGLM_AVAIL_CHECK(__glewMemoryBarrierByRegion, glMemoryBarrierByRegion)
  glMemoryBarrierByRegion(barriers);
  OGLM_CHECK_ERR(glMemoryBarrierByRegion, )

void
glMemoryObjectParameterivEXT_c(memoryObject, pname, params)
  GLuint memoryObject;
  GLenum pname;
  const GLint* params;
CODE:
  OGLM_GLEWINIT
  OGLM_CHECK_ERR(glMemoryObjectParameterivEXT, )
  OGLM_AVAIL_CHECK(__glewMemoryObjectParameterivEXT, glMemoryObjectParameterivEXT)
  glMemoryObjectParameterivEXT(memoryObject, pname, params);
  OGLM_CHECK_ERR(glMemoryObjectParameterivEXT, )

void
glMeshBreadthSGIX(breadth)
  GLint breadth;
CODE:
  OGLM_GLEWINIT
  OGLM_CHECK_ERR(glMeshBreadthSGIX, )
  OGLM_AVAIL_CHECK(__glewMeshBreadthSGIX, glMeshBreadthSGIX)
  glMeshBreadthSGIX(breadth);
  OGLM_CHECK_ERR(glMeshBreadthSGIX, )

void
glMeshStrideSGIX(stride)
  GLint stride;
CODE:
  OGLM_GLEWINIT
  OGLM_CHECK_ERR(glMeshStrideSGIX, )
  OGLM_AVAIL_CHECK(__glewMeshStrideSGIX, glMeshStrideSGIX)
  glMeshStrideSGIX(stride);
  OGLM_CHECK_ERR(glMeshStrideSGIX, )

void
glMinSampleShading(value)
  GLclampf value;
ALIAS:
  glMinSampleShadingARB = 1
CODE:
  OGLM_GLEWINIT
  OGLM_CHECK_ERR(glMinSampleShading, )
  OGLM_AVAIL_CHECK(__glewMinSampleShading, glMinSampleShading)
  glMinSampleShading(value);
  OGLM_CHECK_ERR(glMinSampleShading, )

void
glMinSampleShadingOES(value)
  GLfloat value;
CODE:
  OGLM_GLEWINIT
  OGLM_CHECK_ERR(glMinSampleShadingOES, )
  OGLM_AVAIL_CHECK(__glewMinSampleShadingOES, glMinSampleShadingOES)
  glMinSampleShadingOES(value);
  OGLM_CHECK_ERR(glMinSampleShadingOES, )

void
glMinmax(target, internalformat, sink)
  GLenum target;
  GLenum internalformat;
  GLboolean sink;
ALIAS:
  glMinmaxEXT = 1
CODE:
  OGLM_GLEWINIT
  OGLM_CHECK_ERR(glMinmax, )
  OGLM_AVAIL_CHECK(__glewMinmax, glMinmax)
  glMinmax(target, internalformat, sink);
  OGLM_CHECK_ERR(glMinmax, )

void
glMultMatrixd_c(m)
  const GLdouble *m;
CODE:
  OGLM_GLEWINIT
  OGLM_CHECK_ERR(glMultMatrixd, )
  glMultMatrixd(m);
  OGLM_CHECK_ERR(glMultMatrixd, )

void
glMultMatrixd_p(...)
CODE:
  OGLM_GLEWINIT
  OGLM_CHECK_ERR(glMultMatrixd, )
  GLdouble *m = OGLM_GET_VARARGS(m,0,GLdouble,NV,16);
  glMultMatrixd((const GLdouble *)m);
  OGLM_CHECK_ERR(glMultMatrixd, free(m);)
  free(m);

void
glMultMatrixf_c(m)
  const GLfloat *m;
CODE:
  OGLM_GLEWINIT
  OGLM_CHECK_ERR(glMultMatrixf, )
  glMultMatrixf(m);
  OGLM_CHECK_ERR(glMultMatrixf, )

void
glMultMatrixf_p(...)
CODE:
  OGLM_GLEWINIT
  OGLM_CHECK_ERR(glMultMatrixf, )
  GLfloat *m = OGLM_GET_VARARGS(m,0,GLfloat,NV,16);
  glMultMatrixf((const GLfloat *)m);
  OGLM_CHECK_ERR(glMultMatrixf, free(m);)
  free(m);

void
glMultMatrixx_c(m)
  const GLfixed* m;
CODE:
  OGLM_GLEWINIT
  OGLM_CHECK_ERR(glMultMatrixx, )
  OGLM_AVAIL_CHECK(__glewMultMatrixx, glMultMatrixx)
  glMultMatrixx(m);
  OGLM_CHECK_ERR(glMultMatrixx, )

void
glMultMatrixx_p(...)
CODE:
  OGLM_GLEWINIT
  OGLM_CHECK_ERR(glMultMatrixx, )
  OGLM_AVAIL_CHECK(__glewMultMatrixx, glMultMatrixx)
  GLfixed* m = OGLM_GET_VARARGS(m,0,GLfixed,IV,16);
  glMultMatrixx((const GLfixed* )m);
  OGLM_CHECK_ERR(glMultMatrixx, free(m);)
  free(m);

void
glMultTransposeMatrixd_c(m)
  const GLdouble * m;
ALIAS:
  glMultTransposeMatrixdARB_c = 1
CODE:
  OGLM_GLEWINIT
  OGLM_CHECK_ERR(glMultTransposeMatrixd, )
  OGLM_AVAIL_CHECK(__glewMultTransposeMatrixd, glMultTransposeMatrixd)
  glMultTransposeMatrixd(m);
  OGLM_CHECK_ERR(glMultTransposeMatrixd, )

void
glMultTransposeMatrixd_p(...)
ALIAS:
  glMultTransposeMatrixdARB_p = 1
CODE:
  OGLM_GLEWINIT
  OGLM_CHECK_ERR(glMultTransposeMatrixd, )
  OGLM_AVAIL_CHECK(__glewMultTransposeMatrixd, glMultTransposeMatrixd)
  GLdouble * m = OGLM_GET_VARARGS(m,0,GLdouble,NV,16);
  glMultTransposeMatrixd((const GLdouble * )m);
  OGLM_CHECK_ERR(glMultTransposeMatrixd, free(m);)
  free(m);

void
glMultTransposeMatrixf_c(m)
  const GLfloat * m;
ALIAS:
  glMultTransposeMatrixfARB_c = 1
CODE:
  OGLM_GLEWINIT
  OGLM_CHECK_ERR(glMultTransposeMatrixf, )
  OGLM_AVAIL_CHECK(__glewMultTransposeMatrixf, glMultTransposeMatrixf)
  glMultTransposeMatrixf(m);
  OGLM_CHECK_ERR(glMultTransposeMatrixf, )

void
glMultTransposeMatrixf_p(...)
ALIAS:
  glMultTransposeMatrixfARB_p = 1
CODE:
  OGLM_GLEWINIT
  OGLM_CHECK_ERR(glMultTransposeMatrixf, )
  OGLM_AVAIL_CHECK(__glewMultTransposeMatrixf, glMultTransposeMatrixf)
  GLfloat * m = OGLM_GET_VARARGS(m,0,GLfloat,NV,16);
  glMultTransposeMatrixf((const GLfloat * )m);
  OGLM_CHECK_ERR(glMultTransposeMatrixf, free(m);)
  free(m);

void
glMultiDrawArrays_c(mode, first, count, drawcount)
  GLenum mode;
  const GLint *first;
  const GLsizei *count;
  GLsizei drawcount;
ALIAS:
  glMultiDrawArraysEXT_c = 1
CODE:
  OGLM_GLEWINIT
  OGLM_CHECK_ERR(glMultiDrawArrays, )
  OGLM_AVAIL_CHECK(__glewMultiDrawArrays, glMultiDrawArrays)
  glMultiDrawArrays(mode, first, count, drawcount);
  OGLM_CHECK_ERR(glMultiDrawArrays, )

void
glMultiDrawArrays_p(mode, firstSV, countSV)
  GLenum mode;
  SV *firstSV;
  SV *countSV;
ALIAS:
  glMultiDrawArraysEXT_p = 1
CODE:
  OGLM_GLEWINIT
  OGLM_CHECK_ERR(glMultiDrawArrays, )
  OGLM_AVAIL_CHECK(__glewMultiDrawArrays, glMultiDrawArrays)
  GLsizei drawcount = OGLM_LEN_ARRAY(drawcount, first);
  GLsizei *count = OGLM_GET_ARRAY(count, GLsizei, IV, drawcount);
  GLint *first = OGLM_GET_ARRAY(first, GLint, IV, drawcount);
  glMultiDrawArrays((GLenum )mode, (const GLint *)first, (const GLsizei *)count, (GLsizei )drawcount);
  OGLM_CHECK_ERR(glMultiDrawArrays, free(count);free(first);)
  free(count);free(first);

void
glMultiDrawArraysIndirect_c(mode, indirect, drawcount, stride)
  GLenum mode;
  const void *indirect;
  GLsizei drawcount;
  GLsizei stride;
ALIAS:
  glMultiDrawArraysIndirectAMD_c = 1
  glMultiDrawArraysIndirectEXT_c = 2
CODE:
  OGLM_GLEWINIT
  OGLM_CHECK_ERR(glMultiDrawArraysIndirect, )
  OGLM_AVAIL_CHECK(__glewMultiDrawArraysIndirect, glMultiDrawArraysIndirect)
  glMultiDrawArraysIndirect(mode, indirect, drawcount, stride);
  OGLM_CHECK_ERR(glMultiDrawArraysIndirect, )

void
glMultiDrawArraysIndirectBindlessCountNV_c(mode, indirect, drawCount, maxDrawCount, stride, vertexBufferCount)
  GLenum mode;
  const void *indirect;
  GLintptr drawCount;
  GLsizei maxDrawCount;
  GLsizei stride;
  GLint vertexBufferCount;
CODE:
  OGLM_GLEWINIT
  OGLM_CHECK_ERR(glMultiDrawArraysIndirectBindlessCountNV, )
  OGLM_AVAIL_CHECK(__glewMultiDrawArraysIndirectBindlessCountNV, glMultiDrawArraysIndirectBindlessCountNV)
  glMultiDrawArraysIndirectBindlessCountNV(mode, indirect, drawCount, maxDrawCount, stride, vertexBufferCount);
  OGLM_CHECK_ERR(glMultiDrawArraysIndirectBindlessCountNV, )

void
glMultiDrawArraysIndirectBindlessNV_c(mode, indirect, drawCount, stride, vertexBufferCount)
  GLenum mode;
  const void *indirect;
  GLsizei drawCount;
  GLsizei stride;
  GLint vertexBufferCount;
CODE:
  OGLM_GLEWINIT
  OGLM_CHECK_ERR(glMultiDrawArraysIndirectBindlessNV, )
  OGLM_AVAIL_CHECK(__glewMultiDrawArraysIndirectBindlessNV, glMultiDrawArraysIndirectBindlessNV)
  glMultiDrawArraysIndirectBindlessNV(mode, indirect, drawCount, stride, vertexBufferCount);
  OGLM_CHECK_ERR(glMultiDrawArraysIndirectBindlessNV, )

void
glMultiDrawArraysIndirectCount_c(mode, indirect, drawcount, maxdrawcount, stride)
  GLenum mode;
  const GLvoid *indirect;
  GLintptr drawcount;
  GLsizei maxdrawcount;
  GLsizei stride;
ALIAS:
  glMultiDrawArraysIndirectCountARB_c = 1
CODE:
  OGLM_GLEWINIT
  OGLM_CHECK_ERR(glMultiDrawArraysIndirectCount, )
  OGLM_AVAIL_CHECK(__glewMultiDrawArraysIndirectCount, glMultiDrawArraysIndirectCount)
  glMultiDrawArraysIndirectCount(mode, indirect, drawcount, maxdrawcount, stride);
  OGLM_CHECK_ERR(glMultiDrawArraysIndirectCount, )

void
glMultiDrawElementArrayAPPLE_c(mode, first, count, primcount)
  GLenum mode;
  const GLint* first;
  const GLsizei *count;
  GLsizei primcount;
CODE:
  OGLM_GLEWINIT
  OGLM_CHECK_ERR(glMultiDrawElementArrayAPPLE, )
  OGLM_AVAIL_CHECK(__glewMultiDrawElementArrayAPPLE, glMultiDrawElementArrayAPPLE)
  glMultiDrawElementArrayAPPLE(mode, first, count, primcount);
  OGLM_CHECK_ERR(glMultiDrawElementArrayAPPLE, )

void
glMultiDrawElementArrayAPPLE_p(mode, firstSV, countSV)
  GLenum mode;
  SV *firstSV;
  SV *countSV;
CODE:
  OGLM_GLEWINIT
  OGLM_CHECK_ERR(glMultiDrawElementArrayAPPLE, )
  OGLM_AVAIL_CHECK(__glewMultiDrawElementArrayAPPLE, glMultiDrawElementArrayAPPLE)
  GLsizei primcount = OGLM_LEN_ARRAY(primcount, first);
  GLsizei *count = OGLM_GET_ARRAY(count, GLsizei, IV, primcount);
  GLint* first = OGLM_GET_ARRAY(first, GLint, IV, primcount);
  glMultiDrawElementArrayAPPLE((GLenum )mode, (const GLint* )first, (const GLsizei *)count, (GLsizei )primcount);
  OGLM_CHECK_ERR(glMultiDrawElementArrayAPPLE, free(count);free(first);)
  free(count);free(first);

void
glMultiDrawElements_c(mode, count, type, indices, drawcount)
  GLenum mode;
  const GLsizei *count;
  GLenum type;
  const void *const* indices;
  GLsizei drawcount;
ALIAS:
  glMultiDrawElementsEXT_c = 1
CODE:
  OGLM_GLEWINIT
  OGLM_CHECK_ERR(glMultiDrawElements, )
  OGLM_AVAIL_CHECK(__glewMultiDrawElements, glMultiDrawElements)
  glMultiDrawElements(mode, count, type, indices, drawcount);
  OGLM_CHECK_ERR(glMultiDrawElements, )

void
glMultiDrawElementsBaseVertex_c(mode, count, type, indices, drawcount, basevertex)
  GLenum mode;
  const GLsizei* count;
  GLenum type;
  const void*const *indices;
  GLsizei drawcount;
  const GLint *basevertex;
ALIAS:
  glMultiDrawElementsBaseVertexEXT_c = 1
CODE:
  OGLM_GLEWINIT
  OGLM_CHECK_ERR(glMultiDrawElementsBaseVertex, )
  OGLM_AVAIL_CHECK(__glewMultiDrawElementsBaseVertex, glMultiDrawElementsBaseVertex)
  glMultiDrawElementsBaseVertex(mode, count, type, indices, drawcount, basevertex);
  OGLM_CHECK_ERR(glMultiDrawElementsBaseVertex, )

void
glMultiDrawElementsIndirect_c(mode, type, indirect, drawcount, stride)
  GLenum mode;
  GLenum type;
  const void *indirect;
  GLsizei drawcount;
  GLsizei stride;
ALIAS:
  glMultiDrawElementsIndirectAMD_c = 1
  glMultiDrawElementsIndirectEXT_c = 2
CODE:
  OGLM_GLEWINIT
  OGLM_CHECK_ERR(glMultiDrawElementsIndirect, )
  OGLM_AVAIL_CHECK(__glewMultiDrawElementsIndirect, glMultiDrawElementsIndirect)
  glMultiDrawElementsIndirect(mode, type, indirect, drawcount, stride);
  OGLM_CHECK_ERR(glMultiDrawElementsIndirect, )

void
glMultiDrawElementsIndirectBindlessCountNV_c(mode, type, indirect, drawCount, maxDrawCount, stride, vertexBufferCount)
  GLenum mode;
  GLenum type;
  const void *indirect;
  GLintptr drawCount;
  GLsizei maxDrawCount;
  GLsizei stride;
  GLint vertexBufferCount;
CODE:
  OGLM_GLEWINIT
  OGLM_CHECK_ERR(glMultiDrawElementsIndirectBindlessCountNV, )
  OGLM_AVAIL_CHECK(__glewMultiDrawElementsIndirectBindlessCountNV, glMultiDrawElementsIndirectBindlessCountNV)
  glMultiDrawElementsIndirectBindlessCountNV(mode, type, indirect, drawCount, maxDrawCount, stride, vertexBufferCount);
  OGLM_CHECK_ERR(glMultiDrawElementsIndirectBindlessCountNV, )

void
glMultiDrawElementsIndirectBindlessNV_c(mode, type, indirect, drawCount, stride, vertexBufferCount)
  GLenum mode;
  GLenum type;
  const void *indirect;
  GLsizei drawCount;
  GLsizei stride;
  GLint vertexBufferCount;
CODE:
  OGLM_GLEWINIT
  OGLM_CHECK_ERR(glMultiDrawElementsIndirectBindlessNV, )
  OGLM_AVAIL_CHECK(__glewMultiDrawElementsIndirectBindlessNV, glMultiDrawElementsIndirectBindlessNV)
  glMultiDrawElementsIndirectBindlessNV(mode, type, indirect, drawCount, stride, vertexBufferCount);
  OGLM_CHECK_ERR(glMultiDrawElementsIndirectBindlessNV, )

void
glMultiDrawElementsIndirectCount_c(mode, type, indirect, drawcount, maxdrawcount, stride)
  GLenum mode;
  GLenum type;
  const GLvoid *indirect;
  GLintptr drawcount;
  GLsizei maxdrawcount;
  GLsizei stride;
ALIAS:
  glMultiDrawElementsIndirectCountARB_c = 1
CODE:
  OGLM_GLEWINIT
  OGLM_CHECK_ERR(glMultiDrawElementsIndirectCount, )
  OGLM_AVAIL_CHECK(__glewMultiDrawElementsIndirectCount, glMultiDrawElementsIndirectCount)
  glMultiDrawElementsIndirectCount(mode, type, indirect, drawcount, maxdrawcount, stride);
  OGLM_CHECK_ERR(glMultiDrawElementsIndirectCount, )

void
glMultiDrawMeshTasksIndirectCountEXT(indirect, drawcount, maxdrawcount, stride)
  GLintptr indirect;
  GLintptr drawcount;
  GLsizei maxdrawcount;
  GLsizei stride;
CODE:
  OGLM_GLEWINIT
  OGLM_CHECK_ERR(glMultiDrawMeshTasksIndirectCountEXT, )
  OGLM_AVAIL_CHECK(__glewMultiDrawMeshTasksIndirectCountEXT, glMultiDrawMeshTasksIndirectCountEXT)
  glMultiDrawMeshTasksIndirectCountEXT(indirect, drawcount, maxdrawcount, stride);
  OGLM_CHECK_ERR(glMultiDrawMeshTasksIndirectCountEXT, )

void
glMultiDrawMeshTasksIndirectCountNV(indirect, drawcount, maxdrawcount, stride)
  GLintptr indirect;
  GLintptr drawcount;
  GLsizei maxdrawcount;
  GLsizei stride;
CODE:
  OGLM_GLEWINIT
  OGLM_CHECK_ERR(glMultiDrawMeshTasksIndirectCountNV, )
  OGLM_AVAIL_CHECK(__glewMultiDrawMeshTasksIndirectCountNV, glMultiDrawMeshTasksIndirectCountNV)
  glMultiDrawMeshTasksIndirectCountNV(indirect, drawcount, maxdrawcount, stride);
  OGLM_CHECK_ERR(glMultiDrawMeshTasksIndirectCountNV, )

void
glMultiDrawMeshTasksIndirectEXT(indirect, drawcount, stride)
  GLintptr indirect;
  GLsizei drawcount;
  GLsizei stride;
CODE:
  OGLM_GLEWINIT
  OGLM_CHECK_ERR(glMultiDrawMeshTasksIndirectEXT, )
  OGLM_AVAIL_CHECK(__glewMultiDrawMeshTasksIndirectEXT, glMultiDrawMeshTasksIndirectEXT)
  glMultiDrawMeshTasksIndirectEXT(indirect, drawcount, stride);
  OGLM_CHECK_ERR(glMultiDrawMeshTasksIndirectEXT, )

void
glMultiDrawMeshTasksIndirectNV(indirect, drawcount, stride)
  GLintptr indirect;
  GLsizei drawcount;
  GLsizei stride;
CODE:
  OGLM_GLEWINIT
  OGLM_CHECK_ERR(glMultiDrawMeshTasksIndirectNV, )
  OGLM_AVAIL_CHECK(__glewMultiDrawMeshTasksIndirectNV, glMultiDrawMeshTasksIndirectNV)
  glMultiDrawMeshTasksIndirectNV(indirect, drawcount, stride);
  OGLM_CHECK_ERR(glMultiDrawMeshTasksIndirectNV, )

void
glMultiDrawRangeElementArrayAPPLE_c(mode, start, end, first, count, primcount)
  GLenum mode;
  GLuint start;
  GLuint end;
  const GLint* first;
  const GLsizei *count;
  GLsizei primcount;
CODE:
  OGLM_GLEWINIT
  OGLM_CHECK_ERR(glMultiDrawRangeElementArrayAPPLE, )
  OGLM_AVAIL_CHECK(__glewMultiDrawRangeElementArrayAPPLE, glMultiDrawRangeElementArrayAPPLE)
  glMultiDrawRangeElementArrayAPPLE(mode, start, end, first, count, primcount);
  OGLM_CHECK_ERR(glMultiDrawRangeElementArrayAPPLE, )

void
glMultiDrawRangeElementArrayAPPLE_p(mode, start, end, firstSV, countSV)
  GLenum mode;
  GLuint start;
  GLuint end;
  SV *firstSV;
  SV *countSV;
CODE:
  OGLM_GLEWINIT
  OGLM_CHECK_ERR(glMultiDrawRangeElementArrayAPPLE, )
  OGLM_AVAIL_CHECK(__glewMultiDrawRangeElementArrayAPPLE, glMultiDrawRangeElementArrayAPPLE)
  GLsizei primcount = OGLM_LEN_ARRAY(primcount, first);
  GLsizei *count = OGLM_GET_ARRAY(count, GLsizei, IV, primcount);
  GLint* first = OGLM_GET_ARRAY(first, GLint, IV, primcount);
  glMultiDrawRangeElementArrayAPPLE((GLenum )mode, (GLuint )start, (GLuint )end, (const GLint* )first, (const GLsizei *)count, (GLsizei )primcount);
  OGLM_CHECK_ERR(glMultiDrawRangeElementArrayAPPLE, free(count);free(first);)
  free(count);free(first);

void
glMultiModeDrawArraysIBM_c(mode, first, count, primcount, modestride)
  const GLenum* mode;
  const GLint *first;
  const GLsizei *count;
  GLsizei primcount;
  GLint modestride;
CODE:
  OGLM_GLEWINIT
  OGLM_CHECK_ERR(glMultiModeDrawArraysIBM, )
  OGLM_AVAIL_CHECK(__glewMultiModeDrawArraysIBM, glMultiModeDrawArraysIBM)
  glMultiModeDrawArraysIBM(mode, first, count, primcount, modestride);
  OGLM_CHECK_ERR(glMultiModeDrawArraysIBM, )

void
glMultiModeDrawElementsIBM_c(mode, count, type, indices, primcount, modestride)
  const GLenum* mode;
  const GLsizei *count;
  GLenum type;
  const void *const *indices;
  GLsizei primcount;
  GLint modestride;
CODE:
  OGLM_GLEWINIT
  OGLM_CHECK_ERR(glMultiModeDrawElementsIBM, )
  OGLM_AVAIL_CHECK(__glewMultiModeDrawElementsIBM, glMultiModeDrawElementsIBM)
  glMultiModeDrawElementsIBM(mode, count, type, indices, primcount, modestride);
  OGLM_CHECK_ERR(glMultiModeDrawElementsIBM, )

void
glMultiTexBufferEXT(texunit, target, internalformat, buffer)
  GLenum texunit;
  GLenum target;
  GLenum internalformat;
  GLuint buffer;
CODE:
  OGLM_GLEWINIT
  OGLM_CHECK_ERR(glMultiTexBufferEXT, )
  OGLM_AVAIL_CHECK(__glewMultiTexBufferEXT, glMultiTexBufferEXT)
  glMultiTexBufferEXT(texunit, target, internalformat, buffer);
  OGLM_CHECK_ERR(glMultiTexBufferEXT, )

void
glMultiTexCoord1d(target, s)
  GLenum target;
  GLdouble s;
ALIAS:
  glMultiTexCoord1dARB = 1
CODE:
  OGLM_GLEWINIT
  OGLM_CHECK_ERR(glMultiTexCoord1d, )
  OGLM_AVAIL_CHECK(__glewMultiTexCoord1d, glMultiTexCoord1d)
  glMultiTexCoord1d(target, s);
  OGLM_CHECK_ERR(glMultiTexCoord1d, )

void
glMultiTexCoord1dv_c(target, v)
  GLenum target;
  const GLdouble *v;
ALIAS:
  glMultiTexCoord1dvARB_c = 1
CODE:
  OGLM_GLEWINIT
  OGLM_CHECK_ERR(glMultiTexCoord1dv, )
  OGLM_AVAIL_CHECK(__glewMultiTexCoord1dv, glMultiTexCoord1dv)
  glMultiTexCoord1dv(target, v);
  OGLM_CHECK_ERR(glMultiTexCoord1dv, )

void
glMultiTexCoord1dv_p(target, ...)
  GLenum target;
ALIAS:
  glMultiTexCoord1dvARB_p = 1
CODE:
  OGLM_GLEWINIT
  OGLM_CHECK_ERR(glMultiTexCoord1dv, )
  OGLM_AVAIL_CHECK(__glewMultiTexCoord1dv, glMultiTexCoord1dv)
  GLdouble *v = OGLM_GET_VARARGS(v,1,GLdouble,NV,1);
  glMultiTexCoord1dv((GLenum )target, (const GLdouble *)v);
  OGLM_CHECK_ERR(glMultiTexCoord1dv, free(v);)
  free(v);

void
glMultiTexCoord1f(target, s)
  GLenum target;
  GLfloat s;
ALIAS:
  glMultiTexCoord1fARB = 1
CODE:
  OGLM_GLEWINIT
  OGLM_CHECK_ERR(glMultiTexCoord1f, )
  OGLM_AVAIL_CHECK(__glewMultiTexCoord1f, glMultiTexCoord1f)
  glMultiTexCoord1f(target, s);
  OGLM_CHECK_ERR(glMultiTexCoord1f, )

void
glMultiTexCoord1fv_c(target, v)
  GLenum target;
  const GLfloat *v;
ALIAS:
  glMultiTexCoord1fvARB_c = 1
CODE:
  OGLM_GLEWINIT
  OGLM_CHECK_ERR(glMultiTexCoord1fv, )
  OGLM_AVAIL_CHECK(__glewMultiTexCoord1fv, glMultiTexCoord1fv)
  glMultiTexCoord1fv(target, v);
  OGLM_CHECK_ERR(glMultiTexCoord1fv, )

void
glMultiTexCoord1fv_p(target, ...)
  GLenum target;
ALIAS:
  glMultiTexCoord1fvARB_p = 1
CODE:
  OGLM_GLEWINIT
  OGLM_CHECK_ERR(glMultiTexCoord1fv, )
  OGLM_AVAIL_CHECK(__glewMultiTexCoord1fv, glMultiTexCoord1fv)
  GLfloat *v = OGLM_GET_VARARGS(v,1,GLfloat,NV,1);
  glMultiTexCoord1fv((GLenum )target, (const GLfloat *)v);
  OGLM_CHECK_ERR(glMultiTexCoord1fv, free(v);)
  free(v);

void
glMultiTexCoord1hNV(target, s)
  GLenum target;
  GLhalf s;
CODE:
  OGLM_GLEWINIT
  OGLM_CHECK_ERR(glMultiTexCoord1hNV, )
  OGLM_AVAIL_CHECK(__glewMultiTexCoord1hNV, glMultiTexCoord1hNV)
  glMultiTexCoord1hNV(target, s);
  OGLM_CHECK_ERR(glMultiTexCoord1hNV, )

void
glMultiTexCoord1hvNV_c(target, v)
  GLenum target;
  const GLhalf* v;
CODE:
  OGLM_GLEWINIT
  OGLM_CHECK_ERR(glMultiTexCoord1hvNV, )
  OGLM_AVAIL_CHECK(__glewMultiTexCoord1hvNV, glMultiTexCoord1hvNV)
  glMultiTexCoord1hvNV(target, v);
  OGLM_CHECK_ERR(glMultiTexCoord1hvNV, )

void
glMultiTexCoord1hvNV_p(target, ...)
  GLenum target;
CODE:
  OGLM_GLEWINIT
  OGLM_CHECK_ERR(glMultiTexCoord1hvNV, )
  OGLM_AVAIL_CHECK(__glewMultiTexCoord1hvNV, glMultiTexCoord1hvNV)
  GLhalf* v = OGLM_GET_VARARGS(v,1,GLhalf,NV,1);
  glMultiTexCoord1hvNV((GLenum )target, (const GLhalf* )v);
  OGLM_CHECK_ERR(glMultiTexCoord1hvNV, free(v);)
  free(v);

void
glMultiTexCoord1i(target, s)
  GLenum target;
  GLint s;
ALIAS:
  glMultiTexCoord1iARB = 1
CODE:
  OGLM_GLEWINIT
  OGLM_CHECK_ERR(glMultiTexCoord1i, )
  OGLM_AVAIL_CHECK(__glewMultiTexCoord1i, glMultiTexCoord1i)
  glMultiTexCoord1i(target, s);
  OGLM_CHECK_ERR(glMultiTexCoord1i, )

void
glMultiTexCoord1iv_c(target, v)
  GLenum target;
  const GLint *v;
ALIAS:
  glMultiTexCoord1ivARB_c = 1
CODE:
  OGLM_GLEWINIT
  OGLM_CHECK_ERR(glMultiTexCoord1iv, )
  OGLM_AVAIL_CHECK(__glewMultiTexCoord1iv, glMultiTexCoord1iv)
  glMultiTexCoord1iv(target, v);
  OGLM_CHECK_ERR(glMultiTexCoord1iv, )

void
glMultiTexCoord1iv_p(target, ...)
  GLenum target;
ALIAS:
  glMultiTexCoord1ivARB_p = 1
CODE:
  OGLM_GLEWINIT
  OGLM_CHECK_ERR(glMultiTexCoord1iv, )
  OGLM_AVAIL_CHECK(__glewMultiTexCoord1iv, glMultiTexCoord1iv)
  GLint *v = OGLM_GET_VARARGS(v,1,GLint,IV,1);
  glMultiTexCoord1iv((GLenum )target, (const GLint *)v);
  OGLM_CHECK_ERR(glMultiTexCoord1iv, free(v);)
  free(v);

void
glMultiTexCoord1s(target, s)
  GLenum target;
  GLshort s;
ALIAS:
  glMultiTexCoord1sARB = 1
CODE:
  OGLM_GLEWINIT
  OGLM_CHECK_ERR(glMultiTexCoord1s, )
  OGLM_AVAIL_CHECK(__glewMultiTexCoord1s, glMultiTexCoord1s)
  glMultiTexCoord1s(target, s);
  OGLM_CHECK_ERR(glMultiTexCoord1s, )

void
glMultiTexCoord1sv_c(target, v)
  GLenum target;
  const GLshort *v;
ALIAS:
  glMultiTexCoord1svARB_c = 1
CODE:
  OGLM_GLEWINIT
  OGLM_CHECK_ERR(glMultiTexCoord1sv, )
  OGLM_AVAIL_CHECK(__glewMultiTexCoord1sv, glMultiTexCoord1sv)
  glMultiTexCoord1sv(target, v);
  OGLM_CHECK_ERR(glMultiTexCoord1sv, )

void
glMultiTexCoord1sv_p(target, ...)
  GLenum target;
ALIAS:
  glMultiTexCoord1svARB_p = 1
CODE:
  OGLM_GLEWINIT
  OGLM_CHECK_ERR(glMultiTexCoord1sv, )
  OGLM_AVAIL_CHECK(__glewMultiTexCoord1sv, glMultiTexCoord1sv)
  GLshort *v = OGLM_GET_VARARGS(v,1,GLshort,IV,1);
  glMultiTexCoord1sv((GLenum )target, (const GLshort *)v);
  OGLM_CHECK_ERR(glMultiTexCoord1sv, free(v);)
  free(v);

void
glMultiTexCoord2d(target, s, t)
  GLenum target;
  GLdouble s;
  GLdouble t;
ALIAS:
  glMultiTexCoord2dARB = 1
CODE:
  OGLM_GLEWINIT
  OGLM_CHECK_ERR(glMultiTexCoord2d, )
  OGLM_AVAIL_CHECK(__glewMultiTexCoord2d, glMultiTexCoord2d)
  glMultiTexCoord2d(target, s, t);
  OGLM_CHECK_ERR(glMultiTexCoord2d, )

void
glMultiTexCoord2dv_c(target, v)
  GLenum target;
  const GLdouble *v;
ALIAS:
  glMultiTexCoord2dvARB_c = 1
CODE:
  OGLM_GLEWINIT
  OGLM_CHECK_ERR(glMultiTexCoord2dv, )
  OGLM_AVAIL_CHECK(__glewMultiTexCoord2dv, glMultiTexCoord2dv)
  glMultiTexCoord2dv(target, v);
  OGLM_CHECK_ERR(glMultiTexCoord2dv, )

void
glMultiTexCoord2dv_p(target, ...)
  GLenum target;
ALIAS:
  glMultiTexCoord2dvARB_p = 1
CODE:
  OGLM_GLEWINIT
  OGLM_CHECK_ERR(glMultiTexCoord2dv, )
  OGLM_AVAIL_CHECK(__glewMultiTexCoord2dv, glMultiTexCoord2dv)
  GLdouble *v = OGLM_GET_VARARGS(v,1,GLdouble,NV,2);
  glMultiTexCoord2dv((GLenum )target, (const GLdouble *)v);
  OGLM_CHECK_ERR(glMultiTexCoord2dv, free(v);)
  free(v);

void
glMultiTexCoord2f(target, s, t)
  GLenum target;
  GLfloat s;
  GLfloat t;
ALIAS:
  glMultiTexCoord2fARB = 1
CODE:
  OGLM_GLEWINIT
  OGLM_CHECK_ERR(glMultiTexCoord2f, )
  OGLM_AVAIL_CHECK(__glewMultiTexCoord2f, glMultiTexCoord2f)
  glMultiTexCoord2f(target, s, t);
  OGLM_CHECK_ERR(glMultiTexCoord2f, )

void
glMultiTexCoord2fv_c(target, v)
  GLenum target;
  const GLfloat *v;
ALIAS:
  glMultiTexCoord2fvARB_c = 1
CODE:
  OGLM_GLEWINIT
  OGLM_CHECK_ERR(glMultiTexCoord2fv, )
  OGLM_AVAIL_CHECK(__glewMultiTexCoord2fv, glMultiTexCoord2fv)
  glMultiTexCoord2fv(target, v);
  OGLM_CHECK_ERR(glMultiTexCoord2fv, )

void
glMultiTexCoord2fv_p(target, ...)
  GLenum target;
ALIAS:
  glMultiTexCoord2fvARB_p = 1
CODE:
  OGLM_GLEWINIT
  OGLM_CHECK_ERR(glMultiTexCoord2fv, )
  OGLM_AVAIL_CHECK(__glewMultiTexCoord2fv, glMultiTexCoord2fv)
  GLfloat *v = OGLM_GET_VARARGS(v,1,GLfloat,NV,2);
  glMultiTexCoord2fv((GLenum )target, (const GLfloat *)v);
  OGLM_CHECK_ERR(glMultiTexCoord2fv, free(v);)
  free(v);

void
glMultiTexCoord2hNV(target, s, t)
  GLenum target;
  GLhalf s;
  GLhalf t;
CODE:
  OGLM_GLEWINIT
  OGLM_CHECK_ERR(glMultiTexCoord2hNV, )
  OGLM_AVAIL_CHECK(__glewMultiTexCoord2hNV, glMultiTexCoord2hNV)
  glMultiTexCoord2hNV(target, s, t);
  OGLM_CHECK_ERR(glMultiTexCoord2hNV, )

void
glMultiTexCoord2hvNV_c(target, v)
  GLenum target;
  const GLhalf* v;
CODE:
  OGLM_GLEWINIT
  OGLM_CHECK_ERR(glMultiTexCoord2hvNV, )
  OGLM_AVAIL_CHECK(__glewMultiTexCoord2hvNV, glMultiTexCoord2hvNV)
  glMultiTexCoord2hvNV(target, v);
  OGLM_CHECK_ERR(glMultiTexCoord2hvNV, )

void
glMultiTexCoord2hvNV_p(target, ...)
  GLenum target;
CODE:
  OGLM_GLEWINIT
  OGLM_CHECK_ERR(glMultiTexCoord2hvNV, )
  OGLM_AVAIL_CHECK(__glewMultiTexCoord2hvNV, glMultiTexCoord2hvNV)
  GLhalf* v = OGLM_GET_VARARGS(v,1,GLhalf,NV,2);
  glMultiTexCoord2hvNV((GLenum )target, (const GLhalf* )v);
  OGLM_CHECK_ERR(glMultiTexCoord2hvNV, free(v);)
  free(v);

void
glMultiTexCoord2i(target, s, t)
  GLenum target;
  GLint s;
  GLint t;
ALIAS:
  glMultiTexCoord2iARB = 1
CODE:
  OGLM_GLEWINIT
  OGLM_CHECK_ERR(glMultiTexCoord2i, )
  OGLM_AVAIL_CHECK(__glewMultiTexCoord2i, glMultiTexCoord2i)
  glMultiTexCoord2i(target, s, t);
  OGLM_CHECK_ERR(glMultiTexCoord2i, )

void
glMultiTexCoord2iv_c(target, v)
  GLenum target;
  const GLint *v;
ALIAS:
  glMultiTexCoord2ivARB_c = 1
CODE:
  OGLM_GLEWINIT
  OGLM_CHECK_ERR(glMultiTexCoord2iv, )
  OGLM_AVAIL_CHECK(__glewMultiTexCoord2iv, glMultiTexCoord2iv)
  glMultiTexCoord2iv(target, v);
  OGLM_CHECK_ERR(glMultiTexCoord2iv, )

void
glMultiTexCoord2iv_p(target, ...)
  GLenum target;
ALIAS:
  glMultiTexCoord2ivARB_p = 1
CODE:
  OGLM_GLEWINIT
  OGLM_CHECK_ERR(glMultiTexCoord2iv, )
  OGLM_AVAIL_CHECK(__glewMultiTexCoord2iv, glMultiTexCoord2iv)
  GLint *v = OGLM_GET_VARARGS(v,1,GLint,IV,2);
  glMultiTexCoord2iv((GLenum )target, (const GLint *)v);
  OGLM_CHECK_ERR(glMultiTexCoord2iv, free(v);)
  free(v);

void
glMultiTexCoord2s(target, s, t)
  GLenum target;
  GLshort s;
  GLshort t;
ALIAS:
  glMultiTexCoord2sARB = 1
CODE:
  OGLM_GLEWINIT
  OGLM_CHECK_ERR(glMultiTexCoord2s, )
  OGLM_AVAIL_CHECK(__glewMultiTexCoord2s, glMultiTexCoord2s)
  glMultiTexCoord2s(target, s, t);
  OGLM_CHECK_ERR(glMultiTexCoord2s, )

void
glMultiTexCoord2sv_c(target, v)
  GLenum target;
  const GLshort *v;
ALIAS:
  glMultiTexCoord2svARB_c = 1
CODE:
  OGLM_GLEWINIT
  OGLM_CHECK_ERR(glMultiTexCoord2sv, )
  OGLM_AVAIL_CHECK(__glewMultiTexCoord2sv, glMultiTexCoord2sv)
  glMultiTexCoord2sv(target, v);
  OGLM_CHECK_ERR(glMultiTexCoord2sv, )

void
glMultiTexCoord2sv_p(target, ...)
  GLenum target;
ALIAS:
  glMultiTexCoord2svARB_p = 1
CODE:
  OGLM_GLEWINIT
  OGLM_CHECK_ERR(glMultiTexCoord2sv, )
  OGLM_AVAIL_CHECK(__glewMultiTexCoord2sv, glMultiTexCoord2sv)
  GLshort *v = OGLM_GET_VARARGS(v,1,GLshort,IV,2);
  glMultiTexCoord2sv((GLenum )target, (const GLshort *)v);
  OGLM_CHECK_ERR(glMultiTexCoord2sv, free(v);)
  free(v);

void
glMultiTexCoord3d(target, s, t, r)
  GLenum target;
  GLdouble s;
  GLdouble t;
  GLdouble r;
ALIAS:
  glMultiTexCoord3dARB = 1
CODE:
  OGLM_GLEWINIT
  OGLM_CHECK_ERR(glMultiTexCoord3d, )
  OGLM_AVAIL_CHECK(__glewMultiTexCoord3d, glMultiTexCoord3d)
  glMultiTexCoord3d(target, s, t, r);
  OGLM_CHECK_ERR(glMultiTexCoord3d, )

void
glMultiTexCoord3dv_c(target, v)
  GLenum target;
  const GLdouble *v;
ALIAS:
  glMultiTexCoord3dvARB_c = 1
CODE:
  OGLM_GLEWINIT
  OGLM_CHECK_ERR(glMultiTexCoord3dv, )
  OGLM_AVAIL_CHECK(__glewMultiTexCoord3dv, glMultiTexCoord3dv)
  glMultiTexCoord3dv(target, v);
  OGLM_CHECK_ERR(glMultiTexCoord3dv, )

void
glMultiTexCoord3dv_p(target, ...)
  GLenum target;
ALIAS:
  glMultiTexCoord3dvARB_p = 1
CODE:
  OGLM_GLEWINIT
  OGLM_CHECK_ERR(glMultiTexCoord3dv, )
  OGLM_AVAIL_CHECK(__glewMultiTexCoord3dv, glMultiTexCoord3dv)
  GLdouble *v = OGLM_GET_VARARGS(v,1,GLdouble,NV,3);
  glMultiTexCoord3dv((GLenum )target, (const GLdouble *)v);
  OGLM_CHECK_ERR(glMultiTexCoord3dv, free(v);)
  free(v);

void
glMultiTexCoord3f(target, s, t, r)
  GLenum target;
  GLfloat s;
  GLfloat t;
  GLfloat r;
ALIAS:
  glMultiTexCoord3fARB = 1
CODE:
  OGLM_GLEWINIT
  OGLM_CHECK_ERR(glMultiTexCoord3f, )
  OGLM_AVAIL_CHECK(__glewMultiTexCoord3f, glMultiTexCoord3f)
  glMultiTexCoord3f(target, s, t, r);
  OGLM_CHECK_ERR(glMultiTexCoord3f, )

void
glMultiTexCoord3fv_c(target, v)
  GLenum target;
  const GLfloat *v;
ALIAS:
  glMultiTexCoord3fvARB_c = 1
CODE:
  OGLM_GLEWINIT
  OGLM_CHECK_ERR(glMultiTexCoord3fv, )
  OGLM_AVAIL_CHECK(__glewMultiTexCoord3fv, glMultiTexCoord3fv)
  glMultiTexCoord3fv(target, v);
  OGLM_CHECK_ERR(glMultiTexCoord3fv, )

void
glMultiTexCoord3fv_p(target, ...)
  GLenum target;
ALIAS:
  glMultiTexCoord3fvARB_p = 1
CODE:
  OGLM_GLEWINIT
  OGLM_CHECK_ERR(glMultiTexCoord3fv, )
  OGLM_AVAIL_CHECK(__glewMultiTexCoord3fv, glMultiTexCoord3fv)
  GLfloat *v = OGLM_GET_VARARGS(v,1,GLfloat,NV,3);
  glMultiTexCoord3fv((GLenum )target, (const GLfloat *)v);
  OGLM_CHECK_ERR(glMultiTexCoord3fv, free(v);)
  free(v);

void
glMultiTexCoord3hNV(target, s, t, r)
  GLenum target;
  GLhalf s;
  GLhalf t;
  GLhalf r;
CODE:
  OGLM_GLEWINIT
  OGLM_CHECK_ERR(glMultiTexCoord3hNV, )
  OGLM_AVAIL_CHECK(__glewMultiTexCoord3hNV, glMultiTexCoord3hNV)
  glMultiTexCoord3hNV(target, s, t, r);
  OGLM_CHECK_ERR(glMultiTexCoord3hNV, )

void
glMultiTexCoord3hvNV_c(target, v)
  GLenum target;
  const GLhalf* v;
CODE:
  OGLM_GLEWINIT
  OGLM_CHECK_ERR(glMultiTexCoord3hvNV, )
  OGLM_AVAIL_CHECK(__glewMultiTexCoord3hvNV, glMultiTexCoord3hvNV)
  glMultiTexCoord3hvNV(target, v);
  OGLM_CHECK_ERR(glMultiTexCoord3hvNV, )

void
glMultiTexCoord3hvNV_p(target, ...)
  GLenum target;
CODE:
  OGLM_GLEWINIT
  OGLM_CHECK_ERR(glMultiTexCoord3hvNV, )
  OGLM_AVAIL_CHECK(__glewMultiTexCoord3hvNV, glMultiTexCoord3hvNV)
  GLhalf* v = OGLM_GET_VARARGS(v,1,GLhalf,NV,3);
  glMultiTexCoord3hvNV((GLenum )target, (const GLhalf* )v);
  OGLM_CHECK_ERR(glMultiTexCoord3hvNV, free(v);)
  free(v);

void
glMultiTexCoord3i(target, s, t, r)
  GLenum target;
  GLint s;
  GLint t;
  GLint r;
ALIAS:
  glMultiTexCoord3iARB = 1
CODE:
  OGLM_GLEWINIT
  OGLM_CHECK_ERR(glMultiTexCoord3i, )
  OGLM_AVAIL_CHECK(__glewMultiTexCoord3i, glMultiTexCoord3i)
  glMultiTexCoord3i(target, s, t, r);
  OGLM_CHECK_ERR(glMultiTexCoord3i, )

void
glMultiTexCoord3iv_c(target, v)
  GLenum target;
  const GLint *v;
ALIAS:
  glMultiTexCoord3ivARB_c = 1
CODE:
  OGLM_GLEWINIT
  OGLM_CHECK_ERR(glMultiTexCoord3iv, )
  OGLM_AVAIL_CHECK(__glewMultiTexCoord3iv, glMultiTexCoord3iv)
  glMultiTexCoord3iv(target, v);
  OGLM_CHECK_ERR(glMultiTexCoord3iv, )

void
glMultiTexCoord3iv_p(target, ...)
  GLenum target;
ALIAS:
  glMultiTexCoord3ivARB_p = 1
CODE:
  OGLM_GLEWINIT
  OGLM_CHECK_ERR(glMultiTexCoord3iv, )
  OGLM_AVAIL_CHECK(__glewMultiTexCoord3iv, glMultiTexCoord3iv)
  GLint *v = OGLM_GET_VARARGS(v,1,GLint,IV,3);
  glMultiTexCoord3iv((GLenum )target, (const GLint *)v);
  OGLM_CHECK_ERR(glMultiTexCoord3iv, free(v);)
  free(v);

void
glMultiTexCoord3s(target, s, t, r)
  GLenum target;
  GLshort s;
  GLshort t;
  GLshort r;
ALIAS:
  glMultiTexCoord3sARB = 1
CODE:
  OGLM_GLEWINIT
  OGLM_CHECK_ERR(glMultiTexCoord3s, )
  OGLM_AVAIL_CHECK(__glewMultiTexCoord3s, glMultiTexCoord3s)
  glMultiTexCoord3s(target, s, t, r);
  OGLM_CHECK_ERR(glMultiTexCoord3s, )

void
glMultiTexCoord3sv_c(target, v)
  GLenum target;
  const GLshort *v;
ALIAS:
  glMultiTexCoord3svARB_c = 1
CODE:
  OGLM_GLEWINIT
  OGLM_CHECK_ERR(glMultiTexCoord3sv, )
  OGLM_AVAIL_CHECK(__glewMultiTexCoord3sv, glMultiTexCoord3sv)
  glMultiTexCoord3sv(target, v);
  OGLM_CHECK_ERR(glMultiTexCoord3sv, )

void
glMultiTexCoord3sv_p(target, ...)
  GLenum target;
ALIAS:
  glMultiTexCoord3svARB_p = 1
CODE:
  OGLM_GLEWINIT
  OGLM_CHECK_ERR(glMultiTexCoord3sv, )
  OGLM_AVAIL_CHECK(__glewMultiTexCoord3sv, glMultiTexCoord3sv)
  GLshort *v = OGLM_GET_VARARGS(v,1,GLshort,IV,3);
  glMultiTexCoord3sv((GLenum )target, (const GLshort *)v);
  OGLM_CHECK_ERR(glMultiTexCoord3sv, free(v);)
  free(v);

void
glMultiTexCoord4d(target, s, t, r, q)
  GLenum target;
  GLdouble s;
  GLdouble t;
  GLdouble r;
  GLdouble q;
ALIAS:
  glMultiTexCoord4dARB = 1
CODE:
  OGLM_GLEWINIT
  OGLM_CHECK_ERR(glMultiTexCoord4d, )
  OGLM_AVAIL_CHECK(__glewMultiTexCoord4d, glMultiTexCoord4d)
  glMultiTexCoord4d(target, s, t, r, q);
  OGLM_CHECK_ERR(glMultiTexCoord4d, )

void
glMultiTexCoord4dv_c(target, v)
  GLenum target;
  const GLdouble *v;
ALIAS:
  glMultiTexCoord4dvARB_c = 1
CODE:
  OGLM_GLEWINIT
  OGLM_CHECK_ERR(glMultiTexCoord4dv, )
  OGLM_AVAIL_CHECK(__glewMultiTexCoord4dv, glMultiTexCoord4dv)
  glMultiTexCoord4dv(target, v);
  OGLM_CHECK_ERR(glMultiTexCoord4dv, )

void
glMultiTexCoord4dv_p(target, ...)
  GLenum target;
ALIAS:
  glMultiTexCoord4dvARB_p = 1
CODE:
  OGLM_GLEWINIT
  OGLM_CHECK_ERR(glMultiTexCoord4dv, )
  OGLM_AVAIL_CHECK(__glewMultiTexCoord4dv, glMultiTexCoord4dv)
  GLdouble *v = OGLM_GET_VARARGS(v,1,GLdouble,NV,4);
  glMultiTexCoord4dv((GLenum )target, (const GLdouble *)v);
  OGLM_CHECK_ERR(glMultiTexCoord4dv, free(v);)
  free(v);

void
glMultiTexCoord4f(target, s, t, r, q)
  GLenum target;
  GLfloat s;
  GLfloat t;
  GLfloat r;
  GLfloat q;
ALIAS:
  glMultiTexCoord4fARB = 1
CODE:
  OGLM_GLEWINIT
  OGLM_CHECK_ERR(glMultiTexCoord4f, )
  OGLM_AVAIL_CHECK(__glewMultiTexCoord4f, glMultiTexCoord4f)
  glMultiTexCoord4f(target, s, t, r, q);
  OGLM_CHECK_ERR(glMultiTexCoord4f, )

void
glMultiTexCoord4fv_c(target, v)
  GLenum target;
  const GLfloat *v;
ALIAS:
  glMultiTexCoord4fvARB_c = 1
CODE:
  OGLM_GLEWINIT
  OGLM_CHECK_ERR(glMultiTexCoord4fv, )
  OGLM_AVAIL_CHECK(__glewMultiTexCoord4fv, glMultiTexCoord4fv)
  glMultiTexCoord4fv(target, v);
  OGLM_CHECK_ERR(glMultiTexCoord4fv, )

void
glMultiTexCoord4fv_p(target, ...)
  GLenum target;
ALIAS:
  glMultiTexCoord4fvARB_p = 1
CODE:
  OGLM_GLEWINIT
  OGLM_CHECK_ERR(glMultiTexCoord4fv, )
  OGLM_AVAIL_CHECK(__glewMultiTexCoord4fv, glMultiTexCoord4fv)
  GLfloat *v = OGLM_GET_VARARGS(v,1,GLfloat,NV,4);
  glMultiTexCoord4fv((GLenum )target, (const GLfloat *)v);
  OGLM_CHECK_ERR(glMultiTexCoord4fv, free(v);)
  free(v);

void
glMultiTexCoord4hNV(target, s, t, r, q)
  GLenum target;
  GLhalf s;
  GLhalf t;
  GLhalf r;
  GLhalf q;
CODE:
  OGLM_GLEWINIT
  OGLM_CHECK_ERR(glMultiTexCoord4hNV, )
  OGLM_AVAIL_CHECK(__glewMultiTexCoord4hNV, glMultiTexCoord4hNV)
  glMultiTexCoord4hNV(target, s, t, r, q);
  OGLM_CHECK_ERR(glMultiTexCoord4hNV, )

void
glMultiTexCoord4hvNV_c(target, v)
  GLenum target;
  const GLhalf* v;
CODE:
  OGLM_GLEWINIT
  OGLM_CHECK_ERR(glMultiTexCoord4hvNV, )
  OGLM_AVAIL_CHECK(__glewMultiTexCoord4hvNV, glMultiTexCoord4hvNV)
  glMultiTexCoord4hvNV(target, v);
  OGLM_CHECK_ERR(glMultiTexCoord4hvNV, )

void
glMultiTexCoord4hvNV_p(target, ...)
  GLenum target;
CODE:
  OGLM_GLEWINIT
  OGLM_CHECK_ERR(glMultiTexCoord4hvNV, )
  OGLM_AVAIL_CHECK(__glewMultiTexCoord4hvNV, glMultiTexCoord4hvNV)
  GLhalf* v = OGLM_GET_VARARGS(v,1,GLhalf,NV,4);
  glMultiTexCoord4hvNV((GLenum )target, (const GLhalf* )v);
  OGLM_CHECK_ERR(glMultiTexCoord4hvNV, free(v);)
  free(v);

void
glMultiTexCoord4i(target, s, t, r, q)
  GLenum target;
  GLint s;
  GLint t;
  GLint r;
  GLint q;
ALIAS:
  glMultiTexCoord4iARB = 1
CODE:
  OGLM_GLEWINIT
  OGLM_CHECK_ERR(glMultiTexCoord4i, )
  OGLM_AVAIL_CHECK(__glewMultiTexCoord4i, glMultiTexCoord4i)
  glMultiTexCoord4i(target, s, t, r, q);
  OGLM_CHECK_ERR(glMultiTexCoord4i, )

void
glMultiTexCoord4iv_c(target, v)
  GLenum target;
  const GLint *v;
ALIAS:
  glMultiTexCoord4ivARB_c = 1
CODE:
  OGLM_GLEWINIT
  OGLM_CHECK_ERR(glMultiTexCoord4iv, )
  OGLM_AVAIL_CHECK(__glewMultiTexCoord4iv, glMultiTexCoord4iv)
  glMultiTexCoord4iv(target, v);
  OGLM_CHECK_ERR(glMultiTexCoord4iv, )

void
glMultiTexCoord4iv_p(target, ...)
  GLenum target;
ALIAS:
  glMultiTexCoord4ivARB_p = 1
CODE:
  OGLM_GLEWINIT
  OGLM_CHECK_ERR(glMultiTexCoord4iv, )
  OGLM_AVAIL_CHECK(__glewMultiTexCoord4iv, glMultiTexCoord4iv)
  GLint *v = OGLM_GET_VARARGS(v,1,GLint,IV,4);
  glMultiTexCoord4iv((GLenum )target, (const GLint *)v);
  OGLM_CHECK_ERR(glMultiTexCoord4iv, free(v);)
  free(v);

void
glMultiTexCoord4s(target, s, t, r, q)
  GLenum target;
  GLshort s;
  GLshort t;
  GLshort r;
  GLshort q;
ALIAS:
  glMultiTexCoord4sARB = 1
CODE:
  OGLM_GLEWINIT
  OGLM_CHECK_ERR(glMultiTexCoord4s, )
  OGLM_AVAIL_CHECK(__glewMultiTexCoord4s, glMultiTexCoord4s)
  glMultiTexCoord4s(target, s, t, r, q);
  OGLM_CHECK_ERR(glMultiTexCoord4s, )

void
glMultiTexCoord4sv_c(target, v)
  GLenum target;
  const GLshort *v;
ALIAS:
  glMultiTexCoord4svARB_c = 1
CODE:
  OGLM_GLEWINIT
  OGLM_CHECK_ERR(glMultiTexCoord4sv, )
  OGLM_AVAIL_CHECK(__glewMultiTexCoord4sv, glMultiTexCoord4sv)
  glMultiTexCoord4sv(target, v);
  OGLM_CHECK_ERR(glMultiTexCoord4sv, )

void
glMultiTexCoord4sv_p(target, ...)
  GLenum target;
ALIAS:
  glMultiTexCoord4svARB_p = 1
CODE:
  OGLM_GLEWINIT
  OGLM_CHECK_ERR(glMultiTexCoord4sv, )
  OGLM_AVAIL_CHECK(__glewMultiTexCoord4sv, glMultiTexCoord4sv)
  GLshort *v = OGLM_GET_VARARGS(v,1,GLshort,IV,4);
  glMultiTexCoord4sv((GLenum )target, (const GLshort *)v);
  OGLM_CHECK_ERR(glMultiTexCoord4sv, free(v);)
  free(v);

void
glMultiTexCoord4x(texture, s, t, r, q)
  GLenum texture;
  GLfixed s;
  GLfixed t;
  GLfixed r;
  GLfixed q;
CODE:
  OGLM_GLEWINIT
  OGLM_CHECK_ERR(glMultiTexCoord4x, )
  OGLM_AVAIL_CHECK(__glewMultiTexCoord4x, glMultiTexCoord4x)
  glMultiTexCoord4x(texture, s, t, r, q);
  OGLM_CHECK_ERR(glMultiTexCoord4x, )

void
glMultiTexCoordP1ui(texture, type, coords)
  GLenum texture;
  GLenum type;
  GLuint coords;
CODE:
  OGLM_GLEWINIT
  OGLM_CHECK_ERR(glMultiTexCoordP1ui, )
  OGLM_AVAIL_CHECK(__glewMultiTexCoordP1ui, glMultiTexCoordP1ui)
  glMultiTexCoordP1ui(texture, type, coords);
  OGLM_CHECK_ERR(glMultiTexCoordP1ui, )

void
glMultiTexCoordP1uiv_c(texture, type, coords)
  GLenum texture;
  GLenum type;
  const GLuint* coords;
CODE:
  OGLM_GLEWINIT
  OGLM_CHECK_ERR(glMultiTexCoordP1uiv, )
  OGLM_AVAIL_CHECK(__glewMultiTexCoordP1uiv, glMultiTexCoordP1uiv)
  glMultiTexCoordP1uiv(texture, type, coords);
  OGLM_CHECK_ERR(glMultiTexCoordP1uiv, )

void
glMultiTexCoordP1uiv_p(texture, type, ...)
  GLenum texture;
  GLenum type;
CODE:
  OGLM_GLEWINIT
  OGLM_CHECK_ERR(glMultiTexCoordP1uiv, )
  OGLM_AVAIL_CHECK(__glewMultiTexCoordP1uiv, glMultiTexCoordP1uiv)
  GLuint* coords = OGLM_GET_VARARGS(coords,2,GLuint,UV,1);
  glMultiTexCoordP1uiv((GLenum )texture, (GLenum )type, (const GLuint* )coords);
  OGLM_CHECK_ERR(glMultiTexCoordP1uiv, free(coords);)
  free(coords);

void
glMultiTexCoordP2ui(texture, type, coords)
  GLenum texture;
  GLenum type;
  GLuint coords;
CODE:
  OGLM_GLEWINIT
  OGLM_CHECK_ERR(glMultiTexCoordP2ui, )
  OGLM_AVAIL_CHECK(__glewMultiTexCoordP2ui, glMultiTexCoordP2ui)
  glMultiTexCoordP2ui(texture, type, coords);
  OGLM_CHECK_ERR(glMultiTexCoordP2ui, )

void
glMultiTexCoordP2uiv_c(texture, type, coords)
  GLenum texture;
  GLenum type;
  const GLuint* coords;
CODE:
  OGLM_GLEWINIT
  OGLM_CHECK_ERR(glMultiTexCoordP2uiv, )
  OGLM_AVAIL_CHECK(__glewMultiTexCoordP2uiv, glMultiTexCoordP2uiv)
  glMultiTexCoordP2uiv(texture, type, coords);
  OGLM_CHECK_ERR(glMultiTexCoordP2uiv, )

void
glMultiTexCoordP2uiv_p(texture, type, ...)
  GLenum texture;
  GLenum type;
CODE:
  OGLM_GLEWINIT
  OGLM_CHECK_ERR(glMultiTexCoordP2uiv, )
  OGLM_AVAIL_CHECK(__glewMultiTexCoordP2uiv, glMultiTexCoordP2uiv)
  GLuint* coords = OGLM_GET_VARARGS(coords,2,GLuint,UV,1);
  glMultiTexCoordP2uiv((GLenum )texture, (GLenum )type, (const GLuint* )coords);
  OGLM_CHECK_ERR(glMultiTexCoordP2uiv, free(coords);)
  free(coords);

void
glMultiTexCoordP3ui(texture, type, coords)
  GLenum texture;
  GLenum type;
  GLuint coords;
CODE:
  OGLM_GLEWINIT
  OGLM_CHECK_ERR(glMultiTexCoordP3ui, )
  OGLM_AVAIL_CHECK(__glewMultiTexCoordP3ui, glMultiTexCoordP3ui)
  glMultiTexCoordP3ui(texture, type, coords);
  OGLM_CHECK_ERR(glMultiTexCoordP3ui, )

void
glMultiTexCoordP3uiv_c(texture, type, coords)
  GLenum texture;
  GLenum type;
  const GLuint* coords;
CODE:
  OGLM_GLEWINIT
  OGLM_CHECK_ERR(glMultiTexCoordP3uiv, )
  OGLM_AVAIL_CHECK(__glewMultiTexCoordP3uiv, glMultiTexCoordP3uiv)
  glMultiTexCoordP3uiv(texture, type, coords);
  OGLM_CHECK_ERR(glMultiTexCoordP3uiv, )

void
glMultiTexCoordP3uiv_p(texture, type, ...)
  GLenum texture;
  GLenum type;
CODE:
  OGLM_GLEWINIT
  OGLM_CHECK_ERR(glMultiTexCoordP3uiv, )
  OGLM_AVAIL_CHECK(__glewMultiTexCoordP3uiv, glMultiTexCoordP3uiv)
  GLuint* coords = OGLM_GET_VARARGS(coords,2,GLuint,UV,1);
  glMultiTexCoordP3uiv((GLenum )texture, (GLenum )type, (const GLuint* )coords);
  OGLM_CHECK_ERR(glMultiTexCoordP3uiv, free(coords);)
  free(coords);

void
glMultiTexCoordP4ui(texture, type, coords)
  GLenum texture;
  GLenum type;
  GLuint coords;
CODE:
  OGLM_GLEWINIT
  OGLM_CHECK_ERR(glMultiTexCoordP4ui, )
  OGLM_AVAIL_CHECK(__glewMultiTexCoordP4ui, glMultiTexCoordP4ui)
  glMultiTexCoordP4ui(texture, type, coords);
  OGLM_CHECK_ERR(glMultiTexCoordP4ui, )

void
glMultiTexCoordP4uiv_c(texture, type, coords)
  GLenum texture;
  GLenum type;
  const GLuint* coords;
CODE:
  OGLM_GLEWINIT
  OGLM_CHECK_ERR(glMultiTexCoordP4uiv, )
  OGLM_AVAIL_CHECK(__glewMultiTexCoordP4uiv, glMultiTexCoordP4uiv)
  glMultiTexCoordP4uiv(texture, type, coords);
  OGLM_CHECK_ERR(glMultiTexCoordP4uiv, )

void
glMultiTexCoordP4uiv_p(texture, type, ...)
  GLenum texture;
  GLenum type;
CODE:
  OGLM_GLEWINIT
  OGLM_CHECK_ERR(glMultiTexCoordP4uiv, )
  OGLM_AVAIL_CHECK(__glewMultiTexCoordP4uiv, glMultiTexCoordP4uiv)
  GLuint* coords = OGLM_GET_VARARGS(coords,2,GLuint,UV,1);
  glMultiTexCoordP4uiv((GLenum )texture, (GLenum )type, (const GLuint* )coords);
  OGLM_CHECK_ERR(glMultiTexCoordP4uiv, free(coords);)
  free(coords);

void
glMultiTexCoordPointerEXT_c(texunit, size, type, stride, pointer)
  GLenum texunit;
  GLint size;
  GLenum type;
  GLsizei stride;
  const void *pointer;
CODE:
  OGLM_GLEWINIT
  OGLM_CHECK_ERR(glMultiTexCoordPointerEXT, )
  OGLM_AVAIL_CHECK(__glewMultiTexCoordPointerEXT, glMultiTexCoordPointerEXT)
  glMultiTexCoordPointerEXT(texunit, size, type, stride, pointer);
  OGLM_CHECK_ERR(glMultiTexCoordPointerEXT, )

void
glMultiTexEnvfEXT(texunit, target, pname, param)
  GLenum texunit;
  GLenum target;
  GLenum pname;
  GLfloat param;
CODE:
  OGLM_GLEWINIT
  OGLM_CHECK_ERR(glMultiTexEnvfEXT, )
  OGLM_AVAIL_CHECK(__glewMultiTexEnvfEXT, glMultiTexEnvfEXT)
  glMultiTexEnvfEXT(texunit, target, pname, param);
  OGLM_CHECK_ERR(glMultiTexEnvfEXT, )

void
glMultiTexEnvfvEXT_c(texunit, target, pname, params)
  GLenum texunit;
  GLenum target;
  GLenum pname;
  const GLfloat* params;
CODE:
  OGLM_GLEWINIT
  OGLM_CHECK_ERR(glMultiTexEnvfvEXT, )
  OGLM_AVAIL_CHECK(__glewMultiTexEnvfvEXT, glMultiTexEnvfvEXT)
  glMultiTexEnvfvEXT(texunit, target, pname, params);
  OGLM_CHECK_ERR(glMultiTexEnvfvEXT, )

void
glMultiTexEnvfvEXT_p(texunit, target, pname, ...)
  GLenum texunit;
  GLenum target;
  GLenum pname;
CODE:
  OGLM_GLEWINIT
  OGLM_CHECK_ERR(glMultiTexEnvfvEXT, )
  OGLM_AVAIL_CHECK(__glewMultiTexEnvfvEXT, glMultiTexEnvfvEXT)
  OGLM_SIZE_ENUM(TextureEnvParameter,pname,1)
  GLfloat* params = OGLM_GET_VARARGS(params,3,GLfloat,NV,pname_count);
  glMultiTexEnvfvEXT((GLenum )texunit, (GLenum )target, (GLenum )pname, (const GLfloat* )params);
  OGLM_CHECK_ERR(glMultiTexEnvfvEXT, free(params);)
  free(params);

void
glMultiTexEnviEXT(texunit, target, pname, param)
  GLenum texunit;
  GLenum target;
  GLenum pname;
  GLint param;
CODE:
  OGLM_GLEWINIT
  OGLM_CHECK_ERR(glMultiTexEnviEXT, )
  OGLM_AVAIL_CHECK(__glewMultiTexEnviEXT, glMultiTexEnviEXT)
  glMultiTexEnviEXT(texunit, target, pname, param);
  OGLM_CHECK_ERR(glMultiTexEnviEXT, )

void
glMultiTexEnvivEXT_c(texunit, target, pname, params)
  GLenum texunit;
  GLenum target;
  GLenum pname;
  const GLint* params;
CODE:
  OGLM_GLEWINIT
  OGLM_CHECK_ERR(glMultiTexEnvivEXT, )
  OGLM_AVAIL_CHECK(__glewMultiTexEnvivEXT, glMultiTexEnvivEXT)
  glMultiTexEnvivEXT(texunit, target, pname, params);
  OGLM_CHECK_ERR(glMultiTexEnvivEXT, )

void
glMultiTexEnvivEXT_p(texunit, target, pname, ...)
  GLenum texunit;
  GLenum target;
  GLenum pname;
CODE:
  OGLM_GLEWINIT
  OGLM_CHECK_ERR(glMultiTexEnvivEXT, )
  OGLM_AVAIL_CHECK(__glewMultiTexEnvivEXT, glMultiTexEnvivEXT)
  OGLM_SIZE_ENUM(TextureEnvParameter,pname,1)
  GLint* params = OGLM_GET_VARARGS(params,3,GLint,IV,pname_count);
  glMultiTexEnvivEXT((GLenum )texunit, (GLenum )target, (GLenum )pname, (const GLint* )params);
  OGLM_CHECK_ERR(glMultiTexEnvivEXT, free(params);)
  free(params);

void
glMultiTexGendEXT(texunit, coord, pname, param)
  GLenum texunit;
  GLenum coord;
  GLenum pname;
  GLdouble param;
CODE:
  OGLM_GLEWINIT
  OGLM_CHECK_ERR(glMultiTexGendEXT, )
  OGLM_AVAIL_CHECK(__glewMultiTexGendEXT, glMultiTexGendEXT)
  glMultiTexGendEXT(texunit, coord, pname, param);
  OGLM_CHECK_ERR(glMultiTexGendEXT, )

void
glMultiTexGendvEXT_c(texunit, coord, pname, params)
  GLenum texunit;
  GLenum coord;
  GLenum pname;
  const GLdouble* params;
CODE:
  OGLM_GLEWINIT
  OGLM_CHECK_ERR(glMultiTexGendvEXT, )
  OGLM_AVAIL_CHECK(__glewMultiTexGendvEXT, glMultiTexGendvEXT)
  glMultiTexGendvEXT(texunit, coord, pname, params);
  OGLM_CHECK_ERR(glMultiTexGendvEXT, )

void
glMultiTexGendvEXT_p(texunit, coord, pname, ...)
  GLenum texunit;
  GLenum coord;
  GLenum pname;
CODE:
  OGLM_GLEWINIT
  OGLM_CHECK_ERR(glMultiTexGendvEXT, )
  OGLM_AVAIL_CHECK(__glewMultiTexGendvEXT, glMultiTexGendvEXT)
  OGLM_SIZE_ENUM(TextureGenParameter,pname,1)
  GLdouble* params = OGLM_GET_VARARGS(params,3,GLdouble,NV,pname_count);
  glMultiTexGendvEXT((GLenum )texunit, (GLenum )coord, (GLenum )pname, (const GLdouble* )params);
  OGLM_CHECK_ERR(glMultiTexGendvEXT, free(params);)
  free(params);

void
glMultiTexGenfEXT(texunit, coord, pname, param)
  GLenum texunit;
  GLenum coord;
  GLenum pname;
  GLfloat param;
CODE:
  OGLM_GLEWINIT
  OGLM_CHECK_ERR(glMultiTexGenfEXT, )
  OGLM_AVAIL_CHECK(__glewMultiTexGenfEXT, glMultiTexGenfEXT)
  glMultiTexGenfEXT(texunit, coord, pname, param);
  OGLM_CHECK_ERR(glMultiTexGenfEXT, )

void
glMultiTexGenfvEXT_c(texunit, coord, pname, params)
  GLenum texunit;
  GLenum coord;
  GLenum pname;
  const GLfloat* params;
CODE:
  OGLM_GLEWINIT
  OGLM_CHECK_ERR(glMultiTexGenfvEXT, )
  OGLM_AVAIL_CHECK(__glewMultiTexGenfvEXT, glMultiTexGenfvEXT)
  glMultiTexGenfvEXT(texunit, coord, pname, params);
  OGLM_CHECK_ERR(glMultiTexGenfvEXT, )

void
glMultiTexGenfvEXT_p(texunit, coord, pname, ...)
  GLenum texunit;
  GLenum coord;
  GLenum pname;
CODE:
  OGLM_GLEWINIT
  OGLM_CHECK_ERR(glMultiTexGenfvEXT, )
  OGLM_AVAIL_CHECK(__glewMultiTexGenfvEXT, glMultiTexGenfvEXT)
  OGLM_SIZE_ENUM(TextureGenParameter,pname,1)
  GLfloat* params = OGLM_GET_VARARGS(params,3,GLfloat,NV,pname_count);
  glMultiTexGenfvEXT((GLenum )texunit, (GLenum )coord, (GLenum )pname, (const GLfloat* )params);
  OGLM_CHECK_ERR(glMultiTexGenfvEXT, free(params);)
  free(params);

void
glMultiTexGeniEXT(texunit, coord, pname, param)
  GLenum texunit;
  GLenum coord;
  GLenum pname;
  GLint param;
CODE:
  OGLM_GLEWINIT
  OGLM_CHECK_ERR(glMultiTexGeniEXT, )
  OGLM_AVAIL_CHECK(__glewMultiTexGeniEXT, glMultiTexGeniEXT)
  glMultiTexGeniEXT(texunit, coord, pname, param);
  OGLM_CHECK_ERR(glMultiTexGeniEXT, )

void
glMultiTexGenivEXT_c(texunit, coord, pname, params)
  GLenum texunit;
  GLenum coord;
  GLenum pname;
  const GLint* params;
CODE:
  OGLM_GLEWINIT
  OGLM_CHECK_ERR(glMultiTexGenivEXT, )
  OGLM_AVAIL_CHECK(__glewMultiTexGenivEXT, glMultiTexGenivEXT)
  glMultiTexGenivEXT(texunit, coord, pname, params);
  OGLM_CHECK_ERR(glMultiTexGenivEXT, )

void
glMultiTexGenivEXT_p(texunit, coord, pname, ...)
  GLenum texunit;
  GLenum coord;
  GLenum pname;
CODE:
  OGLM_GLEWINIT
  OGLM_CHECK_ERR(glMultiTexGenivEXT, )
  OGLM_AVAIL_CHECK(__glewMultiTexGenivEXT, glMultiTexGenivEXT)
  OGLM_SIZE_ENUM(TextureGenParameter,pname,1)
  GLint* params = OGLM_GET_VARARGS(params,3,GLint,IV,pname_count);
  glMultiTexGenivEXT((GLenum )texunit, (GLenum )coord, (GLenum )pname, (const GLint* )params);
  OGLM_CHECK_ERR(glMultiTexGenivEXT, free(params);)
  free(params);

void
glMultiTexImage1DEXT_c(texunit, target, level, internalformat, width, border, format, type, pixels)
  GLenum texunit;
  GLenum target;
  GLint level;
  GLint internalformat;
  GLsizei width;
  GLint border;
  GLenum format;
  GLenum type;
  const void *pixels;
CODE:
  OGLM_GLEWINIT
  OGLM_CHECK_ERR(glMultiTexImage1DEXT, )
  OGLM_AVAIL_CHECK(__glewMultiTexImage1DEXT, glMultiTexImage1DEXT)
  glMultiTexImage1DEXT(texunit, target, level, internalformat, width, border, format, type, pixels);
  OGLM_CHECK_ERR(glMultiTexImage1DEXT, )

void
glMultiTexImage2DEXT_c(texunit, target, level, internalformat, width, height, border, format, type, pixels)
  GLenum texunit;
  GLenum target;
  GLint level;
  GLint internalformat;
  GLsizei width;
  GLsizei height;
  GLint border;
  GLenum format;
  GLenum type;
  const void *pixels;
CODE:
  OGLM_GLEWINIT
  OGLM_CHECK_ERR(glMultiTexImage2DEXT, )
  OGLM_AVAIL_CHECK(__glewMultiTexImage2DEXT, glMultiTexImage2DEXT)
  glMultiTexImage2DEXT(texunit, target, level, internalformat, width, height, border, format, type, pixels);
  OGLM_CHECK_ERR(glMultiTexImage2DEXT, )

void
glMultiTexImage3DEXT_c(texunit, target, level, internalformat, width, height, depth, border, format, type, pixels)
  GLenum texunit;
  GLenum target;
  GLint level;
  GLint internalformat;
  GLsizei width;
  GLsizei height;
  GLsizei depth;
  GLint border;
  GLenum format;
  GLenum type;
  const void *pixels;
CODE:
  OGLM_GLEWINIT
  OGLM_CHECK_ERR(glMultiTexImage3DEXT, )
  OGLM_AVAIL_CHECK(__glewMultiTexImage3DEXT, glMultiTexImage3DEXT)
  glMultiTexImage3DEXT(texunit, target, level, internalformat, width, height, depth, border, format, type, pixels);
  OGLM_CHECK_ERR(glMultiTexImage3DEXT, )

void
glMultiTexParameterIivEXT_c(texunit, target, pname, params)
  GLenum texunit;
  GLenum target;
  GLenum pname;
  const GLint* params;
CODE:
  OGLM_GLEWINIT
  OGLM_CHECK_ERR(glMultiTexParameterIivEXT, )
  OGLM_AVAIL_CHECK(__glewMultiTexParameterIivEXT, glMultiTexParameterIivEXT)
  glMultiTexParameterIivEXT(texunit, target, pname, params);
  OGLM_CHECK_ERR(glMultiTexParameterIivEXT, )

void
glMultiTexParameterIivEXT_p(texunit, target, pname, ...)
  GLenum texunit;
  GLenum target;
  GLenum pname;
CODE:
  OGLM_GLEWINIT
  OGLM_CHECK_ERR(glMultiTexParameterIivEXT, )
  OGLM_AVAIL_CHECK(__glewMultiTexParameterIivEXT, glMultiTexParameterIivEXT)
  OGLM_SIZE_ENUM(TextureParameterName,pname,1)
  GLint* params = OGLM_GET_VARARGS(params,3,GLint,IV,pname_count);
  glMultiTexParameterIivEXT((GLenum )texunit, (GLenum )target, (GLenum )pname, (const GLint* )params);
  OGLM_CHECK_ERR(glMultiTexParameterIivEXT, free(params);)
  free(params);

void
glMultiTexParameterIuivEXT_c(texunit, target, pname, params)
  GLenum texunit;
  GLenum target;
  GLenum pname;
  const GLuint* params;
CODE:
  OGLM_GLEWINIT
  OGLM_CHECK_ERR(glMultiTexParameterIuivEXT, )
  OGLM_AVAIL_CHECK(__glewMultiTexParameterIuivEXT, glMultiTexParameterIuivEXT)
  glMultiTexParameterIuivEXT(texunit, target, pname, params);
  OGLM_CHECK_ERR(glMultiTexParameterIuivEXT, )

void
glMultiTexParameterIuivEXT_p(texunit, target, pname, ...)
  GLenum texunit;
  GLenum target;
  GLenum pname;
CODE:
  OGLM_GLEWINIT
  OGLM_CHECK_ERR(glMultiTexParameterIuivEXT, )
  OGLM_AVAIL_CHECK(__glewMultiTexParameterIuivEXT, glMultiTexParameterIuivEXT)
  OGLM_SIZE_ENUM(TextureParameterName,pname,1)
  GLuint* params = OGLM_GET_VARARGS(params,3,GLuint,UV,pname_count);
  glMultiTexParameterIuivEXT((GLenum )texunit, (GLenum )target, (GLenum )pname, (const GLuint* )params);
  OGLM_CHECK_ERR(glMultiTexParameterIuivEXT, free(params);)
  free(params);

void
glMultiTexParameterfEXT(texunit, target, pname, param)
  GLenum texunit;
  GLenum target;
  GLenum pname;
  GLfloat param;
CODE:
  OGLM_GLEWINIT
  OGLM_CHECK_ERR(glMultiTexParameterfEXT, )
  OGLM_AVAIL_CHECK(__glewMultiTexParameterfEXT, glMultiTexParameterfEXT)
  glMultiTexParameterfEXT(texunit, target, pname, param);
  OGLM_CHECK_ERR(glMultiTexParameterfEXT, )

void
glMultiTexParameterfvEXT_c(texunit, target, pname, params)
  GLenum texunit;
  GLenum target;
  GLenum pname;
  const GLfloat* params;
CODE:
  OGLM_GLEWINIT
  OGLM_CHECK_ERR(glMultiTexParameterfvEXT, )
  OGLM_AVAIL_CHECK(__glewMultiTexParameterfvEXT, glMultiTexParameterfvEXT)
  glMultiTexParameterfvEXT(texunit, target, pname, params);
  OGLM_CHECK_ERR(glMultiTexParameterfvEXT, )

void
glMultiTexParameterfvEXT_p(texunit, target, pname, ...)
  GLenum texunit;
  GLenum target;
  GLenum pname;
CODE:
  OGLM_GLEWINIT
  OGLM_CHECK_ERR(glMultiTexParameterfvEXT, )
  OGLM_AVAIL_CHECK(__glewMultiTexParameterfvEXT, glMultiTexParameterfvEXT)
  OGLM_SIZE_ENUM(TextureParameterName,pname,1)
  GLfloat* params = OGLM_GET_VARARGS(params,3,GLfloat,NV,pname_count);
  glMultiTexParameterfvEXT((GLenum )texunit, (GLenum )target, (GLenum )pname, (const GLfloat* )params);
  OGLM_CHECK_ERR(glMultiTexParameterfvEXT, free(params);)
  free(params);

void
glMultiTexParameteriEXT(texunit, target, pname, param)
  GLenum texunit;
  GLenum target;
  GLenum pname;
  GLint param;
CODE:
  OGLM_GLEWINIT
  OGLM_CHECK_ERR(glMultiTexParameteriEXT, )
  OGLM_AVAIL_CHECK(__glewMultiTexParameteriEXT, glMultiTexParameteriEXT)
  glMultiTexParameteriEXT(texunit, target, pname, param);
  OGLM_CHECK_ERR(glMultiTexParameteriEXT, )

void
glMultiTexParameterivEXT_c(texunit, target, pname, params)
  GLenum texunit;
  GLenum target;
  GLenum pname;
  const GLint* params;
CODE:
  OGLM_GLEWINIT
  OGLM_CHECK_ERR(glMultiTexParameterivEXT, )
  OGLM_AVAIL_CHECK(__glewMultiTexParameterivEXT, glMultiTexParameterivEXT)
  glMultiTexParameterivEXT(texunit, target, pname, params);
  OGLM_CHECK_ERR(glMultiTexParameterivEXT, )

void
glMultiTexParameterivEXT_p(texunit, target, pname, ...)
  GLenum texunit;
  GLenum target;
  GLenum pname;
CODE:
  OGLM_GLEWINIT
  OGLM_CHECK_ERR(glMultiTexParameterivEXT, )
  OGLM_AVAIL_CHECK(__glewMultiTexParameterivEXT, glMultiTexParameterivEXT)
  OGLM_SIZE_ENUM(TextureParameterName,pname,1)
  GLint* params = OGLM_GET_VARARGS(params,3,GLint,IV,pname_count);
  glMultiTexParameterivEXT((GLenum )texunit, (GLenum )target, (GLenum )pname, (const GLint* )params);
  OGLM_CHECK_ERR(glMultiTexParameterivEXT, free(params);)
  free(params);

void
glMultiTexRenderbufferEXT(texunit, target, renderbuffer)
  GLenum texunit;
  GLenum target;
  GLuint renderbuffer;
CODE:
  OGLM_GLEWINIT
  OGLM_CHECK_ERR(glMultiTexRenderbufferEXT, )
  OGLM_AVAIL_CHECK(__glewMultiTexRenderbufferEXT, glMultiTexRenderbufferEXT)
  glMultiTexRenderbufferEXT(texunit, target, renderbuffer);
  OGLM_CHECK_ERR(glMultiTexRenderbufferEXT, )

void
glMultiTexSubImage1DEXT_c(texunit, target, level, xoffset, width, format, type, pixels)
  GLenum texunit;
  GLenum target;
  GLint level;
  GLint xoffset;
  GLsizei width;
  GLenum format;
  GLenum type;
  const void *pixels;
CODE:
  OGLM_GLEWINIT
  OGLM_CHECK_ERR(glMultiTexSubImage1DEXT, )
  OGLM_AVAIL_CHECK(__glewMultiTexSubImage1DEXT, glMultiTexSubImage1DEXT)
  glMultiTexSubImage1DEXT(texunit, target, level, xoffset, width, format, type, pixels);
  OGLM_CHECK_ERR(glMultiTexSubImage1DEXT, )

void
glMultiTexSubImage2DEXT_c(texunit, target, level, xoffset, yoffset, width, height, format, type, pixels)
  GLenum texunit;
  GLenum target;
  GLint level;
  GLint xoffset;
  GLint yoffset;
  GLsizei width;
  GLsizei height;
  GLenum format;
  GLenum type;
  const void *pixels;
CODE:
  OGLM_GLEWINIT
  OGLM_CHECK_ERR(glMultiTexSubImage2DEXT, )
  OGLM_AVAIL_CHECK(__glewMultiTexSubImage2DEXT, glMultiTexSubImage2DEXT)
  glMultiTexSubImage2DEXT(texunit, target, level, xoffset, yoffset, width, height, format, type, pixels);
  OGLM_CHECK_ERR(glMultiTexSubImage2DEXT, )

void
glMultiTexSubImage3DEXT_c(texunit, target, level, xoffset, yoffset, zoffset, width, height, depth, format, type, pixels)
  GLenum texunit;
  GLenum target;
  GLint level;
  GLint xoffset;
  GLint yoffset;
  GLint zoffset;
  GLsizei width;
  GLsizei height;
  GLsizei depth;
  GLenum format;
  GLenum type;
  const void *pixels;
CODE:
  OGLM_GLEWINIT
  OGLM_CHECK_ERR(glMultiTexSubImage3DEXT, )
  OGLM_AVAIL_CHECK(__glewMultiTexSubImage3DEXT, glMultiTexSubImage3DEXT)
  glMultiTexSubImage3DEXT(texunit, target, level, xoffset, yoffset, zoffset, width, height, depth, format, type, pixels);
  OGLM_CHECK_ERR(glMultiTexSubImage3DEXT, )

void
glMulticastBarrierNV()
CODE:
  OGLM_GLEWINIT
  OGLM_CHECK_ERR(glMulticastBarrierNV, )
  OGLM_AVAIL_CHECK(__glewMulticastBarrierNV, glMulticastBarrierNV)
  glMulticastBarrierNV();
  OGLM_CHECK_ERR(glMulticastBarrierNV, )

void
glMulticastBlitFramebufferNV(srcGpu, dstGpu, srcX0, srcY0, srcX1, srcY1, dstX0, dstY0, dstX1, dstY1, mask, filter)
  GLuint srcGpu;
  GLuint dstGpu;
  GLint srcX0;
  GLint srcY0;
  GLint srcX1;
  GLint srcY1;
  GLint dstX0;
  GLint dstY0;
  GLint dstX1;
  GLint dstY1;
  GLbitfield mask;
  GLenum filter;
CODE:
  OGLM_GLEWINIT
  OGLM_CHECK_ERR(glMulticastBlitFramebufferNV, )
  OGLM_AVAIL_CHECK(__glewMulticastBlitFramebufferNV, glMulticastBlitFramebufferNV)
  glMulticastBlitFramebufferNV(srcGpu, dstGpu, srcX0, srcY0, srcX1, srcY1, dstX0, dstY0, dstX1, dstY1, mask, filter);
  OGLM_CHECK_ERR(glMulticastBlitFramebufferNV, )

void
glMulticastBufferSubDataNV_c(gpuMask, buffer, offset, size, data)
  GLbitfield gpuMask;
  GLuint buffer;
  GLintptr offset;
  GLsizeiptr size;
  const void *data;
CODE:
  OGLM_GLEWINIT
  OGLM_CHECK_ERR(glMulticastBufferSubDataNV, )
  OGLM_AVAIL_CHECK(__glewMulticastBufferSubDataNV, glMulticastBufferSubDataNV)
  glMulticastBufferSubDataNV(gpuMask, buffer, offset, size, data);
  OGLM_CHECK_ERR(glMulticastBufferSubDataNV, )

void
glMulticastCopyBufferSubDataNV(readGpu, writeGpuMask, readBuffer, writeBuffer, readOffset, writeOffset, size)
  GLuint readGpu;
  GLbitfield writeGpuMask;
  GLuint readBuffer;
  GLuint writeBuffer;
  GLintptr readOffset;
  GLintptr writeOffset;
  GLsizeiptr size;
CODE:
  OGLM_GLEWINIT
  OGLM_CHECK_ERR(glMulticastCopyBufferSubDataNV, )
  OGLM_AVAIL_CHECK(__glewMulticastCopyBufferSubDataNV, glMulticastCopyBufferSubDataNV)
  glMulticastCopyBufferSubDataNV(readGpu, writeGpuMask, readBuffer, writeBuffer, readOffset, writeOffset, size);
  OGLM_CHECK_ERR(glMulticastCopyBufferSubDataNV, )

void
glMulticastCopyImageSubDataNV(srcGpu, dstGpuMask, srcName, srcTarget, srcLevel, srcX, srcY, srcZ, dstName, dstTarget, dstLevel, dstX, dstY, dstZ, srcWidth, srcHeight, srcDepth)
  GLuint srcGpu;
  GLbitfield dstGpuMask;
  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;
CODE:
  OGLM_GLEWINIT
  OGLM_CHECK_ERR(glMulticastCopyImageSubDataNV, )
  OGLM_AVAIL_CHECK(__glewMulticastCopyImageSubDataNV, glMulticastCopyImageSubDataNV)
  glMulticastCopyImageSubDataNV(srcGpu, dstGpuMask, srcName, srcTarget, srcLevel, srcX, srcY, srcZ, dstName, dstTarget, dstLevel, dstX, dstY, dstZ, srcWidth, srcHeight, srcDepth);
  OGLM_CHECK_ERR(glMulticastCopyImageSubDataNV, )

void
glMulticastFramebufferSampleLocationsfvNV_c(gpu, framebuffer, start, count, v)
  GLuint gpu;
  GLuint framebuffer;
  GLuint start;
  GLsizei count;
  const GLfloat* v;
CODE:
  OGLM_GLEWINIT
  OGLM_CHECK_ERR(glMulticastFramebufferSampleLocationsfvNV, )
  OGLM_AVAIL_CHECK(__glewMulticastFramebufferSampleLocationsfvNV, glMulticastFramebufferSampleLocationsfvNV)
  glMulticastFramebufferSampleLocationsfvNV(gpu, framebuffer, start, count, v);
  OGLM_CHECK_ERR(glMulticastFramebufferSampleLocationsfvNV, )

void
glMulticastGetQueryObjecti64vNV_c(gpu, id, pname, params)
  GLuint gpu;
  GLuint id;
  GLenum pname;
  GLint64* params;
CODE:
  OGLM_GLEWINIT
  OGLM_CHECK_ERR(glMulticastGetQueryObjecti64vNV, )
  OGLM_AVAIL_CHECK(__glewMulticastGetQueryObjecti64vNV, glMulticastGetQueryObjecti64vNV)
  glMulticastGetQueryObjecti64vNV(gpu, id, pname, params);
  OGLM_CHECK_ERR(glMulticastGetQueryObjecti64vNV, )

void
glMulticastGetQueryObjectivNV_c(gpu, id, pname, params)
  GLuint gpu;
  GLuint id;
  GLenum pname;
  GLint* params;
CODE:
  OGLM_GLEWINIT
  OGLM_CHECK_ERR(glMulticastGetQueryObjectivNV, )
  OGLM_AVAIL_CHECK(__glewMulticastGetQueryObjectivNV, glMulticastGetQueryObjectivNV)
  glMulticastGetQueryObjectivNV(gpu, id, pname, params);
  OGLM_CHECK_ERR(glMulticastGetQueryObjectivNV, )

void
glMulticastGetQueryObjectui64vNV_c(gpu, id, pname, params)
  GLuint gpu;
  GLuint id;
  GLenum pname;
  GLuint64* params;
CODE:
  OGLM_GLEWINIT
  OGLM_CHECK_ERR(glMulticastGetQueryObjectui64vNV, )
  OGLM_AVAIL_CHECK(__glewMulticastGetQueryObjectui64vNV, glMulticastGetQueryObjectui64vNV)
  glMulticastGetQueryObjectui64vNV(gpu, id, pname, params);
  OGLM_CHECK_ERR(glMulticastGetQueryObjectui64vNV, )

void
glMulticastGetQueryObjectuivNV_c(gpu, id, pname, params)
  GLuint gpu;
  GLuint id;
  GLenum pname;
  GLuint* params;
CODE:
  OGLM_GLEWINIT
  OGLM_CHECK_ERR(glMulticastGetQueryObjectuivNV, )
  OGLM_AVAIL_CHECK(__glewMulticastGetQueryObjectuivNV, glMulticastGetQueryObjectuivNV)
  glMulticastGetQueryObjectuivNV(gpu, id, pname, params);
  OGLM_CHECK_ERR(glMulticastGetQueryObjectuivNV, )

void
glMulticastScissorArrayvNVX_c(gpu, first, count, v)
  GLuint gpu;
  GLuint first;
  GLsizei count;
  const GLint* v;
CODE:
  OGLM_GLEWINIT
  OGLM_CHECK_ERR(glMulticastScissorArrayvNVX, )
  OGLM_AVAIL_CHECK(__glewMulticastScissorArrayvNVX, glMulticastScissorArrayvNVX)
  glMulticastScissorArrayvNVX(gpu, first, count, v);
  OGLM_CHECK_ERR(glMulticastScissorArrayvNVX, )

void
glMulticastScissorArrayvNVX_p(gpu, first, ...)
  GLuint gpu;
  GLuint first;
CODE:
  OGLM_GLEWINIT
  OGLM_CHECK_ERR(glMulticastScissorArrayvNVX, )
  OGLM_AVAIL_CHECK(__glewMulticastScissorArrayvNVX, glMulticastScissorArrayvNVX)
  GLsizei count = items-2;
  GLint* v = OGLM_GET_VARARGS(v,2,GLint,IV,count);
  glMulticastScissorArrayvNVX((GLuint )gpu, (GLuint )first, (GLsizei )count, (const GLint* )v);
  OGLM_CHECK_ERR(glMulticastScissorArrayvNVX, free(v);)
  free(v);

void
glMulticastViewportArrayvNVX_c(gpu, first, count, v)
  GLuint gpu;
  GLuint first;
  GLsizei count;
  const GLfloat* v;
CODE:
  OGLM_GLEWINIT
  OGLM_CHECK_ERR(glMulticastViewportArrayvNVX, )
  OGLM_AVAIL_CHECK(__glewMulticastViewportArrayvNVX, glMulticastViewportArrayvNVX)
  glMulticastViewportArrayvNVX(gpu, first, count, v);
  OGLM_CHECK_ERR(glMulticastViewportArrayvNVX, )

void
glMulticastViewportArrayvNVX_p(gpu, first, ...)
  GLuint gpu;
  GLuint first;
CODE:
  OGLM_GLEWINIT
  OGLM_CHECK_ERR(glMulticastViewportArrayvNVX, )
  OGLM_AVAIL_CHECK(__glewMulticastViewportArrayvNVX, glMulticastViewportArrayvNVX)
  GLsizei count = items-2;
  GLfloat* v = OGLM_GET_VARARGS(v,2,GLfloat,NV,count);
  glMulticastViewportArrayvNVX((GLuint )gpu, (GLuint )first, (GLsizei )count, (const GLfloat* )v);
  OGLM_CHECK_ERR(glMulticastViewportArrayvNVX, free(v);)
  free(v);

void
glMulticastViewportPositionWScaleNVX(gpu, index, xcoeff, ycoeff)
  GLuint gpu;
  GLuint index;
  GLfloat xcoeff;
  GLfloat ycoeff;
CODE:
  OGLM_GLEWINIT
  OGLM_CHECK_ERR(glMulticastViewportPositionWScaleNVX, )
  OGLM_AVAIL_CHECK(__glewMulticastViewportPositionWScaleNVX, glMulticastViewportPositionWScaleNVX)
  glMulticastViewportPositionWScaleNVX(gpu, index, xcoeff, ycoeff);
  OGLM_CHECK_ERR(glMulticastViewportPositionWScaleNVX, )

void
glMulticastWaitSyncNV(signalGpu, waitGpuMask)
  GLuint signalGpu;
  GLbitfield waitGpuMask;
CODE:
  OGLM_GLEWINIT
  OGLM_CHECK_ERR(glMulticastWaitSyncNV, )
  OGLM_AVAIL_CHECK(__glewMulticastWaitSyncNV, glMulticastWaitSyncNV)
  glMulticastWaitSyncNV(signalGpu, waitGpuMask);
  OGLM_CHECK_ERR(glMulticastWaitSyncNV, )

void
glMultisampleSubRectPosSGIS(x, y)
  GLint x;
  GLint y;
CODE:
  OGLM_GLEWINIT
  OGLM_CHECK_ERR(glMultisampleSubRectPosSGIS, )
  OGLM_AVAIL_CHECK(__glewMultisampleSubRectPosSGIS, glMultisampleSubRectPosSGIS)
  glMultisampleSubRectPosSGIS(x, y);
  OGLM_CHECK_ERR(glMultisampleSubRectPosSGIS, )

void
glNamedBufferAttachMemoryNV(buffer, memory, offset)
  GLuint buffer;
  GLuint memory;
  GLuint64 offset;
CODE:
  OGLM_GLEWINIT
  OGLM_CHECK_ERR(glNamedBufferAttachMemoryNV, )
  OGLM_AVAIL_CHECK(__glewNamedBufferAttachMemoryNV, glNamedBufferAttachMemoryNV)
  glNamedBufferAttachMemoryNV(buffer, memory, offset);
  OGLM_CHECK_ERR(glNamedBufferAttachMemoryNV, )

void
glNamedBufferData_c(buffer, size, data, usage)
  GLuint buffer;
  GLsizeiptr size;
  const void *data;
  GLenum usage;
CODE:
  OGLM_GLEWINIT
  OGLM_CHECK_ERR(glNamedBufferData, )
  OGLM_AVAIL_CHECK(__glewNamedBufferData, glNamedBufferData)
  glNamedBufferData(buffer, size, data, usage);
  OGLM_CHECK_ERR(glNamedBufferData, )

void
glNamedBufferDataEXT_c(buffer, size, data, usage)
  GLuint buffer;
  GLsizeiptr size;
  const void *data;
  GLenum usage;
CODE:
  OGLM_GLEWINIT
  OGLM_CHECK_ERR(glNamedBufferDataEXT, )
  OGLM_AVAIL_CHECK(__glewNamedBufferDataEXT, glNamedBufferDataEXT)
  glNamedBufferDataEXT(buffer, size, data, usage);
  OGLM_CHECK_ERR(glNamedBufferDataEXT, )

void
glNamedBufferPageCommitmentMemNV(buffer, offset, size, memory, memOffset, commit)
  GLuint buffer;
  GLintptr offset;
  GLsizeiptr size;
  GLuint memory;
  GLuint64 memOffset;
  GLboolean commit;
CODE:
  OGLM_GLEWINIT
  OGLM_CHECK_ERR(glNamedBufferPageCommitmentMemNV, )
  OGLM_AVAIL_CHECK(__glewNamedBufferPageCommitmentMemNV, glNamedBufferPageCommitmentMemNV)
  glNamedBufferPageCommitmentMemNV(buffer, offset, size, memory, memOffset, commit);
  OGLM_CHECK_ERR(glNamedBufferPageCommitmentMemNV, )

void
glNamedBufferStorage_c(buffer, size, data, flags)
  GLuint buffer;
  GLsizeiptr size;
  const void *data;
  GLbitfield flags;
ALIAS:
  glNamedBufferStorageEXT_c = 1
CODE:
  OGLM_GLEWINIT
  OGLM_CHECK_ERR(glNamedBufferStorage, )
  OGLM_AVAIL_CHECK(__glewNamedBufferStorage, glNamedBufferStorage)
  glNamedBufferStorage(buffer, size, data, flags);
  OGLM_CHECK_ERR(glNamedBufferStorage, )

void
glNamedBufferStorageExternalEXT(buffer, offset, size, clientBuffer, flags)
  GLuint buffer;
  GLintptr offset;
  GLsizeiptr size;
  GLeglClientBufferEXT clientBuffer;
  GLbitfield flags;
CODE:
  OGLM_GLEWINIT
  OGLM_CHECK_ERR(glNamedBufferStorageExternalEXT, )
  OGLM_AVAIL_CHECK(__glewNamedBufferStorageExternalEXT, glNamedBufferStorageExternalEXT)
  glNamedBufferStorageExternalEXT(buffer, offset, size, clientBuffer, flags);
  OGLM_CHECK_ERR(glNamedBufferStorageExternalEXT, )

void
glNamedBufferStorageMemEXT(buffer, size, memory, offset)
  GLuint buffer;
  GLsizeiptr size;
  GLuint memory;
  GLuint64 offset;
CODE:
  OGLM_GLEWINIT
  OGLM_CHECK_ERR(glNamedBufferStorageMemEXT, )
  OGLM_AVAIL_CHECK(__glewNamedBufferStorageMemEXT, glNamedBufferStorageMemEXT)
  glNamedBufferStorageMemEXT(buffer, size, memory, offset);
  OGLM_CHECK_ERR(glNamedBufferStorageMemEXT, )

void
glNamedBufferSubData_c(buffer, offset, size, data)
  GLuint buffer;
  GLintptr offset;
  GLsizeiptr size;
  const void *data;
ALIAS:
  glNamedBufferSubDataEXT_c = 1
CODE:
  OGLM_GLEWINIT
  OGLM_CHECK_ERR(glNamedBufferSubData, )
  OGLM_AVAIL_CHECK(__glewNamedBufferSubData, glNamedBufferSubData)
  glNamedBufferSubData(buffer, offset, size, data);
  OGLM_CHECK_ERR(glNamedBufferSubData, )

void
glNamedCopyBufferSubDataEXT(readBuffer, writeBuffer, readOffset, writeOffset, size)
  GLuint readBuffer;
  GLuint writeBuffer;
  GLintptr readOffset;
  GLintptr writeOffset;
  GLsizeiptr size;
CODE:
  OGLM_GLEWINIT
  OGLM_CHECK_ERR(glNamedCopyBufferSubDataEXT, )
  OGLM_AVAIL_CHECK(__glewNamedCopyBufferSubDataEXT, glNamedCopyBufferSubDataEXT)
  glNamedCopyBufferSubDataEXT(readBuffer, writeBuffer, readOffset, writeOffset, size);
  OGLM_CHECK_ERR(glNamedCopyBufferSubDataEXT, )

void
glNamedFramebufferDrawBuffer(framebuffer, buf)
  GLuint framebuffer;
  GLenum buf;
CODE:
  OGLM_GLEWINIT
  OGLM_CHECK_ERR(glNamedFramebufferDrawBuffer, )
  OGLM_AVAIL_CHECK(__glewNamedFramebufferDrawBuffer, glNamedFramebufferDrawBuffer)
  glNamedFramebufferDrawBuffer(framebuffer, buf);
  OGLM_CHECK_ERR(glNamedFramebufferDrawBuffer, )

void
glNamedFramebufferDrawBuffers_c(framebuffer, n, bufs)
  GLuint framebuffer;
  GLsizei n;
  const GLenum* bufs;
CODE:
  OGLM_GLEWINIT
  OGLM_CHECK_ERR(glNamedFramebufferDrawBuffers, )
  OGLM_AVAIL_CHECK(__glewNamedFramebufferDrawBuffers, glNamedFramebufferDrawBuffers)
  glNamedFramebufferDrawBuffers(framebuffer, n, bufs);
  OGLM_CHECK_ERR(glNamedFramebufferDrawBuffers, )

void
glNamedFramebufferDrawBuffers_p(framebuffer, ...)
  GLuint framebuffer;
CODE:
  OGLM_GLEWINIT
  OGLM_CHECK_ERR(glNamedFramebufferDrawBuffers, )
  OGLM_AVAIL_CHECK(__glewNamedFramebufferDrawBuffers, glNamedFramebufferDrawBuffers)
  GLsizei n = items-1;
  GLenum* bufs = OGLM_GET_VARARGS(bufs,1,GLenum,IV,n);
  glNamedFramebufferDrawBuffers((GLuint )framebuffer, (GLsizei )n, (const GLenum* )bufs);
  OGLM_CHECK_ERR(glNamedFramebufferDrawBuffers, free(bufs);)
  free(bufs);

void
glNamedFramebufferParameteri(framebuffer, pname, param)
  GLuint framebuffer;
  GLenum pname;
  GLint param;
CODE:
  OGLM_GLEWINIT
  OGLM_CHECK_ERR(glNamedFramebufferParameteri, )
  OGLM_AVAIL_CHECK(__glewNamedFramebufferParameteri, glNamedFramebufferParameteri)
  glNamedFramebufferParameteri(framebuffer, pname, param);
  OGLM_CHECK_ERR(glNamedFramebufferParameteri, )

void
glNamedFramebufferParameteriEXT(framebuffer, pname, param)
  GLuint framebuffer;
  GLenum pname;
  GLint param;
CODE:
  OGLM_GLEWINIT
  OGLM_CHECK_ERR(glNamedFramebufferParameteriEXT, )
  OGLM_AVAIL_CHECK(__glewNamedFramebufferParameteriEXT, glNamedFramebufferParameteriEXT)
  glNamedFramebufferParameteriEXT(framebuffer, pname, param);
  OGLM_CHECK_ERR(glNamedFramebufferParameteriEXT, )

void
glNamedFramebufferReadBuffer(framebuffer, src)
  GLuint framebuffer;
  GLenum src;
CODE:
  OGLM_GLEWINIT
  OGLM_CHECK_ERR(glNamedFramebufferReadBuffer, )
  OGLM_AVAIL_CHECK(__glewNamedFramebufferReadBuffer, glNamedFramebufferReadBuffer)
  glNamedFramebufferReadBuffer(framebuffer, src);
  OGLM_CHECK_ERR(glNamedFramebufferReadBuffer, )

void
glNamedFramebufferRenderbuffer(framebuffer, attachment, renderbuffertarget, renderbuffer)
  GLuint framebuffer;
  GLenum attachment;
  GLenum renderbuffertarget;
  GLuint renderbuffer;
CODE:
  OGLM_GLEWINIT
  OGLM_CHECK_ERR(glNamedFramebufferRenderbuffer, )
  OGLM_AVAIL_CHECK(__glewNamedFramebufferRenderbuffer, glNamedFramebufferRenderbuffer)
  glNamedFramebufferRenderbuffer(framebuffer, attachment, renderbuffertarget, renderbuffer);
  OGLM_CHECK_ERR(glNamedFramebufferRenderbuffer, )

void
glNamedFramebufferRenderbufferEXT(framebuffer, attachment, renderbuffertarget, renderbuffer)
  GLuint framebuffer;
  GLenum attachment;
  GLenum renderbuffertarget;
  GLuint renderbuffer;
CODE:
  OGLM_GLEWINIT
  OGLM_CHECK_ERR(glNamedFramebufferRenderbufferEXT, )
  OGLM_AVAIL_CHECK(__glewNamedFramebufferRenderbufferEXT, glNamedFramebufferRenderbufferEXT)
  glNamedFramebufferRenderbufferEXT(framebuffer, attachment, renderbuffertarget, renderbuffer);
  OGLM_CHECK_ERR(glNamedFramebufferRenderbufferEXT, )

void
glNamedFramebufferSampleLocationsfvARB_c(framebuffer, start, count, v)
  GLuint framebuffer;
  GLuint start;
  GLsizei count;
  const GLfloat* v;
CODE:
  OGLM_GLEWINIT
  OGLM_CHECK_ERR(glNamedFramebufferSampleLocationsfvARB, )
  OGLM_AVAIL_CHECK(__glewNamedFramebufferSampleLocationsfvARB, glNamedFramebufferSampleLocationsfvARB)
  glNamedFramebufferSampleLocationsfvARB(framebuffer, start, count, v);
  OGLM_CHECK_ERR(glNamedFramebufferSampleLocationsfvARB, )

void
glNamedFramebufferSampleLocationsfvNV_c(framebuffer, start, count, v)
  GLuint framebuffer;
  GLuint start;
  GLsizei count;
  const GLfloat* v;
CODE:
  OGLM_GLEWINIT
  OGLM_CHECK_ERR(glNamedFramebufferSampleLocationsfvNV, )
  OGLM_AVAIL_CHECK(__glewNamedFramebufferSampleLocationsfvNV, glNamedFramebufferSampleLocationsfvNV)
  glNamedFramebufferSampleLocationsfvNV(framebuffer, start, count, v);
  OGLM_CHECK_ERR(glNamedFramebufferSampleLocationsfvNV, )

void
glNamedFramebufferSamplePositionsfvAMD_c(framebuffer, numsamples, pixelindex, values)
  GLuint framebuffer;
  GLuint numsamples;
  GLuint pixelindex;
  const GLfloat* values;
CODE:
  OGLM_GLEWINIT
  OGLM_CHECK_ERR(glNamedFramebufferSamplePositionsfvAMD, )
  OGLM_AVAIL_CHECK(__glewNamedFramebufferSamplePositionsfvAMD, glNamedFramebufferSamplePositionsfvAMD)
  glNamedFramebufferSamplePositionsfvAMD(framebuffer, numsamples, pixelindex, values);
  OGLM_CHECK_ERR(glNamedFramebufferSamplePositionsfvAMD, )

void
glNamedFramebufferTexture(framebuffer, attachment, texture, level)
  GLuint framebuffer;
  GLenum attachment;
  GLuint texture;
  GLint level;
CODE:
  OGLM_GLEWINIT
  OGLM_CHECK_ERR(glNamedFramebufferTexture, )
  OGLM_AVAIL_CHECK(__glewNamedFramebufferTexture, glNamedFramebufferTexture)
  glNamedFramebufferTexture(framebuffer, attachment, texture, level);
  OGLM_CHECK_ERR(glNamedFramebufferTexture, )

void
glNamedFramebufferTexture1DEXT(framebuffer, attachment, textarget, texture, level)
  GLuint framebuffer;
  GLenum attachment;
  GLenum textarget;
  GLuint texture;
  GLint level;
CODE:
  OGLM_GLEWINIT
  OGLM_CHECK_ERR(glNamedFramebufferTexture1DEXT, )
  OGLM_AVAIL_CHECK(__glewNamedFramebufferTexture1DEXT, glNamedFramebufferTexture1DEXT)
  glNamedFramebufferTexture1DEXT(framebuffer, attachment, textarget, texture, level);
  OGLM_CHECK_ERR(glNamedFramebufferTexture1DEXT, )

void
glNamedFramebufferTexture2DEXT(framebuffer, attachment, textarget, texture, level)
  GLuint framebuffer;
  GLenum attachment;
  GLenum textarget;
  GLuint texture;
  GLint level;
CODE:
  OGLM_GLEWINIT
  OGLM_CHECK_ERR(glNamedFramebufferTexture2DEXT, )
  OGLM_AVAIL_CHECK(__glewNamedFramebufferTexture2DEXT, glNamedFramebufferTexture2DEXT)
  glNamedFramebufferTexture2DEXT(framebuffer, attachment, textarget, texture, level);
  OGLM_CHECK_ERR(glNamedFramebufferTexture2DEXT, )

void
glNamedFramebufferTexture3DEXT(framebuffer, attachment, textarget, texture, level, zoffset)
  GLuint framebuffer;
  GLenum attachment;
  GLenum textarget;
  GLuint texture;
  GLint level;
  GLint zoffset;
CODE:
  OGLM_GLEWINIT
  OGLM_CHECK_ERR(glNamedFramebufferTexture3DEXT, )
  OGLM_AVAIL_CHECK(__glewNamedFramebufferTexture3DEXT, glNamedFramebufferTexture3DEXT)
  glNamedFramebufferTexture3DEXT(framebuffer, attachment, textarget, texture, level, zoffset);
  OGLM_CHECK_ERR(glNamedFramebufferTexture3DEXT, )

void
glNamedFramebufferTextureEXT(framebuffer, attachment, texture, level)
  GLuint framebuffer;
  GLenum attachment;
  GLuint texture;
  GLint level;
CODE:
  OGLM_GLEWINIT
  OGLM_CHECK_ERR(glNamedFramebufferTextureEXT, )
  OGLM_AVAIL_CHECK(__glewNamedFramebufferTextureEXT, glNamedFramebufferTextureEXT)
  glNamedFramebufferTextureEXT(framebuffer, attachment, texture, level);
  OGLM_CHECK_ERR(glNamedFramebufferTextureEXT, )

void
glNamedFramebufferTextureFaceEXT(framebuffer, attachment, texture, level, face)
  GLuint framebuffer;
  GLenum attachment;
  GLuint texture;
  GLint level;
  GLenum face;
CODE:
  OGLM_GLEWINIT
  OGLM_CHECK_ERR(glNamedFramebufferTextureFaceEXT, )
  OGLM_AVAIL_CHECK(__glewNamedFramebufferTextureFaceEXT, glNamedFramebufferTextureFaceEXT)
  glNamedFramebufferTextureFaceEXT(framebuffer, attachment, texture, level, face);
  OGLM_CHECK_ERR(glNamedFramebufferTextureFaceEXT, )

void
glNamedFramebufferTextureLayer(framebuffer, attachment, texture, level, layer)
  GLuint framebuffer;
  GLenum attachment;
  GLuint texture;
  GLint level;
  GLint layer;
CODE:
  OGLM_GLEWINIT
  OGLM_CHECK_ERR(glNamedFramebufferTextureLayer, )
  OGLM_AVAIL_CHECK(__glewNamedFramebufferTextureLayer, glNamedFramebufferTextureLayer)
  glNamedFramebufferTextureLayer(framebuffer, attachment, texture, level, layer);
  OGLM_CHECK_ERR(glNamedFramebufferTextureLayer, )

void
glNamedFramebufferTextureLayerEXT(framebuffer, attachment, texture, level, layer)
  GLuint framebuffer;
  GLenum attachment;
  GLuint texture;
  GLint level;
  GLint layer;
CODE:
  OGLM_GLEWINIT
  OGLM_CHECK_ERR(glNamedFramebufferTextureLayerEXT, )
  OGLM_AVAIL_CHECK(__glewNamedFramebufferTextureLayerEXT, glNamedFramebufferTextureLayerEXT)
  glNamedFramebufferTextureLayerEXT(framebuffer, attachment, texture, level, layer);
  OGLM_CHECK_ERR(glNamedFramebufferTextureLayerEXT, )

void
glNamedFramebufferTextureMultiviewOVR(framebuffer, attachment, texture, level, baseViewIndex, numViews)
  GLuint framebuffer;
  GLenum attachment;
  GLuint texture;
  GLint level;
  GLint baseViewIndex;
  GLsizei numViews;
CODE:
  OGLM_GLEWINIT
  OGLM_CHECK_ERR(glNamedFramebufferTextureMultiviewOVR, )
  OGLM_AVAIL_CHECK(__glewNamedFramebufferTextureMultiviewOVR, glNamedFramebufferTextureMultiviewOVR)
  glNamedFramebufferTextureMultiviewOVR(framebuffer, attachment, texture, level, baseViewIndex, numViews);
  OGLM_CHECK_ERR(glNamedFramebufferTextureMultiviewOVR, )

void
glNamedProgramLocalParameter4dEXT(program, target, index, x, y, z, w)
  GLuint program;
  GLenum target;
  GLuint index;
  GLdouble x;
  GLdouble y;
  GLdouble z;
  GLdouble w;
CODE:
  OGLM_GLEWINIT
  OGLM_CHECK_ERR(glNamedProgramLocalParameter4dEXT, )
  OGLM_AVAIL_CHECK(__glewNamedProgramLocalParameter4dEXT, glNamedProgramLocalParameter4dEXT)
  glNamedProgramLocalParameter4dEXT(program, target, index, x, y, z, w);
  OGLM_CHECK_ERR(glNamedProgramLocalParameter4dEXT, )

void
glNamedProgramLocalParameter4dvEXT_c(program, target, index, params)
  GLuint program;
  GLenum target;
  GLuint index;
  const GLdouble* params;
CODE:
  OGLM_GLEWINIT
  OGLM_CHECK_ERR(glNamedProgramLocalParameter4dvEXT, )
  OGLM_AVAIL_CHECK(__glewNamedProgramLocalParameter4dvEXT, glNamedProgramLocalParameter4dvEXT)
  glNamedProgramLocalParameter4dvEXT(program, target, index, params);
  OGLM_CHECK_ERR(glNamedProgramLocalParameter4dvEXT, )

void
glNamedProgramLocalParameter4dvEXT_p(program, target, index, ...)
  GLuint program;
  GLenum target;
  GLuint index;
CODE:
  OGLM_GLEWINIT
  OGLM_CHECK_ERR(glNamedProgramLocalParameter4dvEXT, )
  OGLM_AVAIL_CHECK(__glewNamedProgramLocalParameter4dvEXT, glNamedProgramLocalParameter4dvEXT)
  GLdouble* params = OGLM_GET_VARARGS(params,3,GLdouble,NV,4);
  glNamedProgramLocalParameter4dvEXT((GLuint )program, (GLenum )target, (GLuint )index, (const GLdouble* )params);
  OGLM_CHECK_ERR(glNamedProgramLocalParameter4dvEXT, free(params);)
  free(params);

void
glNamedProgramLocalParameter4fEXT(program, target, index, x, y, z, w)
  GLuint program;
  GLenum target;
  GLuint index;
  GLfloat x;
  GLfloat y;
  GLfloat z;
  GLfloat w;
CODE:
  OGLM_GLEWINIT
  OGLM_CHECK_ERR(glNamedProgramLocalParameter4fEXT, )
  OGLM_AVAIL_CHECK(__glewNamedProgramLocalParameter4fEXT, glNamedProgramLocalParameter4fEXT)
  glNamedProgramLocalParameter4fEXT(program, target, index, x, y, z, w);
  OGLM_CHECK_ERR(glNamedProgramLocalParameter4fEXT, )

void
glNamedProgramLocalParameter4fvEXT_c(program, target, index, params)
  GLuint program;
  GLenum target;
  GLuint index;
  const GLfloat* params;
CODE:
  OGLM_GLEWINIT
  OGLM_CHECK_ERR(glNamedProgramLocalParameter4fvEXT, )
  OGLM_AVAIL_CHECK(__glewNamedProgramLocalParameter4fvEXT, glNamedProgramLocalParameter4fvEXT)
  glNamedProgramLocalParameter4fvEXT(program, target, index, params);
  OGLM_CHECK_ERR(glNamedProgramLocalParameter4fvEXT, )

void
glNamedProgramLocalParameter4fvEXT_p(program, target, index, ...)
  GLuint program;
  GLenum target;
  GLuint index;
CODE:
  OGLM_GLEWINIT
  OGLM_CHECK_ERR(glNamedProgramLocalParameter4fvEXT, )
  OGLM_AVAIL_CHECK(__glewNamedProgramLocalParameter4fvEXT, glNamedProgramLocalParameter4fvEXT)
  GLfloat* params = OGLM_GET_VARARGS(params,3,GLfloat,NV,4);
  glNamedProgramLocalParameter4fvEXT((GLuint )program, (GLenum )target, (GLuint )index, (const GLfloat* )params);
  OGLM_CHECK_ERR(glNamedProgramLocalParameter4fvEXT, free(params);)
  free(params);

void
glNamedProgramLocalParameterI4iEXT(program, target, index, x, y, z, w)
  GLuint program;
  GLenum target;
  GLuint index;
  GLint x;
  GLint y;
  GLint z;
  GLint w;
CODE:
  OGLM_GLEWINIT
  OGLM_CHECK_ERR(glNamedProgramLocalParameterI4iEXT, )
  OGLM_AVAIL_CHECK(__glewNamedProgramLocalParameterI4iEXT, glNamedProgramLocalParameterI4iEXT)
  glNamedProgramLocalParameterI4iEXT(program, target, index, x, y, z, w);
  OGLM_CHECK_ERR(glNamedProgramLocalParameterI4iEXT, )

void
glNamedProgramLocalParameterI4ivEXT_c(program, target, index, params)
  GLuint program;
  GLenum target;
  GLuint index;
  const GLint* params;
CODE:
  OGLM_GLEWINIT
  OGLM_CHECK_ERR(glNamedProgramLocalParameterI4ivEXT, )
  OGLM_AVAIL_CHECK(__glewNamedProgramLocalParameterI4ivEXT, glNamedProgramLocalParameterI4ivEXT)
  glNamedProgramLocalParameterI4ivEXT(program, target, index, params);
  OGLM_CHECK_ERR(glNamedProgramLocalParameterI4ivEXT, )

void
glNamedProgramLocalParameterI4ivEXT_p(program, target, index, ...)
  GLuint program;
  GLenum target;
  GLuint index;
CODE:
  OGLM_GLEWINIT
  OGLM_CHECK_ERR(glNamedProgramLocalParameterI4ivEXT, )
  OGLM_AVAIL_CHECK(__glewNamedProgramLocalParameterI4ivEXT, glNamedProgramLocalParameterI4ivEXT)
  GLint* params = OGLM_GET_VARARGS(params,3,GLint,IV,4);
  glNamedProgramLocalParameterI4ivEXT((GLuint )program, (GLenum )target, (GLuint )index, (const GLint* )params);
  OGLM_CHECK_ERR(glNamedProgramLocalParameterI4ivEXT, free(params);)
  free(params);

void
glNamedProgramLocalParameterI4uiEXT(program, target, index, x, y, z, w)
  GLuint program;
  GLenum target;
  GLuint index;
  GLuint x;
  GLuint y;
  GLuint z;
  GLuint w;
CODE:
  OGLM_GLEWINIT
  OGLM_CHECK_ERR(glNamedProgramLocalParameterI4uiEXT, )
  OGLM_AVAIL_CHECK(__glewNamedProgramLocalParameterI4uiEXT, glNamedProgramLocalParameterI4uiEXT)
  glNamedProgramLocalParameterI4uiEXT(program, target, index, x, y, z, w);
  OGLM_CHECK_ERR(glNamedProgramLocalParameterI4uiEXT, )

void
glNamedProgramLocalParameterI4uivEXT_c(program, target, index, params)
  GLuint program;
  GLenum target;
  GLuint index;
  const GLuint* params;
CODE:
  OGLM_GLEWINIT
  OGLM_CHECK_ERR(glNamedProgramLocalParameterI4uivEXT, )
  OGLM_AVAIL_CHECK(__glewNamedProgramLocalParameterI4uivEXT, glNamedProgramLocalParameterI4uivEXT)
  glNamedProgramLocalParameterI4uivEXT(program, target, index, params);
  OGLM_CHECK_ERR(glNamedProgramLocalParameterI4uivEXT, )

void
glNamedProgramLocalParameterI4uivEXT_p(program, target, index, ...)
  GLuint program;
  GLenum target;
  GLuint index;
CODE:
  OGLM_GLEWINIT
  OGLM_CHECK_ERR(glNamedProgramLocalParameterI4uivEXT, )
  OGLM_AVAIL_CHECK(__glewNamedProgramLocalParameterI4uivEXT, glNamedProgramLocalParameterI4uivEXT)
  GLuint* params = OGLM_GET_VARARGS(params,3,GLuint,UV,4);
  glNamedProgramLocalParameterI4uivEXT((GLuint )program, (GLenum )target, (GLuint )index, (const GLuint* )params);
  OGLM_CHECK_ERR(glNamedProgramLocalParameterI4uivEXT, free(params);)
  free(params);

void
glNamedProgramLocalParameters4fvEXT_c(program, target, index, count, params)
  GLuint program;
  GLenum target;
  GLuint index;
  GLsizei count;
  const GLfloat* params;
CODE:
  OGLM_GLEWINIT
  OGLM_CHECK_ERR(glNamedProgramLocalParameters4fvEXT, )
  OGLM_AVAIL_CHECK(__glewNamedProgramLocalParameters4fvEXT, glNamedProgramLocalParameters4fvEXT)
  glNamedProgramLocalParameters4fvEXT(program, target, index, count, params);
  OGLM_CHECK_ERR(glNamedProgramLocalParameters4fvEXT, )

void
glNamedProgramLocalParameters4fvEXT_p(program, target, index, count, ...)
  GLuint program;
  GLenum target;
  GLuint index;
  GLsizei count;
CODE:
  OGLM_GLEWINIT
  OGLM_CHECK_ERR(glNamedProgramLocalParameters4fvEXT, )
  OGLM_AVAIL_CHECK(__glewNamedProgramLocalParameters4fvEXT, glNamedProgramLocalParameters4fvEXT)
  GLfloat* params = OGLM_GET_VARARGS(params,4,GLfloat,NV,count*4);
  glNamedProgramLocalParameters4fvEXT((GLuint )program, (GLenum )target, (GLuint )index, (GLsizei )count, (const GLfloat* )params);
  OGLM_CHECK_ERR(glNamedProgramLocalParameters4fvEXT, free(params);)
  free(params);

void
glNamedProgramLocalParametersI4ivEXT_c(program, target, index, count, params)
  GLuint program;
  GLenum target;
  GLuint index;
  GLsizei count;
  const GLint* params;
CODE:
  OGLM_GLEWINIT
  OGLM_CHECK_ERR(glNamedProgramLocalParametersI4ivEXT, )
  OGLM_AVAIL_CHECK(__glewNamedProgramLocalParametersI4ivEXT, glNamedProgramLocalParametersI4ivEXT)
  glNamedProgramLocalParametersI4ivEXT(program, target, index, count, params);
  OGLM_CHECK_ERR(glNamedProgramLocalParametersI4ivEXT, )

void
glNamedProgramLocalParametersI4ivEXT_p(program, target, index, count, ...)
  GLuint program;
  GLenum target;
  GLuint index;
  GLsizei count;
CODE:
  OGLM_GLEWINIT
  OGLM_CHECK_ERR(glNamedProgramLocalParametersI4ivEXT, )
  OGLM_AVAIL_CHECK(__glewNamedProgramLocalParametersI4ivEXT, glNamedProgramLocalParametersI4ivEXT)
  GLint* params = OGLM_GET_VARARGS(params,4,GLint,IV,count*4);
  glNamedProgramLocalParametersI4ivEXT((GLuint )program, (GLenum )target, (GLuint )index, (GLsizei )count, (const GLint* )params);
  OGLM_CHECK_ERR(glNamedProgramLocalParametersI4ivEXT, free(params);)
  free(params);

void
glNamedProgramLocalParametersI4uivEXT_c(program, target, index, count, params)
  GLuint program;
  GLenum target;
  GLuint index;
  GLsizei count;
  const GLuint* params;
CODE:
  OGLM_GLEWINIT
  OGLM_CHECK_ERR(glNamedProgramLocalParametersI4uivEXT, )
  OGLM_AVAIL_CHECK(__glewNamedProgramLocalParametersI4uivEXT, glNamedProgramLocalParametersI4uivEXT)
  glNamedProgramLocalParametersI4uivEXT(program, target, index, count, params);
  OGLM_CHECK_ERR(glNamedProgramLocalParametersI4uivEXT, )

void
glNamedProgramLocalParametersI4uivEXT_p(program, target, index, count, ...)
  GLuint program;
  GLenum target;
  GLuint index;
  GLsizei count;
CODE:
  OGLM_GLEWINIT
  OGLM_CHECK_ERR(glNamedProgramLocalParametersI4uivEXT, )
  OGLM_AVAIL_CHECK(__glewNamedProgramLocalParametersI4uivEXT, glNamedProgramLocalParametersI4uivEXT)
  GLuint* params = OGLM_GET_VARARGS(params,4,GLuint,UV,count*4);
  glNamedProgramLocalParametersI4uivEXT((GLuint )program, (GLenum )target, (GLuint )index, (GLsizei )count, (const GLuint* )params);
  OGLM_CHECK_ERR(glNamedProgramLocalParametersI4uivEXT, free(params);)
  free(params);

void
glNamedProgramStringEXT_c(program, target, format, len, string)
  GLuint program;
  GLenum target;
  GLenum format;
  GLsizei len;
  const void *string;
CODE:
  OGLM_GLEWINIT
  OGLM_CHECK_ERR(glNamedProgramStringEXT, )
  OGLM_AVAIL_CHECK(__glewNamedProgramStringEXT, glNamedProgramStringEXT)
  glNamedProgramStringEXT(program, target, format, len, string);
  OGLM_CHECK_ERR(glNamedProgramStringEXT, )

void
glNamedRenderbufferStorage(renderbuffer, internalformat, width, height)
  GLuint renderbuffer;
  GLenum internalformat;
  GLsizei width;
  GLsizei height;
CODE:
  OGLM_GLEWINIT
  OGLM_CHECK_ERR(glNamedRenderbufferStorage, )
  OGLM_AVAIL_CHECK(__glewNamedRenderbufferStorage, glNamedRenderbufferStorage)
  glNamedRenderbufferStorage(renderbuffer, internalformat, width, height);
  OGLM_CHECK_ERR(glNamedRenderbufferStorage, )

void
glNamedRenderbufferStorageEXT(renderbuffer, internalformat, width, height)
  GLuint renderbuffer;
  GLenum internalformat;
  GLsizei width;
  GLsizei height;
CODE:
  OGLM_GLEWINIT
  OGLM_CHECK_ERR(glNamedRenderbufferStorageEXT, )
  OGLM_AVAIL_CHECK(__glewNamedRenderbufferStorageEXT, glNamedRenderbufferStorageEXT)
  glNamedRenderbufferStorageEXT(renderbuffer, internalformat, width, height);
  OGLM_CHECK_ERR(glNamedRenderbufferStorageEXT, )

void
glNamedRenderbufferStorageMultisample(renderbuffer, samples, internalformat, width, height)
  GLuint renderbuffer;
  GLsizei samples;
  GLenum internalformat;
  GLsizei width;
  GLsizei height;
CODE:
  OGLM_GLEWINIT
  OGLM_CHECK_ERR(glNamedRenderbufferStorageMultisample, )
  OGLM_AVAIL_CHECK(__glewNamedRenderbufferStorageMultisample, glNamedRenderbufferStorageMultisample)
  glNamedRenderbufferStorageMultisample(renderbuffer, samples, internalformat, width, height);
  OGLM_CHECK_ERR(glNamedRenderbufferStorageMultisample, )

void
glNamedRenderbufferStorageMultisampleAdvancedAMD(renderbuffer, samples, storageSamples, internalformat, width, height)
  GLuint renderbuffer;
  GLsizei samples;
  GLsizei storageSamples;
  GLenum internalformat;
  GLsizei width;
  GLsizei height;
CODE:
  OGLM_GLEWINIT
  OGLM_CHECK_ERR(glNamedRenderbufferStorageMultisampleAdvancedAMD, )
  OGLM_AVAIL_CHECK(__glewNamedRenderbufferStorageMultisampleAdvancedAMD, glNamedRenderbufferStorageMultisampleAdvancedAMD)
  glNamedRenderbufferStorageMultisampleAdvancedAMD(renderbuffer, samples, storageSamples, internalformat, width, height);
  OGLM_CHECK_ERR(glNamedRenderbufferStorageMultisampleAdvancedAMD, )

void
glNamedRenderbufferStorageMultisampleCoverageEXT(renderbuffer, coverageSamples, colorSamples, internalformat, width, height)
  GLuint renderbuffer;
  GLsizei coverageSamples;
  GLsizei colorSamples;
  GLenum internalformat;
  GLsizei width;
  GLsizei height;
CODE:
  OGLM_GLEWINIT
  OGLM_CHECK_ERR(glNamedRenderbufferStorageMultisampleCoverageEXT, )
  OGLM_AVAIL_CHECK(__glewNamedRenderbufferStorageMultisampleCoverageEXT, glNamedRenderbufferStorageMultisampleCoverageEXT)
  glNamedRenderbufferStorageMultisampleCoverageEXT(renderbuffer, coverageSamples, colorSamples, internalformat, width, height);
  OGLM_CHECK_ERR(glNamedRenderbufferStorageMultisampleCoverageEXT, )

void
glNamedRenderbufferStorageMultisampleEXT(renderbuffer, samples, internalformat, width, height)
  GLuint renderbuffer;
  GLsizei samples;
  GLenum internalformat;
  GLsizei width;
  GLsizei height;
CODE:
  OGLM_GLEWINIT
  OGLM_CHECK_ERR(glNamedRenderbufferStorageMultisampleEXT, )
  OGLM_AVAIL_CHECK(__glewNamedRenderbufferStorageMultisampleEXT, glNamedRenderbufferStorageMultisampleEXT)
  glNamedRenderbufferStorageMultisampleEXT(renderbuffer, samples, internalformat, width, height);
  OGLM_CHECK_ERR(glNamedRenderbufferStorageMultisampleEXT, )

void
glNamedStringARB(type, namelen, name, stringlen, string)
  GLenum type;
  GLint namelen;
  const GLchar* name;
  GLint stringlen;
  const GLchar *string;
CODE:
  OGLM_GLEWINIT
  OGLM_CHECK_ERR(glNamedStringARB, )
  OGLM_AVAIL_CHECK(__glewNamedStringARB, glNamedStringARB)
  glNamedStringARB(type, namelen, name, stringlen, string);
  OGLM_CHECK_ERR(glNamedStringARB, )

GLuint
glNewBufferRegion(region)
  GLenum region;
CODE:
  OGLM_GLEWINIT
  OGLM_CHECK_ERR(glNewBufferRegion, )
  OGLM_AVAIL_CHECK(__glewNewBufferRegion, glNewBufferRegion)
  RETVAL = glNewBufferRegion(region);
  OGLM_CHECK_ERR(glNewBufferRegion, )
OUTPUT:
  RETVAL

void
glNewList(list, mode)
  GLuint list;
  GLenum mode;
CODE:
  OGLM_GLEWINIT
  OGLM_CHECK_ERR(glNewList, )
  glNewList(list, mode);
  OGLM_CHECK_ERR(glNewList, )

GLuint
glNewObjectBufferATI_c(size, pointer, usage)
  GLsizei size;
  const void *pointer;
  GLenum usage;
CODE:
  OGLM_GLEWINIT
  OGLM_CHECK_ERR(glNewObjectBufferATI, )
  OGLM_AVAIL_CHECK(__glewNewObjectBufferATI, glNewObjectBufferATI)
  RETVAL = glNewObjectBufferATI(size, pointer, usage);
  OGLM_CHECK_ERR(glNewObjectBufferATI, )
OUTPUT:
  RETVAL

void
glNonlinLightfvSGIX_c(light, pname, terms, params)
  GLenum light;
  GLenum pname;
  GLint terms;
  GLfloat* params;
CODE:
  OGLM_GLEWINIT
  OGLM_CHECK_ERR(glNonlinLightfvSGIX, )
  OGLM_AVAIL_CHECK(__glewNonlinLightfvSGIX, glNonlinLightfvSGIX)
  glNonlinLightfvSGIX(light, pname, terms, params);
  OGLM_CHECK_ERR(glNonlinLightfvSGIX, )

void
glNonlinMaterialfvSGIX_c(face, pname, terms, params)
  GLenum face;
  GLenum pname;
  GLint terms;
  const GLfloat* params;
CODE:
  OGLM_GLEWINIT
  OGLM_CHECK_ERR(glNonlinMaterialfvSGIX, )
  OGLM_AVAIL_CHECK(__glewNonlinMaterialfvSGIX, glNonlinMaterialfvSGIX)
  glNonlinMaterialfvSGIX(face, pname, terms, params);
  OGLM_CHECK_ERR(glNonlinMaterialfvSGIX, )

void
glNormal3b(nx, ny, nz)
  GLbyte nx;
  GLbyte ny;
  GLbyte nz;
CODE:
  OGLM_GLEWINIT
  OGLM_CHECK_ERR(glNormal3b, )
  glNormal3b(nx, ny, nz);
  OGLM_CHECK_ERR(glNormal3b, )

void
glNormal3bv_c(v)
  const GLbyte *v;
CODE:
  OGLM_GLEWINIT
  OGLM_CHECK_ERR(glNormal3bv, )
  glNormal3bv(v);
  OGLM_CHECK_ERR(glNormal3bv, )

void
glNormal3bv_p(...)
CODE:
  OGLM_GLEWINIT
  OGLM_CHECK_ERR(glNormal3bv, )
  GLbyte *v = OGLM_GET_VARARGS(v,0,GLbyte,IV,3);
  glNormal3bv((const GLbyte *)v);
  OGLM_CHECK_ERR(glNormal3bv, free(v);)
  free(v);

void
glNormal3d(nx, ny, nz)
  GLdouble nx;
  GLdouble ny;
  GLdouble nz;
CODE:
  OGLM_GLEWINIT
  OGLM_CHECK_ERR(glNormal3d, )
  glNormal3d(nx, ny, nz);
  OGLM_CHECK_ERR(glNormal3d, )

void
glNormal3dv_c(v)
  const GLdouble *v;
CODE:
  OGLM_GLEWINIT
  OGLM_CHECK_ERR(glNormal3dv, )
  glNormal3dv(v);
  OGLM_CHECK_ERR(glNormal3dv, )

void
glNormal3dv_p(...)
CODE:
  OGLM_GLEWINIT
  OGLM_CHECK_ERR(glNormal3dv, )
  GLdouble *v = OGLM_GET_VARARGS(v,0,GLdouble,NV,3);
  glNormal3dv((const GLdouble *)v);
  OGLM_CHECK_ERR(glNormal3dv, free(v);)
  free(v);

void
glNormal3f(nx, ny, nz)
  GLfloat nx;
  GLfloat ny;
  GLfloat nz;
CODE:
  OGLM_GLEWINIT
  OGLM_CHECK_ERR(glNormal3f, )
  glNormal3f(nx, ny, nz);
  OGLM_CHECK_ERR(glNormal3f, )

void
glNormal3fVertex3fSUN(nx, ny, nz, x, y, z)
  GLfloat nx;
  GLfloat ny;
  GLfloat nz;
  GLfloat x;
  GLfloat y;
  GLfloat z;
CODE:
  OGLM_GLEWINIT
  OGLM_CHECK_ERR(glNormal3fVertex3fSUN, )
  OGLM_AVAIL_CHECK(__glewNormal3fVertex3fSUN, glNormal3fVertex3fSUN)
  glNormal3fVertex3fSUN(nx, ny, nz, x, y, z);
  OGLM_CHECK_ERR(glNormal3fVertex3fSUN, )

void
glNormal3fVertex3fvSUN_c(n, v)
  const GLfloat* n;
  const GLfloat *v;
CODE:
  OGLM_GLEWINIT
  OGLM_CHECK_ERR(glNormal3fVertex3fvSUN, )
  OGLM_AVAIL_CHECK(__glewNormal3fVertex3fvSUN, glNormal3fVertex3fvSUN)
  glNormal3fVertex3fvSUN(n, v);
  OGLM_CHECK_ERR(glNormal3fVertex3fvSUN, )

void
glNormal3fVertex3fvSUN_p(nSV, vSV)
  SV *nSV;
  SV *vSV;
CODE:
  OGLM_GLEWINIT
  OGLM_CHECK_ERR(glNormal3fVertex3fvSUN, )
  OGLM_AVAIL_CHECK(__glewNormal3fVertex3fvSUN, glNormal3fVertex3fvSUN)
  GLfloat* n = OGLM_GET_ARRAY(n, GLfloat, NV, 3);
  GLfloat *v = OGLM_GET_ARRAY(v, GLfloat, NV, 3);
  glNormal3fVertex3fvSUN((const GLfloat* )n, (const GLfloat *)v);
  OGLM_CHECK_ERR(glNormal3fVertex3fvSUN, free(n);free(v);)
  free(n);free(v);

void
glNormal3fv_c(v)
  const GLfloat *v;
CODE:
  OGLM_GLEWINIT
  OGLM_CHECK_ERR(glNormal3fv, )
  glNormal3fv(v);
  OGLM_CHECK_ERR(glNormal3fv, )

void
glNormal3fv_p(...)
CODE:
  OGLM_GLEWINIT
  OGLM_CHECK_ERR(glNormal3fv, )
  GLfloat *v = OGLM_GET_VARARGS(v,0,GLfloat,NV,3);
  glNormal3fv((const GLfloat *)v);
  OGLM_CHECK_ERR(glNormal3fv, free(v);)
  free(v);

void
glNormal3hNV(nx, ny, nz)
  GLhalf nx;
  GLhalf ny;
  GLhalf nz;
CODE:
  OGLM_GLEWINIT
  OGLM_CHECK_ERR(glNormal3hNV, )
  OGLM_AVAIL_CHECK(__glewNormal3hNV, glNormal3hNV)
  glNormal3hNV(nx, ny, nz);
  OGLM_CHECK_ERR(glNormal3hNV, )

void
glNormal3hvNV_c(v)
  const GLhalf* v;
CODE:
  OGLM_GLEWINIT
  OGLM_CHECK_ERR(glNormal3hvNV, )
  OGLM_AVAIL_CHECK(__glewNormal3hvNV, glNormal3hvNV)
  glNormal3hvNV(v);
  OGLM_CHECK_ERR(glNormal3hvNV, )

void
glNormal3hvNV_p(...)
CODE:
  OGLM_GLEWINIT
  OGLM_CHECK_ERR(glNormal3hvNV, )
  OGLM_AVAIL_CHECK(__glewNormal3hvNV, glNormal3hvNV)
  GLhalf* v = OGLM_GET_VARARGS(v,0,GLhalf,NV,3);
  glNormal3hvNV((const GLhalf* )v);
  OGLM_CHECK_ERR(glNormal3hvNV, free(v);)
  free(v);

void
glNormal3i(nx, ny, nz)
  GLint nx;
  GLint ny;
  GLint nz;
CODE:
  OGLM_GLEWINIT
  OGLM_CHECK_ERR(glNormal3i, )
  glNormal3i(nx, ny, nz);
  OGLM_CHECK_ERR(glNormal3i, )

void
glNormal3iv_c(v)
  const GLint *v;
CODE:
  OGLM_GLEWINIT
  OGLM_CHECK_ERR(glNormal3iv, )
  glNormal3iv(v);
  OGLM_CHECK_ERR(glNormal3iv, )

void
glNormal3iv_p(...)
CODE:
  OGLM_GLEWINIT
  OGLM_CHECK_ERR(glNormal3iv, )
  GLint *v = OGLM_GET_VARARGS(v,0,GLint,IV,3);
  glNormal3iv((const GLint *)v);
  OGLM_CHECK_ERR(glNormal3iv, free(v);)
  free(v);

void
glNormal3s(nx, ny, nz)
  GLshort nx;
  GLshort ny;
  GLshort nz;
CODE:
  OGLM_GLEWINIT
  OGLM_CHECK_ERR(glNormal3s, )
  glNormal3s(nx, ny, nz);
  OGLM_CHECK_ERR(glNormal3s, )

void
glNormal3sv_c(v)
  const GLshort *v;
CODE:
  OGLM_GLEWINIT
  OGLM_CHECK_ERR(glNormal3sv, )
  glNormal3sv(v);
  OGLM_CHECK_ERR(glNormal3sv, )

void
glNormal3sv_p(...)
CODE:
  OGLM_GLEWINIT
  OGLM_CHECK_ERR(glNormal3sv, )
  GLshort *v = OGLM_GET_VARARGS(v,0,GLshort,IV,3);
  glNormal3sv((const GLshort *)v);
  OGLM_CHECK_ERR(glNormal3sv, free(v);)
  free(v);

void
glNormal3x(nx, ny, nz)
  GLfixed nx;
  GLfixed ny;
  GLfixed nz;
CODE:
  OGLM_GLEWINIT
  OGLM_CHECK_ERR(glNormal3x, )
  OGLM_AVAIL_CHECK(__glewNormal3x, glNormal3x)
  glNormal3x(nx, ny, nz);
  OGLM_CHECK_ERR(glNormal3x, )

void
glNormalFormatNV(type, stride)
  GLenum type;
  GLsizei stride;
CODE:
  OGLM_GLEWINIT
  OGLM_CHECK_ERR(glNormalFormatNV, )
  OGLM_AVAIL_CHECK(__glewNormalFormatNV, glNormalFormatNV)
  glNormalFormatNV(type, stride);
  OGLM_CHECK_ERR(glNormalFormatNV, )

void
glNormalP3ui(type, coords)
  GLenum type;
  GLuint coords;
CODE:
  OGLM_GLEWINIT
  OGLM_CHECK_ERR(glNormalP3ui, )
  OGLM_AVAIL_CHECK(__glewNormalP3ui, glNormalP3ui)
  glNormalP3ui(type, coords);
  OGLM_CHECK_ERR(glNormalP3ui, )

void
glNormalP3uiv_c(type, coords)
  GLenum type;
  const GLuint* coords;
CODE:
  OGLM_GLEWINIT
  OGLM_CHECK_ERR(glNormalP3uiv, )
  OGLM_AVAIL_CHECK(__glewNormalP3uiv, glNormalP3uiv)
  glNormalP3uiv(type, coords);
  OGLM_CHECK_ERR(glNormalP3uiv, )

void
glNormalP3uiv_p(type, ...)
  GLenum type;
CODE:
  OGLM_GLEWINIT
  OGLM_CHECK_ERR(glNormalP3uiv, )
  OGLM_AVAIL_CHECK(__glewNormalP3uiv, glNormalP3uiv)
  GLuint* coords = OGLM_GET_VARARGS(coords,1,GLuint,UV,1);
  glNormalP3uiv((GLenum )type, (const GLuint* )coords);
  OGLM_CHECK_ERR(glNormalP3uiv, free(coords);)
  free(coords);

void
glNormalPointer_c(type, stride, pointer)
  GLenum type;
  GLsizei stride;
  const void *pointer;
CODE:
  OGLM_GLEWINIT
  OGLM_CHECK_ERR(glNormalPointer, )
  glNormalPointer(type, stride, pointer);
  OGLM_CHECK_ERR(glNormalPointer, )

void
glNormalPointerEXT_c(type, stride, count, pointer)
  GLenum type;
  GLsizei stride;
  GLsizei count;
  const void *pointer;
CODE:
  OGLM_GLEWINIT
  OGLM_CHECK_ERR(glNormalPointerEXT, )
  OGLM_AVAIL_CHECK(__glewNormalPointerEXT, glNormalPointerEXT)
  glNormalPointerEXT(type, stride, count, pointer);
  OGLM_CHECK_ERR(glNormalPointerEXT, )

void
glNormalPointerListIBM_c(type, stride, pointer, ptrstride)
  GLenum type;
  GLint stride;
  const void** pointer;
  GLint ptrstride;
CODE:
  OGLM_GLEWINIT
  OGLM_CHECK_ERR(glNormalPointerListIBM, )
  OGLM_AVAIL_CHECK(__glewNormalPointerListIBM, glNormalPointerListIBM)
  glNormalPointerListIBM(type, stride, pointer, ptrstride);
  OGLM_CHECK_ERR(glNormalPointerListIBM, )

void
glNormalPointervINTEL_c(type, pointer)
  GLenum type;
  const void** pointer;
CODE:
  OGLM_GLEWINIT
  OGLM_CHECK_ERR(glNormalPointervINTEL, )
  OGLM_AVAIL_CHECK(__glewNormalPointervINTEL, glNormalPointervINTEL)
  glNormalPointervINTEL(type, pointer);
  OGLM_CHECK_ERR(glNormalPointervINTEL, )

void
glNormalStream3bATI(stream, nx, ny, nz)
  GLenum stream;
  GLbyte nx;
  GLbyte ny;
  GLbyte nz;
CODE:
  OGLM_GLEWINIT
  OGLM_CHECK_ERR(glNormalStream3bATI, )
  OGLM_AVAIL_CHECK(__glewNormalStream3bATI, glNormalStream3bATI)
  glNormalStream3bATI(stream, nx, ny, nz);
  OGLM_CHECK_ERR(glNormalStream3bATI, )

void
glNormalStream3bvATI_c(stream, coords)
  GLenum stream;
  const GLbyte *coords;
CODE:
  OGLM_GLEWINIT
  OGLM_CHECK_ERR(glNormalStream3bvATI, )
  OGLM_AVAIL_CHECK(__glewNormalStream3bvATI, glNormalStream3bvATI)
  glNormalStream3bvATI(stream, coords);
  OGLM_CHECK_ERR(glNormalStream3bvATI, )

void
glNormalStream3bvATI_p(stream, ...)
  GLenum stream;
CODE:
  OGLM_GLEWINIT
  OGLM_CHECK_ERR(glNormalStream3bvATI, )
  OGLM_AVAIL_CHECK(__glewNormalStream3bvATI, glNormalStream3bvATI)
  GLbyte *coords = OGLM_GET_VARARGS(coords,1,GLbyte,IV,3);
  glNormalStream3bvATI((GLenum )stream, (const GLbyte *)coords);
  OGLM_CHECK_ERR(glNormalStream3bvATI, free(coords);)
  free(coords);

void
glNormalStream3dATI(stream, nx, ny, nz)
  GLenum stream;
  GLdouble nx;
  GLdouble ny;
  GLdouble nz;
CODE:
  OGLM_GLEWINIT
  OGLM_CHECK_ERR(glNormalStream3dATI, )
  OGLM_AVAIL_CHECK(__glewNormalStream3dATI, glNormalStream3dATI)
  glNormalStream3dATI(stream, nx, ny, nz);
  OGLM_CHECK_ERR(glNormalStream3dATI, )

void
glNormalStream3dvATI_c(stream, coords)
  GLenum stream;
  const GLdouble *coords;
CODE:
  OGLM_GLEWINIT
  OGLM_CHECK_ERR(glNormalStream3dvATI, )
  OGLM_AVAIL_CHECK(__glewNormalStream3dvATI, glNormalStream3dvATI)
  glNormalStream3dvATI(stream, coords);
  OGLM_CHECK_ERR(glNormalStream3dvATI, )

void
glNormalStream3dvATI_p(stream, ...)
  GLenum stream;
CODE:
  OGLM_GLEWINIT
  OGLM_CHECK_ERR(glNormalStream3dvATI, )
  OGLM_AVAIL_CHECK(__glewNormalStream3dvATI, glNormalStream3dvATI)
  GLdouble *coords = OGLM_GET_VARARGS(coords,1,GLdouble,NV,3);
  glNormalStream3dvATI((GLenum )stream, (const GLdouble *)coords);
  OGLM_CHECK_ERR(glNormalStream3dvATI, free(coords);)
  free(coords);

void
glNormalStream3fATI(stream, nx, ny, nz)
  GLenum stream;
  GLfloat nx;
  GLfloat ny;
  GLfloat nz;
CODE:
  OGLM_GLEWINIT
  OGLM_CHECK_ERR(glNormalStream3fATI, )
  OGLM_AVAIL_CHECK(__glewNormalStream3fATI, glNormalStream3fATI)
  glNormalStream3fATI(stream, nx, ny, nz);
  OGLM_CHECK_ERR(glNormalStream3fATI, )

void
glNormalStream3fvATI_c(stream, coords)
  GLenum stream;
  const GLfloat *coords;
CODE:
  OGLM_GLEWINIT
  OGLM_CHECK_ERR(glNormalStream3fvATI, )
  OGLM_AVAIL_CHECK(__glewNormalStream3fvATI, glNormalStream3fvATI)
  glNormalStream3fvATI(stream, coords);
  OGLM_CHECK_ERR(glNormalStream3fvATI, )

void
glNormalStream3fvATI_p(stream, ...)
  GLenum stream;
CODE:
  OGLM_GLEWINIT
  OGLM_CHECK_ERR(glNormalStream3fvATI, )
  OGLM_AVAIL_CHECK(__glewNormalStream3fvATI, glNormalStream3fvATI)
  GLfloat *coords = OGLM_GET_VARARGS(coords,1,GLfloat,NV,3);
  glNormalStream3fvATI((GLenum )stream, (const GLfloat *)coords);
  OGLM_CHECK_ERR(glNormalStream3fvATI, free(coords);)
  free(coords);

void
glNormalStream3iATI(stream, nx, ny, nz)
  GLenum stream;
  GLint nx;
  GLint ny;
  GLint nz;
CODE:
  OGLM_GLEWINIT
  OGLM_CHECK_ERR(glNormalStream3iATI, )
  OGLM_AVAIL_CHECK(__glewNormalStream3iATI, glNormalStream3iATI)
  glNormalStream3iATI(stream, nx, ny, nz);
  OGLM_CHECK_ERR(glNormalStream3iATI, )

void
glNormalStream3ivATI_c(stream, coords)
  GLenum stream;
  const GLint *coords;
CODE:
  OGLM_GLEWINIT
  OGLM_CHECK_ERR(glNormalStream3ivATI, )
  OGLM_AVAIL_CHECK(__glewNormalStream3ivATI, glNormalStream3ivATI)
  glNormalStream3ivATI(stream, coords);
  OGLM_CHECK_ERR(glNormalStream3ivATI, )

void
glNormalStream3ivATI_p(stream, ...)
  GLenum stream;
CODE:
  OGLM_GLEWINIT
  OGLM_CHECK_ERR(glNormalStream3ivATI, )
  OGLM_AVAIL_CHECK(__glewNormalStream3ivATI, glNormalStream3ivATI)
  GLint *coords = OGLM_GET_VARARGS(coords,1,GLint,IV,3);
  glNormalStream3ivATI((GLenum )stream, (const GLint *)coords);
  OGLM_CHECK_ERR(glNormalStream3ivATI, free(coords);)
  free(coords);

void
glNormalStream3sATI(stream, nx, ny, nz)
  GLenum stream;
  GLshort nx;
  GLshort ny;
  GLshort nz;
CODE:
  OGLM_GLEWINIT
  OGLM_CHECK_ERR(glNormalStream3sATI, )
  OGLM_AVAIL_CHECK(__glewNormalStream3sATI, glNormalStream3sATI)
  glNormalStream3sATI(stream, nx, ny, nz);
  OGLM_CHECK_ERR(glNormalStream3sATI, )

void
glNormalStream3svATI_c(stream, coords)
  GLenum stream;
  const GLshort *coords;
CODE:
  OGLM_GLEWINIT
  OGLM_CHECK_ERR(glNormalStream3svATI, )
  OGLM_AVAIL_CHECK(__glewNormalStream3svATI, glNormalStream3svATI)
  glNormalStream3svATI(stream, coords);
  OGLM_CHECK_ERR(glNormalStream3svATI, )

void
glNormalStream3svATI_p(stream, ...)
  GLenum stream;
CODE:
  OGLM_GLEWINIT
  OGLM_CHECK_ERR(glNormalStream3svATI, )
  OGLM_AVAIL_CHECK(__glewNormalStream3svATI, glNormalStream3svATI)
  GLshort *coords = OGLM_GET_VARARGS(coords,1,GLshort,IV,3);
  glNormalStream3svATI((GLenum )stream, (const GLshort *)coords);
  OGLM_CHECK_ERR(glNormalStream3svATI, free(coords);)
  free(coords);

void
glObjectLabel(identifier, name, length, label)
  GLenum identifier;
  GLuint name;
  GLsizei length;
  const GLchar* label;
ALIAS:
  glObjectLabelKHR = 1
CODE:
  OGLM_GLEWINIT
  OGLM_CHECK_ERR(glObjectLabel, )
  OGLM_AVAIL_CHECK(__glewObjectLabel, glObjectLabel)
  glObjectLabel(identifier, name, length, label);
  OGLM_CHECK_ERR(glObjectLabel, )

void
glObjectPtrLabel_c(ptr, length, label)
  void* ptr;
  GLsizei length;
  const GLchar* label;
ALIAS:
  glObjectPtrLabelKHR_c = 1
CODE:
  OGLM_GLEWINIT
  OGLM_CHECK_ERR(glObjectPtrLabel, )
  OGLM_AVAIL_CHECK(__glewObjectPtrLabel, glObjectPtrLabel)
  glObjectPtrLabel(ptr, length, label);
  OGLM_CHECK_ERR(glObjectPtrLabel, )

GLenum
glObjectPurgeableAPPLE(objectType, name, option)
  GLenum objectType;
  GLuint name;
  GLenum option;
CODE:
  OGLM_GLEWINIT
  OGLM_CHECK_ERR(glObjectPurgeableAPPLE, )
  OGLM_AVAIL_CHECK(__glewObjectPurgeableAPPLE, glObjectPurgeableAPPLE)
  RETVAL = glObjectPurgeableAPPLE(objectType, name, option);
  OGLM_CHECK_ERR(glObjectPurgeableAPPLE, )
OUTPUT:
  RETVAL

GLenum
glObjectUnpurgeableAPPLE(objectType, name, option)
  GLenum objectType;
  GLuint name;
  GLenum option;
CODE:
  OGLM_GLEWINIT
  OGLM_CHECK_ERR(glObjectUnpurgeableAPPLE, )
  OGLM_AVAIL_CHECK(__glewObjectUnpurgeableAPPLE, glObjectUnpurgeableAPPLE)
  RETVAL = glObjectUnpurgeableAPPLE(objectType, name, option);
  OGLM_CHECK_ERR(glObjectUnpurgeableAPPLE, )
OUTPUT:
  RETVAL

void
glOrtho(left, right, bottom, top, zNear, zFar)
  GLdouble left;
  GLdouble right;
  GLdouble bottom;
  GLdouble top;
  GLdouble zNear;
  GLdouble zFar;
CODE:
  OGLM_GLEWINIT
  OGLM_CHECK_ERR(glOrtho, )
  glOrtho(left, right, bottom, top, zNear, zFar);
  OGLM_CHECK_ERR(glOrtho, )

void
glOrthof(left, right, bottom, top, zNear, zFar)
  GLfloat left;
  GLfloat right;
  GLfloat bottom;
  GLfloat top;
  GLfloat zNear;
  GLfloat zFar;
CODE:
  OGLM_GLEWINIT
  OGLM_CHECK_ERR(glOrthof, )
  OGLM_AVAIL_CHECK(__glewOrthof, glOrthof)
  glOrthof(left, right, bottom, top, zNear, zFar);
  OGLM_CHECK_ERR(glOrthof, )

void
glOrthofOES(l, r, b, t, n, f)
  GLfloat l;
  GLfloat r;
  GLfloat b;
  GLfloat t;
  GLfloat n;
  GLfloat f;
CODE:
  OGLM_GLEWINIT
  OGLM_CHECK_ERR(glOrthofOES, )
  OGLM_AVAIL_CHECK(__glewOrthofOES, glOrthofOES)
  glOrthofOES(l, r, b, t, n, f);
  OGLM_CHECK_ERR(glOrthofOES, )

void
glOrthox(left, right, bottom, top, zNear, zFar)
  GLfixed left;
  GLfixed right;
  GLfixed bottom;
  GLfixed top;
  GLfixed zNear;
  GLfixed zFar;
CODE:
  OGLM_GLEWINIT
  OGLM_CHECK_ERR(glOrthox, )
  OGLM_AVAIL_CHECK(__glewOrthox, glOrthox)
  glOrthox(left, right, bottom, top, zNear, zFar);
  OGLM_CHECK_ERR(glOrthox, )

void
glPNTrianglesfATI(pname, param)
  GLenum pname;
  GLfloat param;
CODE:
  OGLM_GLEWINIT
  OGLM_CHECK_ERR(glPNTrianglesfATI, )
  OGLM_AVAIL_CHECK(__glewPNTrianglesfATI, glPNTrianglesfATI)
  glPNTrianglesfATI(pname, param);
  OGLM_CHECK_ERR(glPNTrianglesfATI, )

void
glPNTrianglesiATI(pname, param)
  GLenum pname;
  GLint param;
CODE:
  OGLM_GLEWINIT
  OGLM_CHECK_ERR(glPNTrianglesiATI, )
  OGLM_AVAIL_CHECK(__glewPNTrianglesiATI, glPNTrianglesiATI)
  glPNTrianglesiATI(pname, param);
  OGLM_CHECK_ERR(glPNTrianglesiATI, )

void
glPassTexCoordATI(dst, coord, swizzle)
  GLuint dst;
  GLuint coord;
  GLenum swizzle;
CODE:
  OGLM_GLEWINIT
  OGLM_CHECK_ERR(glPassTexCoordATI, )
  OGLM_AVAIL_CHECK(__glewPassTexCoordATI, glPassTexCoordATI)
  glPassTexCoordATI(dst, coord, swizzle);
  OGLM_CHECK_ERR(glPassTexCoordATI, )

void
glPassThrough(token)
  GLfloat token;
CODE:
  OGLM_GLEWINIT
  OGLM_CHECK_ERR(glPassThrough, )
  glPassThrough(token);
  OGLM_CHECK_ERR(glPassThrough, )

void
glPatchParameterfv_c(pname, values)
  GLenum pname;
  const GLfloat* values;
CODE:
  OGLM_GLEWINIT
  OGLM_CHECK_ERR(glPatchParameterfv, )
  OGLM_AVAIL_CHECK(__glewPatchParameterfv, glPatchParameterfv)
  glPatchParameterfv(pname, values);
  OGLM_CHECK_ERR(glPatchParameterfv, )

void
glPatchParameterfv_p(pname, ...)
  GLenum pname;
CODE:
  OGLM_GLEWINIT
  OGLM_CHECK_ERR(glPatchParameterfv, )
  OGLM_AVAIL_CHECK(__glewPatchParameterfv, glPatchParameterfv)
  OGLM_SIZE_ENUM(PatchParameterName,pname,1)
  GLfloat* values = OGLM_GET_VARARGS(values,1,GLfloat,NV,pname_count);
  glPatchParameterfv((GLenum )pname, (const GLfloat* )values);
  OGLM_CHECK_ERR(glPatchParameterfv, free(values);)
  free(values);

void
glPatchParameteri(pname, value)
  GLenum pname;
  GLint value;
ALIAS:
  glPatchParameteriEXT = 1
CODE:
  OGLM_GLEWINIT
  OGLM_CHECK_ERR(glPatchParameteri, )
  OGLM_AVAIL_CHECK(__glewPatchParameteri, glPatchParameteri)
  glPatchParameteri(pname, value);
  OGLM_CHECK_ERR(glPatchParameteri, )

void
glPathColorGenNV_c(color, genMode, colorFormat, coeffs)
  GLenum color;
  GLenum genMode;
  GLenum colorFormat;
  const GLfloat* coeffs;
CODE:
  OGLM_GLEWINIT
  OGLM_CHECK_ERR(glPathColorGenNV, )
  OGLM_AVAIL_CHECK(__glewPathColorGenNV, glPathColorGenNV)
  glPathColorGenNV(color, genMode, colorFormat, coeffs);
  OGLM_CHECK_ERR(glPathColorGenNV, )

void
glPathCommandsNV_c(path, numCommands, commands, numCoords, coordType, coords)
  GLuint path;
  GLsizei numCommands;
  const GLubyte* commands;
  GLsizei numCoords;
  GLenum coordType;
  const void*coords;
CODE:
  OGLM_GLEWINIT
  OGLM_CHECK_ERR(glPathCommandsNV, )
  OGLM_AVAIL_CHECK(__glewPathCommandsNV, glPathCommandsNV)
  glPathCommandsNV(path, numCommands, commands, numCoords, coordType, coords);
  OGLM_CHECK_ERR(glPathCommandsNV, )

void
glPathCoordsNV_c(path, numCoords, coordType, coords)
  GLuint path;
  GLsizei numCoords;
  GLenum coordType;
  const void *coords;
CODE:
  OGLM_GLEWINIT
  OGLM_CHECK_ERR(glPathCoordsNV, )
  OGLM_AVAIL_CHECK(__glewPathCoordsNV, glPathCoordsNV)
  glPathCoordsNV(path, numCoords, coordType, coords);
  OGLM_CHECK_ERR(glPathCoordsNV, )

void
glPathCoverDepthFuncNV(func)
  GLenum func;
CODE:
  OGLM_GLEWINIT
  OGLM_CHECK_ERR(glPathCoverDepthFuncNV, )
  OGLM_AVAIL_CHECK(__glewPathCoverDepthFuncNV, glPathCoverDepthFuncNV)
  glPathCoverDepthFuncNV(func);
  OGLM_CHECK_ERR(glPathCoverDepthFuncNV, )

void
glPathDashArrayNV_c(path, dashCount, dashArray)
  GLuint path;
  GLsizei dashCount;
  const GLfloat* dashArray;
CODE:
  OGLM_GLEWINIT
  OGLM_CHECK_ERR(glPathDashArrayNV, )
  OGLM_AVAIL_CHECK(__glewPathDashArrayNV, glPathDashArrayNV)
  glPathDashArrayNV(path, dashCount, dashArray);
  OGLM_CHECK_ERR(glPathDashArrayNV, )

void
glPathDashArrayNV_p(path, ...)
  GLuint path;
CODE:
  OGLM_GLEWINIT
  OGLM_CHECK_ERR(glPathDashArrayNV, )
  OGLM_AVAIL_CHECK(__glewPathDashArrayNV, glPathDashArrayNV)
  GLsizei dashCount = items-1;
  GLfloat* dashArray = OGLM_GET_VARARGS(dashArray,1,GLfloat,NV,dashCount);
  glPathDashArrayNV((GLuint )path, (GLsizei )dashCount, (const GLfloat* )dashArray);
  OGLM_CHECK_ERR(glPathDashArrayNV, free(dashArray);)
  free(dashArray);

void
glPathFogGenNV(genMode)
  GLenum genMode;
CODE:
  OGLM_GLEWINIT
  OGLM_CHECK_ERR(glPathFogGenNV, )
  OGLM_AVAIL_CHECK(__glewPathFogGenNV, glPathFogGenNV)
  glPathFogGenNV(genMode);
  OGLM_CHECK_ERR(glPathFogGenNV, )

GLenum
glPathGlyphIndexArrayNV_c(firstPathName, fontTarget, fontName, fontStyle, firstGlyphIndex, numGlyphs, pathParameterTemplate, emScale)
  GLuint firstPathName;
  GLenum fontTarget;
  const void *fontName;
  GLbitfield fontStyle;
  GLuint firstGlyphIndex;
  GLsizei numGlyphs;
  GLuint pathParameterTemplate;
  GLfloat emScale;
CODE:
  OGLM_GLEWINIT
  OGLM_CHECK_ERR(glPathGlyphIndexArrayNV, )
  OGLM_AVAIL_CHECK(__glewPathGlyphIndexArrayNV, glPathGlyphIndexArrayNV)
  RETVAL = glPathGlyphIndexArrayNV(firstPathName, fontTarget, fontName, fontStyle, firstGlyphIndex, numGlyphs, pathParameterTemplate, emScale);
  OGLM_CHECK_ERR(glPathGlyphIndexArrayNV, )
OUTPUT:
  RETVAL

GLenum
glPathGlyphIndexRangeNV_c(fontTarget, fontName, fontStyle, pathParameterTemplate, emScale, baseAndCount)
  GLenum fontTarget;
  const void *fontName;
  GLbitfield fontStyle;
  GLuint pathParameterTemplate;
  GLfloat emScale;
  GLuint* baseAndCount;
CODE:
  OGLM_GLEWINIT
  OGLM_CHECK_ERR(glPathGlyphIndexRangeNV, )
  OGLM_AVAIL_CHECK(__glewPathGlyphIndexRangeNV, glPathGlyphIndexRangeNV)
  RETVAL = glPathGlyphIndexRangeNV(fontTarget, fontName, fontStyle, pathParameterTemplate, emScale, baseAndCount);
  OGLM_CHECK_ERR(glPathGlyphIndexRangeNV, )
OUTPUT:
  RETVAL

GLenum
glPathGlyphIndexRangeNV_p(fontTarget, fontName, fontStyle, pathParameterTemplate, emScale)
  GLenum fontTarget;
  const void *fontName;
  GLbitfield fontStyle;
  GLuint pathParameterTemplate;
  GLfloat emScale;
PPCODE:
  OGLM_GLEWINIT
  OGLM_CHECK_ERR(glPathGlyphIndexRangeNV, )
  OGLM_AVAIL_CHECK(__glewPathGlyphIndexRangeNV, glPathGlyphIndexRangeNV)
  GLuint* baseAndCount = OGLM_ALLOC(2,GLuint,baseAndCount);
  RETVAL = glPathGlyphIndexRangeNV(fontTarget, fontName, fontStyle, pathParameterTemplate, emScale, baseAndCount);
  OGLM_CHECK_ERR(glPathGlyphIndexRangeNV, free(baseAndCount);)
  EXTEND(sp, 2);
  mPUSHs(newSViv(RETVAL));
  OGLM_PUSH_ARRAY(glPathGlyphIndexRangeNV, newSVuv, baseAndCount, 2)
  free(baseAndCount);

void
glPathGlyphRangeNV_c(firstPathName, fontTarget, fontName, fontStyle, firstGlyph, numGlyphs, handleMissingGlyphs, pathParameterTemplate, emScale)
  GLuint firstPathName;
  GLenum fontTarget;
  const void *fontName;
  GLbitfield fontStyle;
  GLuint firstGlyph;
  GLsizei numGlyphs;
  GLenum handleMissingGlyphs;
  GLuint pathParameterTemplate;
  GLfloat emScale;
CODE:
  OGLM_GLEWINIT
  OGLM_CHECK_ERR(glPathGlyphRangeNV, )
  OGLM_AVAIL_CHECK(__glewPathGlyphRangeNV, glPathGlyphRangeNV)
  glPathGlyphRangeNV(firstPathName, fontTarget, fontName, fontStyle, firstGlyph, numGlyphs, handleMissingGlyphs, pathParameterTemplate, emScale);
  OGLM_CHECK_ERR(glPathGlyphRangeNV, )

void
glPathGlyphsNV_c(firstPathName, fontTarget, fontName, fontStyle, numGlyphs, type, charcodes, handleMissingGlyphs, pathParameterTemplate, emScale)
  GLuint firstPathName;
  GLenum fontTarget;
  const void *fontName;
  GLbitfield fontStyle;
  GLsizei numGlyphs;
  GLenum type;
  const void*charcodes;
  GLenum handleMissingGlyphs;
  GLuint pathParameterTemplate;
  GLfloat emScale;
CODE:
  OGLM_GLEWINIT
  OGLM_CHECK_ERR(glPathGlyphsNV, )
  OGLM_AVAIL_CHECK(__glewPathGlyphsNV, glPathGlyphsNV)
  glPathGlyphsNV(firstPathName, fontTarget, fontName, fontStyle, numGlyphs, type, charcodes, handleMissingGlyphs, pathParameterTemplate, emScale);
  OGLM_CHECK_ERR(glPathGlyphsNV, )

GLenum
glPathMemoryGlyphIndexArrayNV_c(firstPathName, fontTarget, fontSize, fontData, faceIndex, firstGlyphIndex, numGlyphs, pathParameterTemplate, emScale)
  GLuint firstPathName;
  GLenum fontTarget;
  GLsizeiptr fontSize;
  const void *fontData;
  GLsizei faceIndex;
  GLuint firstGlyphIndex;
  GLsizei numGlyphs;
  GLuint pathParameterTemplate;
  GLfloat emScale;
CODE:
  OGLM_GLEWINIT
  OGLM_CHECK_ERR(glPathMemoryGlyphIndexArrayNV, )
  OGLM_AVAIL_CHECK(__glewPathMemoryGlyphIndexArrayNV, glPathMemoryGlyphIndexArrayNV)
  RETVAL = glPathMemoryGlyphIndexArrayNV(firstPathName, fontTarget, fontSize, fontData, faceIndex, firstGlyphIndex, numGlyphs, pathParameterTemplate, emScale);
  OGLM_CHECK_ERR(glPathMemoryGlyphIndexArrayNV, )
OUTPUT:
  RETVAL

void
glPathParameterfNV(path, pname, value)
  GLuint path;
  GLenum pname;
  GLfloat value;
CODE:
  OGLM_GLEWINIT
  OGLM_CHECK_ERR(glPathParameterfNV, )
  OGLM_AVAIL_CHECK(__glewPathParameterfNV, glPathParameterfNV)
  glPathParameterfNV(path, pname, value);
  OGLM_CHECK_ERR(glPathParameterfNV, )

void
glPathParameterfvNV_c(path, pname, value)
  GLuint path;
  GLenum pname;
  const GLfloat* value;
CODE:
  OGLM_GLEWINIT
  OGLM_CHECK_ERR(glPathParameterfvNV, )
  OGLM_AVAIL_CHECK(__glewPathParameterfvNV, glPathParameterfvNV)
  glPathParameterfvNV(path, pname, value);
  OGLM_CHECK_ERR(glPathParameterfvNV, )

void
glPathParameteriNV(path, pname, value)
  GLuint path;
  GLenum pname;
  GLint value;
CODE:
  OGLM_GLEWINIT
  OGLM_CHECK_ERR(glPathParameteriNV, )
  OGLM_AVAIL_CHECK(__glewPathParameteriNV, glPathParameteriNV)
  glPathParameteriNV(path, pname, value);
  OGLM_CHECK_ERR(glPathParameteriNV, )

void
glPathParameterivNV_c(path, pname, value)
  GLuint path;
  GLenum pname;
  const GLint* value;
CODE:
  OGLM_GLEWINIT
  OGLM_CHECK_ERR(glPathParameterivNV, )
  OGLM_AVAIL_CHECK(__glewPathParameterivNV, glPathParameterivNV)
  glPathParameterivNV(path, pname, value);
  OGLM_CHECK_ERR(glPathParameterivNV, )

void
glPathStencilDepthOffsetNV(factor, units)
  GLfloat factor;
  GLfloat units;
CODE:
  OGLM_GLEWINIT
  OGLM_CHECK_ERR(glPathStencilDepthOffsetNV, )
  OGLM_AVAIL_CHECK(__glewPathStencilDepthOffsetNV, glPathStencilDepthOffsetNV)
  glPathStencilDepthOffsetNV(factor, units);
  OGLM_CHECK_ERR(glPathStencilDepthOffsetNV, )

void
glPathStencilFuncNV(func, ref, mask)
  GLenum func;
  GLint ref;
  GLuint mask;
CODE:
  OGLM_GLEWINIT
  OGLM_CHECK_ERR(glPathStencilFuncNV, )
  OGLM_AVAIL_CHECK(__glewPathStencilFuncNV, glPathStencilFuncNV)
  glPathStencilFuncNV(func, ref, mask);
  OGLM_CHECK_ERR(glPathStencilFuncNV, )

void
glPathStringNV_c(path, format, length, pathString)
  GLuint path;
  GLenum format;
  GLsizei length;
  const void *pathString;
CODE:
  OGLM_GLEWINIT
  OGLM_CHECK_ERR(glPathStringNV, )
  OGLM_AVAIL_CHECK(__glewPathStringNV, glPathStringNV)
  glPathStringNV(path, format, length, pathString);
  OGLM_CHECK_ERR(glPathStringNV, )

void
glPathSubCommandsNV_c(path, commandStart, commandsToDelete, numCommands, commands, numCoords, coordType, coords)
  GLuint path;
  GLsizei commandStart;
  GLsizei commandsToDelete;
  GLsizei numCommands;
  const GLubyte* commands;
  GLsizei numCoords;
  GLenum coordType;
  const void*coords;
CODE:
  OGLM_GLEWINIT
  OGLM_CHECK_ERR(glPathSubCommandsNV, )
  OGLM_AVAIL_CHECK(__glewPathSubCommandsNV, glPathSubCommandsNV)
  glPathSubCommandsNV(path, commandStart, commandsToDelete, numCommands, commands, numCoords, coordType, coords);
  OGLM_CHECK_ERR(glPathSubCommandsNV, )

void
glPathSubCoordsNV_c(path, coordStart, numCoords, coordType, coords)
  GLuint path;
  GLsizei coordStart;
  GLsizei numCoords;
  GLenum coordType;
  const void *coords;
CODE:
  OGLM_GLEWINIT
  OGLM_CHECK_ERR(glPathSubCoordsNV, )
  OGLM_AVAIL_CHECK(__glewPathSubCoordsNV, glPathSubCoordsNV)
  glPathSubCoordsNV(path, coordStart, numCoords, coordType, coords);
  OGLM_CHECK_ERR(glPathSubCoordsNV, )

void
glPathTexGenNV_c(texCoordSet, genMode, components, coeffs)
  GLenum texCoordSet;
  GLenum genMode;
  GLint components;
  const GLfloat* coeffs;
CODE:
  OGLM_GLEWINIT
  OGLM_CHECK_ERR(glPathTexGenNV, )
  OGLM_AVAIL_CHECK(__glewPathTexGenNV, glPathTexGenNV)
  glPathTexGenNV(texCoordSet, genMode, components, coeffs);
  OGLM_CHECK_ERR(glPathTexGenNV, )

void
glPauseTransformFeedback()
ALIAS:
  glPauseTransformFeedbackNV = 1
CODE:
  OGLM_GLEWINIT
  OGLM_CHECK_ERR(glPauseTransformFeedback, )
  OGLM_AVAIL_CHECK(__glewPauseTransformFeedback, glPauseTransformFeedback)
  glPauseTransformFeedback();
  OGLM_CHECK_ERR(glPauseTransformFeedback, )

void
glPixelDataRangeNV_c(target, length, pointer)
  GLenum target;
  GLsizei length;
  void *pointer;
CODE:
  OGLM_GLEWINIT
  OGLM_CHECK_ERR(glPixelDataRangeNV, )
  OGLM_AVAIL_CHECK(__glewPixelDataRangeNV, glPixelDataRangeNV)
  glPixelDataRangeNV(target, length, pointer);
  OGLM_CHECK_ERR(glPixelDataRangeNV, )

void
glPixelMapfv_c(map, mapsize, values)
  GLenum map;
  GLsizei mapsize;
  const GLfloat *values;
CODE:
  OGLM_GLEWINIT
  OGLM_CHECK_ERR(glPixelMapfv, )
  glPixelMapfv(map, mapsize, values);
  OGLM_CHECK_ERR(glPixelMapfv, )

void
glPixelMapfv_p(map, ...)
  GLenum map;
CODE:
  OGLM_GLEWINIT
  OGLM_CHECK_ERR(glPixelMapfv, )
  GLsizei mapsize = items-1;
  GLfloat *values = OGLM_GET_VARARGS(values,1,GLfloat,NV,mapsize);
  glPixelMapfv((GLenum )map, (GLsizei )mapsize, (const GLfloat *)values);
  OGLM_CHECK_ERR(glPixelMapfv, free(values);)
  free(values);

void
glPixelMapuiv_c(map, mapsize, values)
  GLenum map;
  GLsizei mapsize;
  const GLuint *values;
CODE:
  OGLM_GLEWINIT
  OGLM_CHECK_ERR(glPixelMapuiv, )
  glPixelMapuiv(map, mapsize, values);
  OGLM_CHECK_ERR(glPixelMapuiv, )

void
glPixelMapuiv_p(map, ...)
  GLenum map;
CODE:
  OGLM_GLEWINIT
  OGLM_CHECK_ERR(glPixelMapuiv, )
  GLsizei mapsize = items-1;
  GLuint *values = OGLM_GET_VARARGS(values,1,GLuint,UV,mapsize);
  glPixelMapuiv((GLenum )map, (GLsizei )mapsize, (const GLuint *)values);
  OGLM_CHECK_ERR(glPixelMapuiv, free(values);)
  free(values);

void
glPixelMapusv_c(map, mapsize, values)
  GLenum map;
  GLsizei mapsize;
  const GLushort *values;
CODE:
  OGLM_GLEWINIT
  OGLM_CHECK_ERR(glPixelMapusv, )
  glPixelMapusv(map, mapsize, values);
  OGLM_CHECK_ERR(glPixelMapusv, )

void
glPixelMapusv_p(map, ...)
  GLenum map;
CODE:
  OGLM_GLEWINIT
  OGLM_CHECK_ERR(glPixelMapusv, )
  GLsizei mapsize = items-1;
  GLushort *values = OGLM_GET_VARARGS(values,1,GLushort,UV,mapsize);
  glPixelMapusv((GLenum )map, (GLsizei )mapsize, (const GLushort *)values);
  OGLM_CHECK_ERR(glPixelMapusv, free(values);)
  free(values);

void
glPixelStoref(pname, param)
  GLenum pname;
  GLfloat param;
CODE:
  OGLM_GLEWINIT
  OGLM_CHECK_ERR(glPixelStoref, )
  glPixelStoref(pname, param);
  OGLM_CHECK_ERR(glPixelStoref, )

void
glPixelStorei(pname, param)
  GLenum pname;
  GLint param;
CODE:
  OGLM_GLEWINIT
  OGLM_CHECK_ERR(glPixelStorei, )
  glPixelStorei(pname, param);
  OGLM_CHECK_ERR(glPixelStorei, )

void
glPixelTexGenSGIX(mode)
  GLenum mode;
CODE:
  OGLM_GLEWINIT
  OGLM_CHECK_ERR(glPixelTexGenSGIX, )
  OGLM_AVAIL_CHECK(__glewPixelTexGenSGIX, glPixelTexGenSGIX)
  glPixelTexGenSGIX(mode);
  OGLM_CHECK_ERR(glPixelTexGenSGIX, )

void
glPixelTransferf(pname, param)
  GLenum pname;
  GLfloat param;
CODE:
  OGLM_GLEWINIT
  OGLM_CHECK_ERR(glPixelTransferf, )
  glPixelTransferf(pname, param);
  OGLM_CHECK_ERR(glPixelTransferf, )

void
glPixelTransferi(pname, param)
  GLenum pname;
  GLint param;
CODE:
  OGLM_GLEWINIT
  OGLM_CHECK_ERR(glPixelTransferi, )
  glPixelTransferi(pname, param);
  OGLM_CHECK_ERR(glPixelTransferi, )

void
glPixelTransformParameterfEXT(target, pname, param)
  GLenum target;
  GLenum pname;
  const GLfloat param;
CODE:
  OGLM_GLEWINIT
  OGLM_CHECK_ERR(glPixelTransformParameterfEXT, )
  OGLM_AVAIL_CHECK(__glewPixelTransformParameterfEXT, glPixelTransformParameterfEXT)
  glPixelTransformParameterfEXT(target, pname, param);
  OGLM_CHECK_ERR(glPixelTransformParameterfEXT, )

void
glPixelTransformParameterfSGI(target, pname, param)
  GLenum target;
  GLenum pname;
  GLfloat param;
CODE:
  OGLM_GLEWINIT
  OGLM_CHECK_ERR(glPixelTransformParameterfSGI, )
  OGLM_AVAIL_CHECK(__glewPixelTransformParameterfSGI, glPixelTransformParameterfSGI)
  glPixelTransformParameterfSGI(target, pname, param);
  OGLM_CHECK_ERR(glPixelTransformParameterfSGI, )

void
glPixelTransformParameterfvEXT_c(target, pname, params)
  GLenum target;
  GLenum pname;
  const GLfloat* params;
CODE:
  OGLM_GLEWINIT
  OGLM_CHECK_ERR(glPixelTransformParameterfvEXT, )
  OGLM_AVAIL_CHECK(__glewPixelTransformParameterfvEXT, glPixelTransformParameterfvEXT)
  glPixelTransformParameterfvEXT(target, pname, params);
  OGLM_CHECK_ERR(glPixelTransformParameterfvEXT, )

void
glPixelTransformParameterfvEXT_p(target, pname, ...)
  GLenum target;
  GLenum pname;
CODE:
  OGLM_GLEWINIT
  OGLM_CHECK_ERR(glPixelTransformParameterfvEXT, )
  OGLM_AVAIL_CHECK(__glewPixelTransformParameterfvEXT, glPixelTransformParameterfvEXT)
  GLfloat* params = OGLM_GET_VARARGS(params,2,GLfloat,NV,1);
  glPixelTransformParameterfvEXT((GLenum )target, (GLenum )pname, (const GLfloat* )params);
  OGLM_CHECK_ERR(glPixelTransformParameterfvEXT, free(params);)
  free(params);

void
glPixelTransformParameterfvSGI_c(target, pname, params)
  GLenum target;
  GLenum pname;
  const GLfloat* params;
CODE:
  OGLM_GLEWINIT
  OGLM_CHECK_ERR(glPixelTransformParameterfvSGI, )
  OGLM_AVAIL_CHECK(__glewPixelTransformParameterfvSGI, glPixelTransformParameterfvSGI)
  glPixelTransformParameterfvSGI(target, pname, params);
  OGLM_CHECK_ERR(glPixelTransformParameterfvSGI, )

void
glPixelTransformParameteriEXT(target, pname, param)
  GLenum target;
  GLenum pname;
  const GLint param;
CODE:
  OGLM_GLEWINIT
  OGLM_CHECK_ERR(glPixelTransformParameteriEXT, )
  OGLM_AVAIL_CHECK(__glewPixelTransformParameteriEXT, glPixelTransformParameteriEXT)
  glPixelTransformParameteriEXT(target, pname, param);
  OGLM_CHECK_ERR(glPixelTransformParameteriEXT, )

void
glPixelTransformParameteriSGI(target, pname, param)
  GLenum target;
  GLenum pname;
  GLint param;
CODE:
  OGLM_GLEWINIT
  OGLM_CHECK_ERR(glPixelTransformParameteriSGI, )
  OGLM_AVAIL_CHECK(__glewPixelTransformParameteriSGI, glPixelTransformParameteriSGI)
  glPixelTransformParameteriSGI(target, pname, param);
  OGLM_CHECK_ERR(glPixelTransformParameteriSGI, )

void
glPixelTransformParameterivEXT_c(target, pname, params)
  GLenum target;
  GLenum pname;
  const GLint* params;
CODE:
  OGLM_GLEWINIT
  OGLM_CHECK_ERR(glPixelTransformParameterivEXT, )
  OGLM_AVAIL_CHECK(__glewPixelTransformParameterivEXT, glPixelTransformParameterivEXT)
  glPixelTransformParameterivEXT(target, pname, params);
  OGLM_CHECK_ERR(glPixelTransformParameterivEXT, )

void
glPixelTransformParameterivEXT_p(target, pname, ...)
  GLenum target;
  GLenum pname;
CODE:
  OGLM_GLEWINIT
  OGLM_CHECK_ERR(glPixelTransformParameterivEXT, )
  OGLM_AVAIL_CHECK(__glewPixelTransformParameterivEXT, glPixelTransformParameterivEXT)
  GLint* params = OGLM_GET_VARARGS(params,2,GLint,IV,1);
  glPixelTransformParameterivEXT((GLenum )target, (GLenum )pname, (const GLint* )params);
  OGLM_CHECK_ERR(glPixelTransformParameterivEXT, free(params);)
  free(params);

void
glPixelTransformParameterivSGI_c(target, pname, params)
  GLenum target;
  GLenum pname;
  const GLint* params;
CODE:
  OGLM_GLEWINIT
  OGLM_CHECK_ERR(glPixelTransformParameterivSGI, )
  OGLM_AVAIL_CHECK(__glewPixelTransformParameterivSGI, glPixelTransformParameterivSGI)
  glPixelTransformParameterivSGI(target, pname, params);
  OGLM_CHECK_ERR(glPixelTransformParameterivSGI, )

void
glPixelTransformSGI(target)
  GLenum target;
CODE:
  OGLM_GLEWINIT
  OGLM_CHECK_ERR(glPixelTransformSGI, )
  OGLM_AVAIL_CHECK(__glewPixelTransformSGI, glPixelTransformSGI)
  glPixelTransformSGI(target);
  OGLM_CHECK_ERR(glPixelTransformSGI, )

void
glPixelZoom(xfactor, yfactor)
  GLfloat xfactor;
  GLfloat yfactor;
CODE:
  OGLM_GLEWINIT
  OGLM_CHECK_ERR(glPixelZoom, )
  glPixelZoom(xfactor, yfactor);
  OGLM_CHECK_ERR(glPixelZoom, )

GLboolean
glPointAlongPathNV_c(path, startSegment, numSegments, distance, x, y, tangentX, tangentY)
  GLuint path;
  GLsizei startSegment;
  GLsizei numSegments;
  GLfloat distance;
  GLfloat* x;
  GLfloat *y;
  GLfloat *tangentX;
  GLfloat *tangentY;
CODE:
  OGLM_GLEWINIT
  OGLM_CHECK_ERR(glPointAlongPathNV, )
  OGLM_AVAIL_CHECK(__glewPointAlongPathNV, glPointAlongPathNV)
  RETVAL = glPointAlongPathNV(path, startSegment, numSegments, distance, x, y, tangentX, tangentY);
  OGLM_CHECK_ERR(glPointAlongPathNV, )
OUTPUT:
  RETVAL

GLboolean
glPointAlongPathNV_p(path, startSegment, numSegments, distance)
  GLuint path;
  GLsizei startSegment;
  GLsizei numSegments;
  GLfloat distance;
PPCODE:
  OGLM_GLEWINIT
  OGLM_CHECK_ERR(glPointAlongPathNV, )
  OGLM_AVAIL_CHECK(__glewPointAlongPathNV, glPointAlongPathNV)
  GLfloat tangentX[1];
  GLfloat tangentY[1];
  GLfloat x[1];
  GLfloat y[1];
  RETVAL = glPointAlongPathNV(path, startSegment, numSegments, distance, x, y, tangentX, tangentY);
  OGLM_CHECK_ERR(glPointAlongPathNV, )
  EXTEND(sp, 5);
  mPUSHs(newSViv(RETVAL));
  mPUSHs(newSVnv(x[0]));
  mPUSHs(newSVnv(y[0]));
  mPUSHs(newSVnv(tangentX[0]));
  mPUSHs(newSVnv(tangentY[0]));

void
glPointParameterf(pname, param)
  GLenum pname;
  GLfloat param;
ALIAS:
  glPointParameterfARB = 1
  glPointParameterfEXT = 2
  glPointParameterfSGIS = 3
CODE:
  OGLM_GLEWINIT
  OGLM_CHECK_ERR(glPointParameterf, )
  OGLM_AVAIL_CHECK(__glewPointParameterf, glPointParameterf)
  glPointParameterf(pname, param);
  OGLM_CHECK_ERR(glPointParameterf, )

void
glPointParameterfv_c(pname, params)
  GLenum pname;
  const GLfloat *params;
ALIAS:
  glPointParameterfvARB_c = 1
  glPointParameterfvEXT_c = 2
  glPointParameterfvSGIS_c = 3
CODE:
  OGLM_GLEWINIT
  OGLM_CHECK_ERR(glPointParameterfv, )
  OGLM_AVAIL_CHECK(__glewPointParameterfv, glPointParameterfv)
  glPointParameterfv(pname, params);
  OGLM_CHECK_ERR(glPointParameterfv, )

void
glPointParameterfv_p(pname, ...)
  GLenum pname;
ALIAS:
  glPointParameterfvARB_p = 1
  glPointParameterfvEXT_p = 2
  glPointParameterfvSGIS_p = 3
CODE:
  OGLM_GLEWINIT
  OGLM_CHECK_ERR(glPointParameterfv, )
  OGLM_AVAIL_CHECK(__glewPointParameterfv, glPointParameterfv)
  OGLM_SIZE_ENUM(PointParameterNameARB,pname,1)
  GLfloat *params = OGLM_GET_VARARGS(params,1,GLfloat,NV,pname_count);
  glPointParameterfv((GLenum )pname, (const GLfloat *)params);
  OGLM_CHECK_ERR(glPointParameterfv, free(params);)
  free(params);

void
glPointParameteri(pname, param)
  GLenum pname;
  GLint param;
ALIAS:
  glPointParameteriNV = 1
CODE:
  OGLM_GLEWINIT
  OGLM_CHECK_ERR(glPointParameteri, )
  OGLM_AVAIL_CHECK(__glewPointParameteri, glPointParameteri)
  glPointParameteri(pname, param);
  OGLM_CHECK_ERR(glPointParameteri, )

void
glPointParameteriv_c(pname, params)
  GLenum pname;
  const GLint *params;
ALIAS:
  glPointParameterivNV_c = 1
CODE:
  OGLM_GLEWINIT
  OGLM_CHECK_ERR(glPointParameteriv, )
  OGLM_AVAIL_CHECK(__glewPointParameteriv, glPointParameteriv)
  glPointParameteriv(pname, params);
  OGLM_CHECK_ERR(glPointParameteriv, )

void
glPointParameteriv_p(pname, ...)
  GLenum pname;
ALIAS:
  glPointParameterivNV_p = 1
CODE:
  OGLM_GLEWINIT
  OGLM_CHECK_ERR(glPointParameteriv, )
  OGLM_AVAIL_CHECK(__glewPointParameteriv, glPointParameteriv)
  OGLM_SIZE_ENUM(PointParameterNameARB,pname,1)
  GLint *params = OGLM_GET_VARARGS(params,1,GLint,IV,pname_count);
  glPointParameteriv((GLenum )pname, (const GLint *)params);
  OGLM_CHECK_ERR(glPointParameteriv, free(params);)
  free(params);

void
glPointParameterx(pname, param)
  GLenum pname;
  GLfixed param;
CODE:
  OGLM_GLEWINIT
  OGLM_CHECK_ERR(glPointParameterx, )
  OGLM_AVAIL_CHECK(__glewPointParameterx, glPointParameterx)
  glPointParameterx(pname, param);
  OGLM_CHECK_ERR(glPointParameterx, )

void
glPointParameterxv_c(pname, params)
  GLenum pname;
  const GLfixed* params;
CODE:
  OGLM_GLEWINIT
  OGLM_CHECK_ERR(glPointParameterxv, )
  OGLM_AVAIL_CHECK(__glewPointParameterxv, glPointParameterxv)
  glPointParameterxv(pname, params);
  OGLM_CHECK_ERR(glPointParameterxv, )

void
glPointParameterxv_p(pname, ...)
  GLenum pname;
CODE:
  OGLM_GLEWINIT
  OGLM_CHECK_ERR(glPointParameterxv, )
  OGLM_AVAIL_CHECK(__glewPointParameterxv, glPointParameterxv)
  OGLM_SIZE_ENUM(PointParameterNameARB,pname,1)
  GLfixed* params = OGLM_GET_VARARGS(params,1,GLfixed,IV,pname_count);
  glPointParameterxv((GLenum )pname, (const GLfixed* )params);
  OGLM_CHECK_ERR(glPointParameterxv, free(params);)
  free(params);

void
glPointSize(size)
  GLfloat size;
CODE:
  OGLM_GLEWINIT
  OGLM_CHECK_ERR(glPointSize, )
  glPointSize(size);
  OGLM_CHECK_ERR(glPointSize, )

void
glPointSizePointerOES_c(type, stride, pointer)
  GLenum type;
  GLsizei stride;
  const void *pointer;
CODE:
  OGLM_GLEWINIT
  OGLM_CHECK_ERR(glPointSizePointerOES, )
  OGLM_AVAIL_CHECK(__glewPointSizePointerOES, glPointSizePointerOES)
  glPointSizePointerOES(type, stride, pointer);
  OGLM_CHECK_ERR(glPointSizePointerOES, )

void
glPointSizex(size)
  GLfixed size;
CODE:
  OGLM_GLEWINIT
  OGLM_CHECK_ERR(glPointSizex, )
  OGLM_AVAIL_CHECK(__glewPointSizex, glPointSizex)
  glPointSizex(size);
  OGLM_CHECK_ERR(glPointSizex, )

GLint
glPollAsyncSGIX_c(markerp)
  GLuint* markerp;
CODE:
  OGLM_GLEWINIT
  OGLM_CHECK_ERR(glPollAsyncSGIX, )
  OGLM_AVAIL_CHECK(__glewPollAsyncSGIX, glPollAsyncSGIX)
  RETVAL = glPollAsyncSGIX(markerp);
  OGLM_CHECK_ERR(glPollAsyncSGIX, )
OUTPUT:
  RETVAL

GLint
glPollAsyncSGIX_p()
PPCODE:
  OGLM_GLEWINIT
  OGLM_CHECK_ERR(glPollAsyncSGIX, )
  OGLM_AVAIL_CHECK(__glewPollAsyncSGIX, glPollAsyncSGIX)
  GLuint markerp[1];
  RETVAL = glPollAsyncSGIX(markerp);
  OGLM_CHECK_ERR(glPollAsyncSGIX, )
  EXTEND(sp, 2);
  mPUSHs(newSViv(RETVAL));
  mPUSHs(newSVuv(markerp[0]));

void
glPolygonMode(face, mode)
  GLenum face;
  GLenum mode;
ALIAS:
  glPolygonModeNV = 1
CODE:
  OGLM_GLEWINIT
  OGLM_CHECK_ERR(glPolygonMode, )
  glPolygonMode(face, mode);
  OGLM_CHECK_ERR(glPolygonMode, )

void
glPolygonOffset(factor, units)
  GLfloat factor;
  GLfloat units;
CODE:
  OGLM_GLEWINIT
  OGLM_CHECK_ERR(glPolygonOffset, )
  glPolygonOffset(factor, units);
  OGLM_CHECK_ERR(glPolygonOffset, )

void
glPolygonOffsetClamp(factor, units, clamp)
  GLfloat factor;
  GLfloat units;
  GLfloat clamp;
ALIAS:
  glPolygonOffsetClampEXT = 1
CODE:
  OGLM_GLEWINIT
  OGLM_CHECK_ERR(glPolygonOffsetClamp, )
  OGLM_AVAIL_CHECK(__glewPolygonOffsetClamp, glPolygonOffsetClamp)
  glPolygonOffsetClamp(factor, units, clamp);
  OGLM_CHECK_ERR(glPolygonOffsetClamp, )

void
glPolygonOffsetEXT(factor, bias)
  GLfloat factor;
  GLfloat bias;
CODE:
  OGLM_GLEWINIT
  OGLM_CHECK_ERR(glPolygonOffsetEXT, )
  OGLM_AVAIL_CHECK(__glewPolygonOffsetEXT, glPolygonOffsetEXT)
  glPolygonOffsetEXT(factor, bias);
  OGLM_CHECK_ERR(glPolygonOffsetEXT, )

void
glPolygonOffsetx(factor, units)
  GLfixed factor;
  GLfixed units;
CODE:
  OGLM_GLEWINIT
  OGLM_CHECK_ERR(glPolygonOffsetx, )
  OGLM_AVAIL_CHECK(__glewPolygonOffsetx, glPolygonOffsetx)
  glPolygonOffsetx(factor, units);
  OGLM_CHECK_ERR(glPolygonOffsetx, )

void
glPolygonStipple(mask)
  const GLubyte *mask;
CODE:
  OGLM_GLEWINIT
  OGLM_CHECK_ERR(glPolygonStipple, )
  glPolygonStipple(mask);
  OGLM_CHECK_ERR(glPolygonStipple, )

void
glPopAttrib()
CODE:
  OGLM_GLEWINIT
  OGLM_CHECK_ERR(glPopAttrib, )
  glPopAttrib();
  OGLM_CHECK_ERR(glPopAttrib, )

void
glPopClientAttrib()
CODE:
  OGLM_GLEWINIT
  OGLM_CHECK_ERR(glPopClientAttrib, )
  glPopClientAttrib();
  OGLM_CHECK_ERR(glPopClientAttrib, )

void
glPopDebugGroup()
ALIAS:
  glPopDebugGroupKHR = 1
CODE:
  OGLM_GLEWINIT
  OGLM_CHECK_ERR(glPopDebugGroup, )
  OGLM_AVAIL_CHECK(__glewPopDebugGroup, glPopDebugGroup)
  glPopDebugGroup();
  OGLM_CHECK_ERR(glPopDebugGroup, )

void
glPopGroupMarkerEXT()
CODE:
  OGLM_GLEWINIT
  OGLM_CHECK_ERR(glPopGroupMarkerEXT, )
  OGLM_AVAIL_CHECK(__glewPopGroupMarkerEXT, glPopGroupMarkerEXT)
  glPopGroupMarkerEXT();
  OGLM_CHECK_ERR(glPopGroupMarkerEXT, )

void
glPopMatrix()
CODE:
  OGLM_GLEWINIT
  OGLM_CHECK_ERR(glPopMatrix, )
  glPopMatrix();
  OGLM_CHECK_ERR(glPopMatrix, )

void
glPopName()
CODE:
  OGLM_GLEWINIT
  OGLM_CHECK_ERR(glPopName, )
  glPopName();
  OGLM_CHECK_ERR(glPopName, )

void
glPresentFrameDualFillNV(video_slot, minPresentTime, beginPresentTimeId, presentDurationId, type, target0, fill0, target1, fill1, target2, fill2, target3, fill3)
  GLuint video_slot;
  GLuint64EXT minPresentTime;
  GLuint beginPresentTimeId;
  GLuint presentDurationId;
  GLenum type;
  GLenum target0;
  GLuint fill0;
  GLenum target1;
  GLuint fill1;
  GLenum target2;
  GLuint fill2;
  GLenum target3;
  GLuint fill3;
CODE:
  OGLM_GLEWINIT
  OGLM_CHECK_ERR(glPresentFrameDualFillNV, )
  OGLM_AVAIL_CHECK(__glewPresentFrameDualFillNV, glPresentFrameDualFillNV)
  glPresentFrameDualFillNV(video_slot, minPresentTime, beginPresentTimeId, presentDurationId, type, target0, fill0, target1, fill1, target2, fill2, target3, fill3);
  OGLM_CHECK_ERR(glPresentFrameDualFillNV, )

void
glPresentFrameKeyedNV(video_slot, minPresentTime, beginPresentTimeId, presentDurationId, type, target0, fill0, key0, target1, fill1, key1)
  GLuint video_slot;
  GLuint64EXT minPresentTime;
  GLuint beginPresentTimeId;
  GLuint presentDurationId;
  GLenum type;
  GLenum target0;
  GLuint fill0;
  GLuint key0;
  GLenum target1;
  GLuint fill1;
  GLuint key1;
CODE:
  OGLM_GLEWINIT
  OGLM_CHECK_ERR(glPresentFrameKeyedNV, )
  OGLM_AVAIL_CHECK(__glewPresentFrameKeyedNV, glPresentFrameKeyedNV)
  glPresentFrameKeyedNV(video_slot, minPresentTime, beginPresentTimeId, presentDurationId, type, target0, fill0, key0, target1, fill1, key1);
  OGLM_CHECK_ERR(glPresentFrameKeyedNV, )

void
glPrimitiveBoundingBoxARB(minX, minY, minZ, minW, maxX, maxY, maxZ, maxW)
  GLfloat minX;
  GLfloat minY;
  GLfloat minZ;
  GLfloat minW;
  GLfloat maxX;
  GLfloat maxY;
  GLfloat maxZ;
  GLfloat maxW;
ALIAS:
  glPrimitiveBoundingBox = 1
  glPrimitiveBoundingBoxEXT = 2
CODE:
  OGLM_GLEWINIT
  OGLM_CHECK_ERR(glPrimitiveBoundingBoxARB, )
  OGLM_AVAIL_CHECK(__glewPrimitiveBoundingBoxARB, glPrimitiveBoundingBoxARB)
  glPrimitiveBoundingBoxARB(minX, minY, minZ, minW, maxX, maxY, maxZ, maxW);
  OGLM_CHECK_ERR(glPrimitiveBoundingBoxARB, )

void
glPrimitiveRestartIndex(buffer)
  GLuint buffer;
CODE:
  OGLM_GLEWINIT
  OGLM_CHECK_ERR(glPrimitiveRestartIndex, )
  OGLM_AVAIL_CHECK(__glewPrimitiveRestartIndex, glPrimitiveRestartIndex)
  glPrimitiveRestartIndex(buffer);
  OGLM_CHECK_ERR(glPrimitiveRestartIndex, )

void
glPrimitiveRestartIndexNV(index)
  GLuint index;
CODE:
  OGLM_GLEWINIT
  OGLM_CHECK_ERR(glPrimitiveRestartIndexNV, )
  OGLM_AVAIL_CHECK(__glewPrimitiveRestartIndexNV, glPrimitiveRestartIndexNV)
  glPrimitiveRestartIndexNV(index);
  OGLM_CHECK_ERR(glPrimitiveRestartIndexNV, )

void
glPrimitiveRestartNV()
CODE:
  OGLM_GLEWINIT
  OGLM_CHECK_ERR(glPrimitiveRestartNV, )
  OGLM_AVAIL_CHECK(__glewPrimitiveRestartNV, glPrimitiveRestartNV)
  glPrimitiveRestartNV();
  OGLM_CHECK_ERR(glPrimitiveRestartNV, )

void
glPrioritizeTextures_c(n, textures, priorities)
  GLsizei n;
  const GLuint *textures;
  const GLclampf *priorities;
ALIAS:
  glPrioritizeTexturesEXT_c = 1
CODE:
  OGLM_GLEWINIT
  OGLM_CHECK_ERR(glPrioritizeTextures, )
  glPrioritizeTextures(n, textures, priorities);
  OGLM_CHECK_ERR(glPrioritizeTextures, )

void
glPrioritizeTextures_p(texturesSV, prioritiesSV)
  SV *texturesSV;
  SV *prioritiesSV;
ALIAS:
  glPrioritizeTexturesEXT_p = 1
CODE:
  OGLM_GLEWINIT
  OGLM_CHECK_ERR(glPrioritizeTextures, )
  GLsizei n = OGLM_LEN_ARRAY(n, textures);
  GLclampf *priorities = OGLM_GET_ARRAY(priorities, GLclampf, NV, n);
  GLuint *textures = OGLM_GET_ARRAY(textures, GLuint, UV, n);
  glPrioritizeTextures((GLsizei )n, (const GLuint *)textures, (const GLclampf *)priorities);
  OGLM_CHECK_ERR(glPrioritizeTextures, free(priorities);free(textures);)
  free(priorities);free(textures);

void
glPrioritizeVertexArraysSGIX_c(n, arrays, priorities)
  GLsizei n;
  const GLuint* arrays;
  const GLclampf* priorities;
CODE:
  OGLM_GLEWINIT
  OGLM_CHECK_ERR(glPrioritizeVertexArraysSGIX, )
  OGLM_AVAIL_CHECK(__glewPrioritizeVertexArraysSGIX, glPrioritizeVertexArraysSGIX)
  glPrioritizeVertexArraysSGIX(n, arrays, priorities);
  OGLM_CHECK_ERR(glPrioritizeVertexArraysSGIX, )

void
glProgramBinary_c(program, binaryFormat, binary, length)
  GLuint program;
  GLenum binaryFormat;
  const void *binary;
  GLsizei length;
CODE:
  OGLM_GLEWINIT
  OGLM_CHECK_ERR(glProgramBinary, )
  OGLM_AVAIL_CHECK(__glewProgramBinary, glProgramBinary)
  glProgramBinary(program, binaryFormat, binary, length);
  OGLM_CHECK_ERR(glProgramBinary, )

void
glProgramBinaryOES_c(program, binaryFormat, binary, length)
  GLuint program;
  GLenum binaryFormat;
  const void *binary;
  GLint length;
CODE:
  OGLM_GLEWINIT
  OGLM_CHECK_ERR(glProgramBinaryOES, )
  OGLM_AVAIL_CHECK(__glewProgramBinaryOES, glProgramBinaryOES)
  glProgramBinaryOES(program, binaryFormat, binary, length);
  OGLM_CHECK_ERR(glProgramBinaryOES, )

void
glProgramBufferParametersIivNV_c(target, bindingIndex, wordIndex, count, params)
  GLenum target;
  GLuint bindingIndex;
  GLuint wordIndex;
  GLsizei count;
  const GLint *params;
CODE:
  OGLM_GLEWINIT
  OGLM_CHECK_ERR(glProgramBufferParametersIivNV, )
  OGLM_AVAIL_CHECK(__glewProgramBufferParametersIivNV, glProgramBufferParametersIivNV)
  glProgramBufferParametersIivNV(target, bindingIndex, wordIndex, count, params);
  OGLM_CHECK_ERR(glProgramBufferParametersIivNV, )

void
glProgramBufferParametersIivNV_p(target, bindingIndex, wordIndex, ...)
  GLenum target;
  GLuint bindingIndex;
  GLuint wordIndex;
CODE:
  OGLM_GLEWINIT
  OGLM_CHECK_ERR(glProgramBufferParametersIivNV, )
  OGLM_AVAIL_CHECK(__glewProgramBufferParametersIivNV, glProgramBufferParametersIivNV)
  GLsizei count = items-3;
  GLint *params = OGLM_GET_VARARGS(params,3,GLint,IV,count);
  glProgramBufferParametersIivNV((GLenum )target, (GLuint )bindingIndex, (GLuint )wordIndex, (GLsizei )count, (const GLint *)params);
  OGLM_CHECK_ERR(glProgramBufferParametersIivNV, free(params);)
  free(params);

void
glProgramBufferParametersIuivNV_c(target, bindingIndex, wordIndex, count, params)
  GLenum target;
  GLuint bindingIndex;
  GLuint wordIndex;
  GLsizei count;
  const GLuint *params;
CODE:
  OGLM_GLEWINIT
  OGLM_CHECK_ERR(glProgramBufferParametersIuivNV, )
  OGLM_AVAIL_CHECK(__glewProgramBufferParametersIuivNV, glProgramBufferParametersIuivNV)
  glProgramBufferParametersIuivNV(target, bindingIndex, wordIndex, count, params);
  OGLM_CHECK_ERR(glProgramBufferParametersIuivNV, )

void
glProgramBufferParametersIuivNV_p(target, bindingIndex, wordIndex, ...)
  GLenum target;
  GLuint bindingIndex;
  GLuint wordIndex;
CODE:
  OGLM_GLEWINIT
  OGLM_CHECK_ERR(glProgramBufferParametersIuivNV, )
  OGLM_AVAIL_CHECK(__glewProgramBufferParametersIuivNV, glProgramBufferParametersIuivNV)
  GLsizei count = items-3;
  GLuint *params = OGLM_GET_VARARGS(params,3,GLuint,UV,count);
  glProgramBufferParametersIuivNV((GLenum )target, (GLuint )bindingIndex, (GLuint )wordIndex, (GLsizei )count, (const GLuint *)params);
  OGLM_CHECK_ERR(glProgramBufferParametersIuivNV, free(params);)
  free(params);

void
glProgramBufferParametersfvNV_c(target, bindingIndex, wordIndex, count, params)
  GLenum target;
  GLuint bindingIndex;
  GLuint wordIndex;
  GLsizei count;
  const GLfloat *params;
CODE:
  OGLM_GLEWINIT
  OGLM_CHECK_ERR(glProgramBufferParametersfvNV, )
  OGLM_AVAIL_CHECK(__glewProgramBufferParametersfvNV, glProgramBufferParametersfvNV)
  glProgramBufferParametersfvNV(target, bindingIndex, wordIndex, count, params);
  OGLM_CHECK_ERR(glProgramBufferParametersfvNV, )

void
glProgramBufferParametersfvNV_p(target, bindingIndex, wordIndex, ...)
  GLenum target;
  GLuint bindingIndex;
  GLuint wordIndex;
CODE:
  OGLM_GLEWINIT
  OGLM_CHECK_ERR(glProgramBufferParametersfvNV, )
  OGLM_AVAIL_CHECK(__glewProgramBufferParametersfvNV, glProgramBufferParametersfvNV)
  GLsizei count = items-3;
  GLfloat *params = OGLM_GET_VARARGS(params,3,GLfloat,NV,count);
  glProgramBufferParametersfvNV((GLenum )target, (GLuint )bindingIndex, (GLuint )wordIndex, (GLsizei )count, (const GLfloat *)params);
  OGLM_CHECK_ERR(glProgramBufferParametersfvNV, free(params);)
  free(params);

void
glProgramEnvParameter4dARB(target, index, x, y, z, w)
  GLenum target;
  GLuint index;
  GLdouble x;
  GLdouble y;
  GLdouble z;
  GLdouble w;
CODE:
  OGLM_GLEWINIT
  OGLM_CHECK_ERR(glProgramEnvParameter4dARB, )
  OGLM_AVAIL_CHECK(__glewProgramEnvParameter4dARB, glProgramEnvParameter4dARB)
  glProgramEnvParameter4dARB(target, index, x, y, z, w);
  OGLM_CHECK_ERR(glProgramEnvParameter4dARB, )

void
glProgramEnvParameter4dvARB_c(target, index, params)
  GLenum target;
  GLuint index;
  const GLdouble* params;
CODE:
  OGLM_GLEWINIT
  OGLM_CHECK_ERR(glProgramEnvParameter4dvARB, )
  OGLM_AVAIL_CHECK(__glewProgramEnvParameter4dvARB, glProgramEnvParameter4dvARB)
  glProgramEnvParameter4dvARB(target, index, params);
  OGLM_CHECK_ERR(glProgramEnvParameter4dvARB, )

void
glProgramEnvParameter4dvARB_p(target, index, ...)
  GLenum target;
  GLuint index;
CODE:
  OGLM_GLEWINIT
  OGLM_CHECK_ERR(glProgramEnvParameter4dvARB, )
  OGLM_AVAIL_CHECK(__glewProgramEnvParameter4dvARB, glProgramEnvParameter4dvARB)
  GLdouble* params = OGLM_GET_VARARGS(params,2,GLdouble,NV,4);
  glProgramEnvParameter4dvARB((GLenum )target, (GLuint )index, (const GLdouble* )params);
  OGLM_CHECK_ERR(glProgramEnvParameter4dvARB, free(params);)
  free(params);

void
glProgramEnvParameter4fARB(target, index, x, y, z, w)
  GLenum target;
  GLuint index;
  GLfloat x;
  GLfloat y;
  GLfloat z;
  GLfloat w;
CODE:
  OGLM_GLEWINIT
  OGLM_CHECK_ERR(glProgramEnvParameter4fARB, )
  OGLM_AVAIL_CHECK(__glewProgramEnvParameter4fARB, glProgramEnvParameter4fARB)
  glProgramEnvParameter4fARB(target, index, x, y, z, w);
  OGLM_CHECK_ERR(glProgramEnvParameter4fARB, )

void
glProgramEnvParameter4fvARB_c(target, index, params)
  GLenum target;
  GLuint index;
  const GLfloat* params;
CODE:
  OGLM_GLEWINIT
  OGLM_CHECK_ERR(glProgramEnvParameter4fvARB, )
  OGLM_AVAIL_CHECK(__glewProgramEnvParameter4fvARB, glProgramEnvParameter4fvARB)
  glProgramEnvParameter4fvARB(target, index, params);
  OGLM_CHECK_ERR(glProgramEnvParameter4fvARB, )

void
glProgramEnvParameter4fvARB_p(target, index, ...)
  GLenum target;
  GLuint index;
CODE:
  OGLM_GLEWINIT
  OGLM_CHECK_ERR(glProgramEnvParameter4fvARB, )
  OGLM_AVAIL_CHECK(__glewProgramEnvParameter4fvARB, glProgramEnvParameter4fvARB)
  GLfloat* params = OGLM_GET_VARARGS(params,2,GLfloat,NV,4);
  glProgramEnvParameter4fvARB((GLenum )target, (GLuint )index, (const GLfloat* )params);
  OGLM_CHECK_ERR(glProgramEnvParameter4fvARB, free(params);)
  free(params);

void
glProgramEnvParameterI4iNV(target, index, x, y, z, w)
  GLenum target;
  GLuint index;
  GLint x;
  GLint y;
  GLint z;
  GLint w;
CODE:
  OGLM_GLEWINIT
  OGLM_CHECK_ERR(glProgramEnvParameterI4iNV, )
  OGLM_AVAIL_CHECK(__glewProgramEnvParameterI4iNV, glProgramEnvParameterI4iNV)
  glProgramEnvParameterI4iNV(target, index, x, y, z, w);
  OGLM_CHECK_ERR(glProgramEnvParameterI4iNV, )

void
glProgramEnvParameterI4ivNV_c(target, index, params)
  GLenum target;
  GLuint index;
  const GLint *params;
CODE:
  OGLM_GLEWINIT
  OGLM_CHECK_ERR(glProgramEnvParameterI4ivNV, )
  OGLM_AVAIL_CHECK(__glewProgramEnvParameterI4ivNV, glProgramEnvParameterI4ivNV)
  glProgramEnvParameterI4ivNV(target, index, params);
  OGLM_CHECK_ERR(glProgramEnvParameterI4ivNV, )

void
glProgramEnvParameterI4ivNV_p(target, index, ...)
  GLenum target;
  GLuint index;
CODE:
  OGLM_GLEWINIT
  OGLM_CHECK_ERR(glProgramEnvParameterI4ivNV, )
  OGLM_AVAIL_CHECK(__glewProgramEnvParameterI4ivNV, glProgramEnvParameterI4ivNV)
  GLint *params = OGLM_GET_VARARGS(params,2,GLint,IV,4);
  glProgramEnvParameterI4ivNV((GLenum )target, (GLuint )index, (const GLint *)params);
  OGLM_CHECK_ERR(glProgramEnvParameterI4ivNV, free(params);)
  free(params);

void
glProgramEnvParameterI4uiNV(target, index, x, y, z, w)
  GLenum target;
  GLuint index;
  GLuint x;
  GLuint y;
  GLuint z;
  GLuint w;
CODE:
  OGLM_GLEWINIT
  OGLM_CHECK_ERR(glProgramEnvParameterI4uiNV, )
  OGLM_AVAIL_CHECK(__glewProgramEnvParameterI4uiNV, glProgramEnvParameterI4uiNV)
  glProgramEnvParameterI4uiNV(target, index, x, y, z, w);
  OGLM_CHECK_ERR(glProgramEnvParameterI4uiNV, )

void
glProgramEnvParameterI4uivNV_c(target, index, params)
  GLenum target;
  GLuint index;
  const GLuint *params;
CODE:
  OGLM_GLEWINIT
  OGLM_CHECK_ERR(glProgramEnvParameterI4uivNV, )
  OGLM_AVAIL_CHECK(__glewProgramEnvParameterI4uivNV, glProgramEnvParameterI4uivNV)
  glProgramEnvParameterI4uivNV(target, index, params);
  OGLM_CHECK_ERR(glProgramEnvParameterI4uivNV, )

void
glProgramEnvParameterI4uivNV_p(target, index, ...)
  GLenum target;
  GLuint index;
CODE:
  OGLM_GLEWINIT
  OGLM_CHECK_ERR(glProgramEnvParameterI4uivNV, )
  OGLM_AVAIL_CHECK(__glewProgramEnvParameterI4uivNV, glProgramEnvParameterI4uivNV)
  GLuint *params = OGLM_GET_VARARGS(params,2,GLuint,UV,4);
  glProgramEnvParameterI4uivNV((GLenum )target, (GLuint )index, (const GLuint *)params);
  OGLM_CHECK_ERR(glProgramEnvParameterI4uivNV, free(params);)
  free(params);

void
glProgramEnvParameters4fvEXT_c(target, index, count, params)
  GLenum target;
  GLuint index;
  GLsizei count;
  const GLfloat* params;
CODE:
  OGLM_GLEWINIT
  OGLM_CHECK_ERR(glProgramEnvParameters4fvEXT, )
  OGLM_AVAIL_CHECK(__glewProgramEnvParameters4fvEXT, glProgramEnvParameters4fvEXT)
  glProgramEnvParameters4fvEXT(target, index, count, params);
  OGLM_CHECK_ERR(glProgramEnvParameters4fvEXT, )

void
glProgramEnvParameters4fvEXT_p(target, index, count, ...)
  GLenum target;
  GLuint index;
  GLsizei count;
CODE:
  OGLM_GLEWINIT
  OGLM_CHECK_ERR(glProgramEnvParameters4fvEXT, )
  OGLM_AVAIL_CHECK(__glewProgramEnvParameters4fvEXT, glProgramEnvParameters4fvEXT)
  GLfloat* params = OGLM_GET_VARARGS(params,3,GLfloat,NV,count*4);
  glProgramEnvParameters4fvEXT((GLenum )target, (GLuint )index, (GLsizei )count, (const GLfloat* )params);
  OGLM_CHECK_ERR(glProgramEnvParameters4fvEXT, free(params);)
  free(params);

void
glProgramEnvParametersI4ivNV_c(target, index, count, params)
  GLenum target;
  GLuint index;
  GLsizei count;
  const GLint *params;
CODE:
  OGLM_GLEWINIT
  OGLM_CHECK_ERR(glProgramEnvParametersI4ivNV, )
  OGLM_AVAIL_CHECK(__glewProgramEnvParametersI4ivNV, glProgramEnvParametersI4ivNV)
  glProgramEnvParametersI4ivNV(target, index, count, params);
  OGLM_CHECK_ERR(glProgramEnvParametersI4ivNV, )

void
glProgramEnvParametersI4ivNV_p(target, index, count, ...)
  GLenum target;
  GLuint index;
  GLsizei count;
CODE:
  OGLM_GLEWINIT
  OGLM_CHECK_ERR(glProgramEnvParametersI4ivNV, )
  OGLM_AVAIL_CHECK(__glewProgramEnvParametersI4ivNV, glProgramEnvParametersI4ivNV)
  GLint *params = OGLM_GET_VARARGS(params,3,GLint,IV,count*4);
  glProgramEnvParametersI4ivNV((GLenum )target, (GLuint )index, (GLsizei )count, (const GLint *)params);
  OGLM_CHECK_ERR(glProgramEnvParametersI4ivNV, free(params);)
  free(params);

void
glProgramEnvParametersI4uivNV_c(target, index, count, params)
  GLenum target;
  GLuint index;
  GLsizei count;
  const GLuint *params;
CODE:
  OGLM_GLEWINIT
  OGLM_CHECK_ERR(glProgramEnvParametersI4uivNV, )
  OGLM_AVAIL_CHECK(__glewProgramEnvParametersI4uivNV, glProgramEnvParametersI4uivNV)
  glProgramEnvParametersI4uivNV(target, index, count, params);
  OGLM_CHECK_ERR(glProgramEnvParametersI4uivNV, )

void
glProgramEnvParametersI4uivNV_p(target, index, count, ...)
  GLenum target;
  GLuint index;
  GLsizei count;
CODE:
  OGLM_GLEWINIT
  OGLM_CHECK_ERR(glProgramEnvParametersI4uivNV, )
  OGLM_AVAIL_CHECK(__glewProgramEnvParametersI4uivNV, glProgramEnvParametersI4uivNV)
  GLuint *params = OGLM_GET_VARARGS(params,3,GLuint,UV,count*4);
  glProgramEnvParametersI4uivNV((GLenum )target, (GLuint )index, (GLsizei )count, (const GLuint *)params);
  OGLM_CHECK_ERR(glProgramEnvParametersI4uivNV, free(params);)
  free(params);

void
glProgramLocalParameter4dARB(target, index, x, y, z, w)
  GLenum target;
  GLuint index;
  GLdouble x;
  GLdouble y;
  GLdouble z;
  GLdouble w;
CODE:
  OGLM_GLEWINIT
  OGLM_CHECK_ERR(glProgramLocalParameter4dARB, )
  OGLM_AVAIL_CHECK(__glewProgramLocalParameter4dARB, glProgramLocalParameter4dARB)
  glProgramLocalParameter4dARB(target, index, x, y, z, w);
  OGLM_CHECK_ERR(glProgramLocalParameter4dARB, )

void
glProgramLocalParameter4dvARB_c(target, index, params)
  GLenum target;
  GLuint index;
  const GLdouble* params;
CODE:
  OGLM_GLEWINIT
  OGLM_CHECK_ERR(glProgramLocalParameter4dvARB, )
  OGLM_AVAIL_CHECK(__glewProgramLocalParameter4dvARB, glProgramLocalParameter4dvARB)
  glProgramLocalParameter4dvARB(target, index, params);
  OGLM_CHECK_ERR(glProgramLocalParameter4dvARB, )

void
glProgramLocalParameter4dvARB_p(target, index, ...)
  GLenum target;
  GLuint index;
CODE:
  OGLM_GLEWINIT
  OGLM_CHECK_ERR(glProgramLocalParameter4dvARB, )
  OGLM_AVAIL_CHECK(__glewProgramLocalParameter4dvARB, glProgramLocalParameter4dvARB)
  GLdouble* params = OGLM_GET_VARARGS(params,2,GLdouble,NV,4);
  glProgramLocalParameter4dvARB((GLenum )target, (GLuint )index, (const GLdouble* )params);
  OGLM_CHECK_ERR(glProgramLocalParameter4dvARB, free(params);)
  free(params);

void
glProgramLocalParameter4fARB(target, index, x, y, z, w)
  GLenum target;
  GLuint index;
  GLfloat x;
  GLfloat y;
  GLfloat z;
  GLfloat w;
CODE:
  OGLM_GLEWINIT
  OGLM_CHECK_ERR(glProgramLocalParameter4fARB, )
  OGLM_AVAIL_CHECK(__glewProgramLocalParameter4fARB, glProgramLocalParameter4fARB)
  glProgramLocalParameter4fARB(target, index, x, y, z, w);
  OGLM_CHECK_ERR(glProgramLocalParameter4fARB, )

void
glProgramLocalParameter4fvARB_c(target, index, params)
  GLenum target;
  GLuint index;
  const GLfloat* params;
CODE:
  OGLM_GLEWINIT
  OGLM_CHECK_ERR(glProgramLocalParameter4fvARB, )
  OGLM_AVAIL_CHECK(__glewProgramLocalParameter4fvARB, glProgramLocalParameter4fvARB)
  glProgramLocalParameter4fvARB(target, index, params);
  OGLM_CHECK_ERR(glProgramLocalParameter4fvARB, )

void
glProgramLocalParameter4fvARB_p(target, index, ...)
  GLenum target;
  GLuint index;
CODE:
  OGLM_GLEWINIT
  OGLM_CHECK_ERR(glProgramLocalParameter4fvARB, )
  OGLM_AVAIL_CHECK(__glewProgramLocalParameter4fvARB, glProgramLocalParameter4fvARB)
  GLfloat* params = OGLM_GET_VARARGS(params,2,GLfloat,NV,4);
  glProgramLocalParameter4fvARB((GLenum )target, (GLuint )index, (const GLfloat* )params);
  OGLM_CHECK_ERR(glProgramLocalParameter4fvARB, free(params);)
  free(params);

void
glProgramLocalParameterI4iNV(target, index, x, y, z, w)
  GLenum target;
  GLuint index;
  GLint x;
  GLint y;
  GLint z;
  GLint w;
CODE:
  OGLM_GLEWINIT
  OGLM_CHECK_ERR(glProgramLocalParameterI4iNV, )
  OGLM_AVAIL_CHECK(__glewProgramLocalParameterI4iNV, glProgramLocalParameterI4iNV)
  glProgramLocalParameterI4iNV(target, index, x, y, z, w);
  OGLM_CHECK_ERR(glProgramLocalParameterI4iNV, )

void
glProgramLocalParameterI4ivNV_c(target, index, params)
  GLenum target;
  GLuint index;
  const GLint *params;
CODE:
  OGLM_GLEWINIT
  OGLM_CHECK_ERR(glProgramLocalParameterI4ivNV, )
  OGLM_AVAIL_CHECK(__glewProgramLocalParameterI4ivNV, glProgramLocalParameterI4ivNV)
  glProgramLocalParameterI4ivNV(target, index, params);
  OGLM_CHECK_ERR(glProgramLocalParameterI4ivNV, )

void
glProgramLocalParameterI4ivNV_p(target, index, ...)
  GLenum target;
  GLuint index;
CODE:
  OGLM_GLEWINIT
  OGLM_CHECK_ERR(glProgramLocalParameterI4ivNV, )
  OGLM_AVAIL_CHECK(__glewProgramLocalParameterI4ivNV, glProgramLocalParameterI4ivNV)
  GLint *params = OGLM_GET_VARARGS(params,2,GLint,IV,4);
  glProgramLocalParameterI4ivNV((GLenum )target, (GLuint )index, (const GLint *)params);
  OGLM_CHECK_ERR(glProgramLocalParameterI4ivNV, free(params);)
  free(params);

void
glProgramLocalParameterI4uiNV(target, index, x, y, z, w)
  GLenum target;
  GLuint index;
  GLuint x;
  GLuint y;
  GLuint z;
  GLuint w;
CODE:
  OGLM_GLEWINIT
  OGLM_CHECK_ERR(glProgramLocalParameterI4uiNV, )
  OGLM_AVAIL_CHECK(__glewProgramLocalParameterI4uiNV, glProgramLocalParameterI4uiNV)
  glProgramLocalParameterI4uiNV(target, index, x, y, z, w);
  OGLM_CHECK_ERR(glProgramLocalParameterI4uiNV, )

void
glProgramLocalParameterI4uivNV_c(target, index, params)
  GLenum target;
  GLuint index;
  const GLuint *params;
CODE:
  OGLM_GLEWINIT
  OGLM_CHECK_ERR(glProgramLocalParameterI4uivNV, )
  OGLM_AVAIL_CHECK(__glewProgramLocalParameterI4uivNV, glProgramLocalParameterI4uivNV)
  glProgramLocalParameterI4uivNV(target, index, params);
  OGLM_CHECK_ERR(glProgramLocalParameterI4uivNV, )

void
glProgramLocalParameterI4uivNV_p(target, index, ...)
  GLenum target;
  GLuint index;
CODE:
  OGLM_GLEWINIT
  OGLM_CHECK_ERR(glProgramLocalParameterI4uivNV, )
  OGLM_AVAIL_CHECK(__glewProgramLocalParameterI4uivNV, glProgramLocalParameterI4uivNV)
  GLuint *params = OGLM_GET_VARARGS(params,2,GLuint,UV,4);
  glProgramLocalParameterI4uivNV((GLenum )target, (GLuint )index, (const GLuint *)params);
  OGLM_CHECK_ERR(glProgramLocalParameterI4uivNV, free(params);)
  free(params);

void
glProgramLocalParameters4fvEXT_c(target, index, count, params)
  GLenum target;
  GLuint index;
  GLsizei count;
  const GLfloat* params;
CODE:
  OGLM_GLEWINIT
  OGLM_CHECK_ERR(glProgramLocalParameters4fvEXT, )
  OGLM_AVAIL_CHECK(__glewProgramLocalParameters4fvEXT, glProgramLocalParameters4fvEXT)
  glProgramLocalParameters4fvEXT(target, index, count, params);
  OGLM_CHECK_ERR(glProgramLocalParameters4fvEXT, )

void
glProgramLocalParameters4fvEXT_p(target, index, count, ...)
  GLenum target;
  GLuint index;
  GLsizei count;
CODE:
  OGLM_GLEWINIT
  OGLM_CHECK_ERR(glProgramLocalParameters4fvEXT, )
  OGLM_AVAIL_CHECK(__glewProgramLocalParameters4fvEXT, glProgramLocalParameters4fvEXT)
  GLfloat* params = OGLM_GET_VARARGS(params,3,GLfloat,NV,count*4);
  glProgramLocalParameters4fvEXT((GLenum )target, (GLuint )index, (GLsizei )count, (const GLfloat* )params);
  OGLM_CHECK_ERR(glProgramLocalParameters4fvEXT, free(params);)
  free(params);

void
glProgramLocalParametersI4ivNV_c(target, index, count, params)
  GLenum target;
  GLuint index;
  GLsizei count;
  const GLint *params;
CODE:
  OGLM_GLEWINIT
  OGLM_CHECK_ERR(glProgramLocalParametersI4ivNV, )
  OGLM_AVAIL_CHECK(__glewProgramLocalParametersI4ivNV, glProgramLocalParametersI4ivNV)
  glProgramLocalParametersI4ivNV(target, index, count, params);
  OGLM_CHECK_ERR(glProgramLocalParametersI4ivNV, )

void
glProgramLocalParametersI4ivNV_p(target, index, count, ...)
  GLenum target;
  GLuint index;
  GLsizei count;
CODE:
  OGLM_GLEWINIT
  OGLM_CHECK_ERR(glProgramLocalParametersI4ivNV, )
  OGLM_AVAIL_CHECK(__glewProgramLocalParametersI4ivNV, glProgramLocalParametersI4ivNV)
  GLint *params = OGLM_GET_VARARGS(params,3,GLint,IV,count*4);
  glProgramLocalParametersI4ivNV((GLenum )target, (GLuint )index, (GLsizei )count, (const GLint *)params);
  OGLM_CHECK_ERR(glProgramLocalParametersI4ivNV, free(params);)
  free(params);

void
glProgramLocalParametersI4uivNV_c(target, index, count, params)
  GLenum target;
  GLuint index;
  GLsizei count;
  const GLuint *params;
CODE:
  OGLM_GLEWINIT
  OGLM_CHECK_ERR(glProgramLocalParametersI4uivNV, )
  OGLM_AVAIL_CHECK(__glewProgramLocalParametersI4uivNV, glProgramLocalParametersI4uivNV)
  glProgramLocalParametersI4uivNV(target, index, count, params);
  OGLM_CHECK_ERR(glProgramLocalParametersI4uivNV, )

void
glProgramLocalParametersI4uivNV_p(target, index, count, ...)
  GLenum target;
  GLuint index;
  GLsizei count;
CODE:
  OGLM_GLEWINIT
  OGLM_CHECK_ERR(glProgramLocalParametersI4uivNV, )
  OGLM_AVAIL_CHECK(__glewProgramLocalParametersI4uivNV, glProgramLocalParametersI4uivNV)
  GLuint *params = OGLM_GET_VARARGS(params,3,GLuint,UV,count*4);
  glProgramLocalParametersI4uivNV((GLenum )target, (GLuint )index, (GLsizei )count, (const GLuint *)params);
  OGLM_CHECK_ERR(glProgramLocalParametersI4uivNV, free(params);)
  free(params);

void
glProgramNamedParameter4dNV(id, len, name, x, y, z, w)
  GLuint id;
  GLsizei len;
  const GLubyte* name;
  GLdouble x;
  GLdouble y;
  GLdouble z;
  GLdouble w;
CODE:
  OGLM_GLEWINIT
  OGLM_CHECK_ERR(glProgramNamedParameter4dNV, )
  OGLM_AVAIL_CHECK(__glewProgramNamedParameter4dNV, glProgramNamedParameter4dNV)
  glProgramNamedParameter4dNV(id, len, name, x, y, z, w);
  OGLM_CHECK_ERR(glProgramNamedParameter4dNV, )

void
glProgramNamedParameter4dvNV_c(id, len, name, v)
  GLuint id;
  GLsizei len;
  const GLubyte* name;
  const GLdouble * v;
CODE:
  OGLM_GLEWINIT
  OGLM_CHECK_ERR(glProgramNamedParameter4dvNV, )
  OGLM_AVAIL_CHECK(__glewProgramNamedParameter4dvNV, glProgramNamedParameter4dvNV)
  glProgramNamedParameter4dvNV(id, len, name, v);
  OGLM_CHECK_ERR(glProgramNamedParameter4dvNV, )

void
glProgramNamedParameter4dvNV_p(id, len, name, ...)
  GLuint id;
  GLsizei len;
  const GLubyte* name;
CODE:
  OGLM_GLEWINIT
  OGLM_CHECK_ERR(glProgramNamedParameter4dvNV, )
  OGLM_AVAIL_CHECK(__glewProgramNamedParameter4dvNV, glProgramNamedParameter4dvNV)
  GLdouble * v = OGLM_GET_VARARGS(v,3,GLdouble,NV,4);
  glProgramNamedParameter4dvNV((GLuint )id, (GLsizei )len, (const GLubyte* )name, (const GLdouble * )v);
  OGLM_CHECK_ERR(glProgramNamedParameter4dvNV, free(v);)
  free(v);

void
glProgramNamedParameter4fNV(id, len, name, x, y, z, w)
  GLuint id;
  GLsizei len;
  const GLubyte* name;
  GLfloat x;
  GLfloat y;
  GLfloat z;
  GLfloat w;
CODE:
  OGLM_GLEWINIT
  OGLM_CHECK_ERR(glProgramNamedParameter4fNV, )
  OGLM_AVAIL_CHECK(__glewProgramNamedParameter4fNV, glProgramNamedParameter4fNV)
  glProgramNamedParameter4fNV(id, len, name, x, y, z, w);
  OGLM_CHECK_ERR(glProgramNamedParameter4fNV, )

void
glProgramNamedParameter4fvNV_c(id, len, name, v)
  GLuint id;
  GLsizei len;
  const GLubyte* name;
  const GLfloat * v;
CODE:
  OGLM_GLEWINIT
  OGLM_CHECK_ERR(glProgramNamedParameter4fvNV, )
  OGLM_AVAIL_CHECK(__glewProgramNamedParameter4fvNV, glProgramNamedParameter4fvNV)
  glProgramNamedParameter4fvNV(id, len, name, v);
  OGLM_CHECK_ERR(glProgramNamedParameter4fvNV, )

void
glProgramNamedParameter4fvNV_p(id, len, name, ...)
  GLuint id;
  GLsizei len;
  const GLubyte* name;
CODE:
  OGLM_GLEWINIT
  OGLM_CHECK_ERR(glProgramNamedParameter4fvNV, )
  OGLM_AVAIL_CHECK(__glewProgramNamedParameter4fvNV, glProgramNamedParameter4fvNV)
  GLfloat * v = OGLM_GET_VARARGS(v,3,GLfloat,NV,4);
  glProgramNamedParameter4fvNV((GLuint )id, (GLsizei )len, (const GLubyte* )name, (const GLfloat * )v);
  OGLM_CHECK_ERR(glProgramNamedParameter4fvNV, free(v);)
  free(v);

void
glProgramParameter4dNV(target, index, x, y, z, w)
  GLenum target;
  GLuint index;
  GLdouble x;
  GLdouble y;
  GLdouble z;
  GLdouble w;
CODE:
  OGLM_GLEWINIT
  OGLM_CHECK_ERR(glProgramParameter4dNV, )
  OGLM_AVAIL_CHECK(__glewProgramParameter4dNV, glProgramParameter4dNV)
  glProgramParameter4dNV(target, index, x, y, z, w);
  OGLM_CHECK_ERR(glProgramParameter4dNV, )

void
glProgramParameter4dvNV_c(target, index, v)
  GLenum target;
  GLuint index;
  const GLdouble* v;
CODE:
  OGLM_GLEWINIT
  OGLM_CHECK_ERR(glProgramParameter4dvNV, )
  OGLM_AVAIL_CHECK(__glewProgramParameter4dvNV, glProgramParameter4dvNV)
  glProgramParameter4dvNV(target, index, v);
  OGLM_CHECK_ERR(glProgramParameter4dvNV, )

void
glProgramParameter4dvNV_p(target, index, ...)
  GLenum target;
  GLuint index;
CODE:
  OGLM_GLEWINIT
  OGLM_CHECK_ERR(glProgramParameter4dvNV, )
  OGLM_AVAIL_CHECK(__glewProgramParameter4dvNV, glProgramParameter4dvNV)
  GLdouble* v = OGLM_GET_VARARGS(v,2,GLdouble,NV,4);
  glProgramParameter4dvNV((GLenum )target, (GLuint )index, (const GLdouble* )v);
  OGLM_CHECK_ERR(glProgramParameter4dvNV, free(v);)
  free(v);

void
glProgramParameter4fNV(target, index, x, y, z, w)
  GLenum target;
  GLuint index;
  GLfloat x;
  GLfloat y;
  GLfloat z;
  GLfloat w;
CODE:
  OGLM_GLEWINIT
  OGLM_CHECK_ERR(glProgramParameter4fNV, )
  OGLM_AVAIL_CHECK(__glewProgramParameter4fNV, glProgramParameter4fNV)
  glProgramParameter4fNV(target, index, x, y, z, w);
  OGLM_CHECK_ERR(glProgramParameter4fNV, )

void
glProgramParameter4fvNV_c(target, index, v)
  GLenum target;
  GLuint index;
  const GLfloat* v;
CODE:
  OGLM_GLEWINIT
  OGLM_CHECK_ERR(glProgramParameter4fvNV, )
  OGLM_AVAIL_CHECK(__glewProgramParameter4fvNV, glProgramParameter4fvNV)
  glProgramParameter4fvNV(target, index, v);
  OGLM_CHECK_ERR(glProgramParameter4fvNV, )

void
glProgramParameter4fvNV_p(target, index, ...)
  GLenum target;
  GLuint index;
CODE:
  OGLM_GLEWINIT
  OGLM_CHECK_ERR(glProgramParameter4fvNV, )
  OGLM_AVAIL_CHECK(__glewProgramParameter4fvNV, glProgramParameter4fvNV)
  GLfloat* v = OGLM_GET_VARARGS(v,2,GLfloat,NV,4);
  glProgramParameter4fvNV((GLenum )target, (GLuint )index, (const GLfloat* )v);
  OGLM_CHECK_ERR(glProgramParameter4fvNV, free(v);)
  free(v);

void
glProgramParameteri(program, pname, value)
  GLuint program;
  GLenum pname;
  GLint value;
ALIAS:
  glProgramParameteriARB = 1
  glProgramParameteriEXT = 2
CODE:
  OGLM_GLEWINIT
  OGLM_CHECK_ERR(glProgramParameteri, )
  OGLM_AVAIL_CHECK(__glewProgramParameteri, glProgramParameteri)
  glProgramParameteri(program, pname, value);
  OGLM_CHECK_ERR(glProgramParameteri, )

void
glProgramParameters4dvNV_c(target, index, count, v)
  GLenum target;
  GLuint index;
  GLsizei count;
  const GLdouble* v;
CODE:
  OGLM_GLEWINIT
  OGLM_CHECK_ERR(glProgramParameters4dvNV, )
  OGLM_AVAIL_CHECK(__glewProgramParameters4dvNV, glProgramParameters4dvNV)
  glProgramParameters4dvNV(target, index, count, v);
  OGLM_CHECK_ERR(glProgramParameters4dvNV, )

void
glProgramParameters4dvNV_p(target, index, count, ...)
  GLenum target;
  GLuint index;
  GLsizei count;
CODE:
  OGLM_GLEWINIT
  OGLM_CHECK_ERR(glProgramParameters4dvNV, )
  OGLM_AVAIL_CHECK(__glewProgramParameters4dvNV, glProgramParameters4dvNV)
  GLdouble* v = OGLM_GET_VARARGS(v,3,GLdouble,NV,count*4);
  glProgramParameters4dvNV((GLenum )target, (GLuint )index, (GLsizei )count, (const GLdouble* )v);
  OGLM_CHECK_ERR(glProgramParameters4dvNV, free(v);)
  free(v);

void
glProgramParameters4fvNV_c(target, index, count, v)
  GLenum target;
  GLuint index;
  GLsizei count;
  const GLfloat* v;
CODE:
  OGLM_GLEWINIT
  OGLM_CHECK_ERR(glProgramParameters4fvNV, )
  OGLM_AVAIL_CHECK(__glewProgramParameters4fvNV, glProgramParameters4fvNV)
  glProgramParameters4fvNV(target, index, count, v);
  OGLM_CHECK_ERR(glProgramParameters4fvNV, )

void
glProgramParameters4fvNV_p(target, index, count, ...)
  GLenum target;
  GLuint index;
  GLsizei count;
CODE:
  OGLM_GLEWINIT
  OGLM_CHECK_ERR(glProgramParameters4fvNV, )
  OGLM_AVAIL_CHECK(__glewProgramParameters4fvNV, glProgramParameters4fvNV)
  GLfloat* v = OGLM_GET_VARARGS(v,3,GLfloat,NV,count*4);
  glProgramParameters4fvNV((GLenum )target, (GLuint )index, (GLsizei )count, (const GLfloat* )v);
  OGLM_CHECK_ERR(glProgramParameters4fvNV, free(v);)
  free(v);

void
glProgramPathFragmentInputGenNV_c(program, location, genMode, components, coeffs)
  GLuint program;
  GLint location;
  GLenum genMode;
  GLint components;
  const GLfloat* coeffs;
CODE:
  OGLM_GLEWINIT
  OGLM_CHECK_ERR(glProgramPathFragmentInputGenNV, )
  OGLM_AVAIL_CHECK(__glewProgramPathFragmentInputGenNV, glProgramPathFragmentInputGenNV)
  glProgramPathFragmentInputGenNV(program, location, genMode, components, coeffs);
  OGLM_CHECK_ERR(glProgramPathFragmentInputGenNV, )

void
glProgramStringARB_c(target, format, len, string)
  GLenum target;
  GLenum format;
  GLsizei len;
  const void *string;
CODE:
  OGLM_GLEWINIT
  OGLM_CHECK_ERR(glProgramStringARB, )
  OGLM_AVAIL_CHECK(__glewProgramStringARB, glProgramStringARB)
  glProgramStringARB(target, format, len, string);
  OGLM_CHECK_ERR(glProgramStringARB, )

void
glProgramUniform1d(program, location, x)
  GLuint program;
  GLint location;
  GLdouble x;
CODE:
  OGLM_GLEWINIT
  OGLM_CHECK_ERR(glProgramUniform1d, )
  OGLM_AVAIL_CHECK(__glewProgramUniform1d, glProgramUniform1d)
  glProgramUniform1d(program, location, x);
  OGLM_CHECK_ERR(glProgramUniform1d, )

void
glProgramUniform1dv_c(program, location, count, value)
  GLuint program;
  GLint location;
  GLsizei count;
  const GLdouble* value;
CODE:
  OGLM_GLEWINIT
  OGLM_CHECK_ERR(glProgramUniform1dv, )
  OGLM_AVAIL_CHECK(__glewProgramUniform1dv, glProgramUniform1dv)
  glProgramUniform1dv(program, location, count, value);
  OGLM_CHECK_ERR(glProgramUniform1dv, )

void
glProgramUniform1dv_p(program, location, ...)
  GLuint program;
  GLint location;
CODE:
  OGLM_GLEWINIT
  OGLM_CHECK_ERR(glProgramUniform1dv, )
  OGLM_AVAIL_CHECK(__glewProgramUniform1dv, glProgramUniform1dv)
  GLsizei count = items-2;
  GLdouble* value = OGLM_GET_VARARGS(value,2,GLdouble,NV,count);
  glProgramUniform1dv((GLuint )program, (GLint )location, (GLsizei )count, (const GLdouble* )value);
  OGLM_CHECK_ERR(glProgramUniform1dv, free(value);)
  free(value);

void
glProgramUniform1f(program, location, x)
  GLuint program;
  GLint location;
  GLfloat x;
ALIAS:
  glProgramUniform1fEXT = 1
CODE:
  OGLM_GLEWINIT
  OGLM_CHECK_ERR(glProgramUniform1f, )
  OGLM_AVAIL_CHECK(__glewProgramUniform1f, glProgramUniform1f)
  glProgramUniform1f(program, location, x);
  OGLM_CHECK_ERR(glProgramUniform1f, )

void
glProgramUniform1fv_c(program, location, count, value)
  GLuint program;
  GLint location;
  GLsizei count;
  const GLfloat* value;
ALIAS:
  glProgramUniform1fvEXT_c = 1
CODE:
  OGLM_GLEWINIT
  OGLM_CHECK_ERR(glProgramUniform1fv, )
  OGLM_AVAIL_CHECK(__glewProgramUniform1fv, glProgramUniform1fv)
  glProgramUniform1fv(program, location, count, value);
  OGLM_CHECK_ERR(glProgramUniform1fv, )

void
glProgramUniform1fv_p(program, location, ...)
  GLuint program;
  GLint location;
ALIAS:
  glProgramUniform1fvEXT_p = 1
CODE:
  OGLM_GLEWINIT
  OGLM_CHECK_ERR(glProgramUniform1fv, )
  OGLM_AVAIL_CHECK(__glewProgramUniform1fv, glProgramUniform1fv)
  GLsizei count = items-2;
  GLfloat* value = OGLM_GET_VARARGS(value,2,GLfloat,NV,count);
  glProgramUniform1fv((GLuint )program, (GLint )location, (GLsizei )count, (const GLfloat* )value);
  OGLM_CHECK_ERR(glProgramUniform1fv, free(value);)
  free(value);

void
glProgramUniform1i(program, location, x)
  GLuint program;
  GLint location;
  GLint x;
ALIAS:
  glProgramUniform1iEXT = 1
CODE:
  OGLM_GLEWINIT
  OGLM_CHECK_ERR(glProgramUniform1i, )
  OGLM_AVAIL_CHECK(__glewProgramUniform1i, glProgramUniform1i)
  glProgramUniform1i(program, location, x);
  OGLM_CHECK_ERR(glProgramUniform1i, )

void
glProgramUniform1i64ARB(program, location, x)
  GLuint program;
  GLint location;
  GLint64 x;
CODE:
  OGLM_GLEWINIT
  OGLM_CHECK_ERR(glProgramUniform1i64ARB, )
  OGLM_AVAIL_CHECK(__glewProgramUniform1i64ARB, glProgramUniform1i64ARB)
  glProgramUniform1i64ARB(program, location, x);
  OGLM_CHECK_ERR(glProgramUniform1i64ARB, )

void
glProgramUniform1i64NV(program, location, x)
  GLuint program;
  GLint location;
  GLint64EXT x;
CODE:
  OGLM_GLEWINIT
  OGLM_CHECK_ERR(glProgramUniform1i64NV, )
  OGLM_AVAIL_CHECK(__glewProgramUniform1i64NV, glProgramUniform1i64NV)
  glProgramUniform1i64NV(program, location, x);
  OGLM_CHECK_ERR(glProgramUniform1i64NV, )

void
glProgramUniform1i64vARB_c(program, location, count, value)
  GLuint program;
  GLint location;
  GLsizei count;
  const GLint64* value;
CODE:
  OGLM_GLEWINIT
  OGLM_CHECK_ERR(glProgramUniform1i64vARB, )
  OGLM_AVAIL_CHECK(__glewProgramUniform1i64vARB, glProgramUniform1i64vARB)
  glProgramUniform1i64vARB(program, location, count, value);
  OGLM_CHECK_ERR(glProgramUniform1i64vARB, )

void
glProgramUniform1i64vARB_p(program, location, ...)
  GLuint program;
  GLint location;
CODE:
  OGLM_GLEWINIT
  OGLM_CHECK_ERR(glProgramUniform1i64vARB, )
  OGLM_AVAIL_CHECK(__glewProgramUniform1i64vARB, glProgramUniform1i64vARB)
  GLsizei count = items-2;
  GLint64* value = OGLM_GET_VARARGS(value,2,GLint64,IV,count);
  glProgramUniform1i64vARB((GLuint )program, (GLint )location, (GLsizei )count, (const GLint64* )value);
  OGLM_CHECK_ERR(glProgramUniform1i64vARB, free(value);)
  free(value);

void
glProgramUniform1i64vNV_c(program, location, count, value)
  GLuint program;
  GLint location;
  GLsizei count;
  const GLint64EXT* value;
CODE:
  OGLM_GLEWINIT
  OGLM_CHECK_ERR(glProgramUniform1i64vNV, )
  OGLM_AVAIL_CHECK(__glewProgramUniform1i64vNV, glProgramUniform1i64vNV)
  glProgramUniform1i64vNV(program, location, count, value);
  OGLM_CHECK_ERR(glProgramUniform1i64vNV, )

void
glProgramUniform1i64vNV_p(program, location, ...)
  GLuint program;
  GLint location;
CODE:
  OGLM_GLEWINIT
  OGLM_CHECK_ERR(glProgramUniform1i64vNV, )
  OGLM_AVAIL_CHECK(__glewProgramUniform1i64vNV, glProgramUniform1i64vNV)
  GLsizei count = items-2;
  GLint64EXT* value = OGLM_GET_VARARGS(value,2,GLint64EXT,IV,count);
  glProgramUniform1i64vNV((GLuint )program, (GLint )location, (GLsizei )count, (const GLint64EXT* )value);
  OGLM_CHECK_ERR(glProgramUniform1i64vNV, free(value);)
  free(value);

void
glProgramUniform1iv_c(program, location, count, value)
  GLuint program;
  GLint location;
  GLsizei count;
  const GLint* value;
ALIAS:
  glProgramUniform1ivEXT_c = 1
CODE:
  OGLM_GLEWINIT
  OGLM_CHECK_ERR(glProgramUniform1iv, )
  OGLM_AVAIL_CHECK(__glewProgramUniform1iv, glProgramUniform1iv)
  glProgramUniform1iv(program, location, count, value);
  OGLM_CHECK_ERR(glProgramUniform1iv, )

void
glProgramUniform1iv_p(program, location, ...)
  GLuint program;
  GLint location;
ALIAS:
  glProgramUniform1ivEXT_p = 1
CODE:
  OGLM_GLEWINIT
  OGLM_CHECK_ERR(glProgramUniform1iv, )
  OGLM_AVAIL_CHECK(__glewProgramUniform1iv, glProgramUniform1iv)
  GLsizei count = items-2;
  GLint* value = OGLM_GET_VARARGS(value,2,GLint,IV,count);
  glProgramUniform1iv((GLuint )program, (GLint )location, (GLsizei )count, (const GLint* )value);
  OGLM_CHECK_ERR(glProgramUniform1iv, free(value);)
  free(value);

void
glProgramUniform1ui(program, location, x)
  GLuint program;
  GLint location;
  GLuint x;
ALIAS:
  glProgramUniform1uiEXT = 1
CODE:
  OGLM_GLEWINIT
  OGLM_CHECK_ERR(glProgramUniform1ui, )
  OGLM_AVAIL_CHECK(__glewProgramUniform1ui, glProgramUniform1ui)
  glProgramUniform1ui(program, location, x);
  OGLM_CHECK_ERR(glProgramUniform1ui, )

void
glProgramUniform1ui64ARB(program, location, x)
  GLuint program;
  GLint location;
  GLuint64 x;
CODE:
  OGLM_GLEWINIT
  OGLM_CHECK_ERR(glProgramUniform1ui64ARB, )
  OGLM_AVAIL_CHECK(__glewProgramUniform1ui64ARB, glProgramUniform1ui64ARB)
  glProgramUniform1ui64ARB(program, location, x);
  OGLM_CHECK_ERR(glProgramUniform1ui64ARB, )

void
glProgramUniform1ui64NV(program, location, x)
  GLuint program;
  GLint location;
  GLuint64EXT x;
CODE:
  OGLM_GLEWINIT
  OGLM_CHECK_ERR(glProgramUniform1ui64NV, )
  OGLM_AVAIL_CHECK(__glewProgramUniform1ui64NV, glProgramUniform1ui64NV)
  glProgramUniform1ui64NV(program, location, x);
  OGLM_CHECK_ERR(glProgramUniform1ui64NV, )

void
glProgramUniform1ui64vARB_c(program, location, count, value)
  GLuint program;
  GLint location;
  GLsizei count;
  const GLuint64* value;
CODE:
  OGLM_GLEWINIT
  OGLM_CHECK_ERR(glProgramUniform1ui64vARB, )
  OGLM_AVAIL_CHECK(__glewProgramUniform1ui64vARB, glProgramUniform1ui64vARB)
  glProgramUniform1ui64vARB(program, location, count, value);
  OGLM_CHECK_ERR(glProgramUniform1ui64vARB, )

void
glProgramUniform1ui64vARB_p(program, location, ...)
  GLuint program;
  GLint location;
CODE:
  OGLM_GLEWINIT
  OGLM_CHECK_ERR(glProgramUniform1ui64vARB, )
  OGLM_AVAIL_CHECK(__glewProgramUniform1ui64vARB, glProgramUniform1ui64vARB)
  GLsizei count = items-2;
  GLuint64* value = OGLM_GET_VARARGS(value,2,GLuint64,UV,count);
  glProgramUniform1ui64vARB((GLuint )program, (GLint )location, (GLsizei )count, (const GLuint64* )value);
  OGLM_CHECK_ERR(glProgramUniform1ui64vARB, free(value);)
  free(value);

void
glProgramUniform1ui64vNV_c(program, location, count, value)
  GLuint program;
  GLint location;
  GLsizei count;
  const GLuint64EXT* value;
CODE:
  OGLM_GLEWINIT
  OGLM_CHECK_ERR(glProgramUniform1ui64vNV, )
  OGLM_AVAIL_CHECK(__glewProgramUniform1ui64vNV, glProgramUniform1ui64vNV)
  glProgramUniform1ui64vNV(program, location, count, value);
  OGLM_CHECK_ERR(glProgramUniform1ui64vNV, )

void
glProgramUniform1ui64vNV_p(program, location, ...)
  GLuint program;
  GLint location;
CODE:
  OGLM_GLEWINIT
  OGLM_CHECK_ERR(glProgramUniform1ui64vNV, )
  OGLM_AVAIL_CHECK(__glewProgramUniform1ui64vNV, glProgramUniform1ui64vNV)
  GLsizei count = items-2;
  GLuint64EXT* value = OGLM_GET_VARARGS(value,2,GLuint64EXT,UV,count);
  glProgramUniform1ui64vNV((GLuint )program, (GLint )location, (GLsizei )count, (const GLuint64EXT* )value);
  OGLM_CHECK_ERR(glProgramUniform1ui64vNV, free(value);)
  free(value);

void
glProgramUniform1uiv_c(program, location, count, value)
  GLuint program;
  GLint location;
  GLsizei count;
  const GLuint* value;
ALIAS:
  glProgramUniform1uivEXT_c = 1
CODE:
  OGLM_GLEWINIT
  OGLM_CHECK_ERR(glProgramUniform1uiv, )
  OGLM_AVAIL_CHECK(__glewProgramUniform1uiv, glProgramUniform1uiv)
  glProgramUniform1uiv(program, location, count, value);
  OGLM_CHECK_ERR(glProgramUniform1uiv, )

void
glProgramUniform1uiv_p(program, location, ...)
  GLuint program;
  GLint location;
ALIAS:
  glProgramUniform1uivEXT_p = 1
CODE:
  OGLM_GLEWINIT
  OGLM_CHECK_ERR(glProgramUniform1uiv, )
  OGLM_AVAIL_CHECK(__glewProgramUniform1uiv, glProgramUniform1uiv)
  GLsizei count = items-2;
  GLuint* value = OGLM_GET_VARARGS(value,2,GLuint,UV,count);
  glProgramUniform1uiv((GLuint )program, (GLint )location, (GLsizei )count, (const GLuint* )value);
  OGLM_CHECK_ERR(glProgramUniform1uiv, free(value);)
  free(value);

void
glProgramUniform2d(program, location, x, y)
  GLuint program;
  GLint location;
  GLdouble x;
  GLdouble y;
CODE:
  OGLM_GLEWINIT
  OGLM_CHECK_ERR(glProgramUniform2d, )
  OGLM_AVAIL_CHECK(__glewProgramUniform2d, glProgramUniform2d)
  glProgramUniform2d(program, location, x, y);
  OGLM_CHECK_ERR(glProgramUniform2d, )

void
glProgramUniform2dv_c(program, location, count, value)
  GLuint program;
  GLint location;
  GLsizei count;
  const GLdouble* value;
CODE:
  OGLM_GLEWINIT
  OGLM_CHECK_ERR(glProgramUniform2dv, )
  OGLM_AVAIL_CHECK(__glewProgramUniform2dv, glProgramUniform2dv)
  glProgramUniform2dv(program, location, count, value);
  OGLM_CHECK_ERR(glProgramUniform2dv, )

void
glProgramUniform2dv_p(program, location, count, ...)
  GLuint program;
  GLint location;
  GLsizei count;
CODE:
  OGLM_GLEWINIT
  OGLM_CHECK_ERR(glProgramUniform2dv, )
  OGLM_AVAIL_CHECK(__glewProgramUniform2dv, glProgramUniform2dv)
  GLdouble* value = OGLM_GET_VARARGS(value,3,GLdouble,NV,count*2);
  glProgramUniform2dv((GLuint )program, (GLint )location, (GLsizei )count, (const GLdouble* )value);
  OGLM_CHECK_ERR(glProgramUniform2dv, free(value);)
  free(value);

void
glProgramUniform2f(program, location, x, y)
  GLuint program;
  GLint location;
  GLfloat x;
  GLfloat y;
ALIAS:
  glProgramUniform2fEXT = 1
CODE:
  OGLM_GLEWINIT
  OGLM_CHECK_ERR(glProgramUniform2f, )
  OGLM_AVAIL_CHECK(__glewProgramUniform2f, glProgramUniform2f)
  glProgramUniform2f(program, location, x, y);
  OGLM_CHECK_ERR(glProgramUniform2f, )

void
glProgramUniform2fv_c(program, location, count, value)
  GLuint program;
  GLint location;
  GLsizei count;
  const GLfloat* value;
ALIAS:
  glProgramUniform2fvEXT_c = 1
CODE:
  OGLM_GLEWINIT
  OGLM_CHECK_ERR(glProgramUniform2fv, )
  OGLM_AVAIL_CHECK(__glewProgramUniform2fv, glProgramUniform2fv)
  glProgramUniform2fv(program, location, count, value);
  OGLM_CHECK_ERR(glProgramUniform2fv, )

void
glProgramUniform2fv_p(program, location, count, ...)
  GLuint program;
  GLint location;
  GLsizei count;
ALIAS:
  glProgramUniform2fvEXT_p = 1
CODE:
  OGLM_GLEWINIT
  OGLM_CHECK_ERR(glProgramUniform2fv, )
  OGLM_AVAIL_CHECK(__glewProgramUniform2fv, glProgramUniform2fv)
  GLfloat* value = OGLM_GET_VARARGS(value,3,GLfloat,NV,count*2);
  glProgramUniform2fv((GLuint )program, (GLint )location, (GLsizei )count, (const GLfloat* )value);
  OGLM_CHECK_ERR(glProgramUniform2fv, free(value);)
  free(value);

void
glProgramUniform2i(program, location, x, y)
  GLuint program;
  GLint location;
  GLint x;
  GLint y;
ALIAS:
  glProgramUniform2iEXT = 1
CODE:
  OGLM_GLEWINIT
  OGLM_CHECK_ERR(glProgramUniform2i, )
  OGLM_AVAIL_CHECK(__glewProgramUniform2i, glProgramUniform2i)
  glProgramUniform2i(program, location, x, y);
  OGLM_CHECK_ERR(glProgramUniform2i, )

void
glProgramUniform2i64ARB(program, location, x, y)
  GLuint program;
  GLint location;
  GLint64 x;
  GLint64 y;
CODE:
  OGLM_GLEWINIT
  OGLM_CHECK_ERR(glProgramUniform2i64ARB, )
  OGLM_AVAIL_CHECK(__glewProgramUniform2i64ARB, glProgramUniform2i64ARB)
  glProgramUniform2i64ARB(program, location, x, y);
  OGLM_CHECK_ERR(glProgramUniform2i64ARB, )

void
glProgramUniform2i64NV(program, location, x, y)
  GLuint program;
  GLint location;
  GLint64EXT x;
  GLint64EXT y;
CODE:
  OGLM_GLEWINIT
  OGLM_CHECK_ERR(glProgramUniform2i64NV, )
  OGLM_AVAIL_CHECK(__glewProgramUniform2i64NV, glProgramUniform2i64NV)
  glProgramUniform2i64NV(program, location, x, y);
  OGLM_CHECK_ERR(glProgramUniform2i64NV, )

void
glProgramUniform2i64vARB_c(program, location, count, value)
  GLuint program;
  GLint location;
  GLsizei count;
  const GLint64* value;
CODE:
  OGLM_GLEWINIT
  OGLM_CHECK_ERR(glProgramUniform2i64vARB, )
  OGLM_AVAIL_CHECK(__glewProgramUniform2i64vARB, glProgramUniform2i64vARB)
  glProgramUniform2i64vARB(program, location, count, value);
  OGLM_CHECK_ERR(glProgramUniform2i64vARB, )

void
glProgramUniform2i64vARB_p(program, location, count, ...)
  GLuint program;
  GLint location;
  GLsizei count;
CODE:
  OGLM_GLEWINIT
  OGLM_CHECK_ERR(glProgramUniform2i64vARB, )
  OGLM_AVAIL_CHECK(__glewProgramUniform2i64vARB, glProgramUniform2i64vARB)
  GLint64* value = OGLM_GET_VARARGS(value,3,GLint64,IV,count*2);
  glProgramUniform2i64vARB((GLuint )program, (GLint )location, (GLsizei )count, (const GLint64* )value);
  OGLM_CHECK_ERR(glProgramUniform2i64vARB, free(value);)
  free(value);

void
glProgramUniform2i64vNV_c(program, location, count, value)
  GLuint program;
  GLint location;
  GLsizei count;
  const GLint64EXT* value;
CODE:
  OGLM_GLEWINIT
  OGLM_CHECK_ERR(glProgramUniform2i64vNV, )
  OGLM_AVAIL_CHECK(__glewProgramUniform2i64vNV, glProgramUniform2i64vNV)
  glProgramUniform2i64vNV(program, location, count, value);
  OGLM_CHECK_ERR(glProgramUniform2i64vNV, )

void
glProgramUniform2i64vNV_p(program, location, count, ...)
  GLuint program;
  GLint location;
  GLsizei count;
CODE:
  OGLM_GLEWINIT
  OGLM_CHECK_ERR(glProgramUniform2i64vNV, )
  OGLM_AVAIL_CHECK(__glewProgramUniform2i64vNV, glProgramUniform2i64vNV)
  GLint64EXT* value = OGLM_GET_VARARGS(value,3,GLint64EXT,IV,count*2);
  glProgramUniform2i64vNV((GLuint )program, (GLint )location, (GLsizei )count, (const GLint64EXT* )value);
  OGLM_CHECK_ERR(glProgramUniform2i64vNV, free(value);)
  free(value);

void
glProgramUniform2iv_c(program, location, count, value)
  GLuint program;
  GLint location;
  GLsizei count;
  const GLint* value;
ALIAS:
  glProgramUniform2ivEXT_c = 1
CODE:
  OGLM_GLEWINIT
  OGLM_CHECK_ERR(glProgramUniform2iv, )
  OGLM_AVAIL_CHECK(__glewProgramUniform2iv, glProgramUniform2iv)
  glProgramUniform2iv(program, location, count, value);
  OGLM_CHECK_ERR(glProgramUniform2iv, )

void
glProgramUniform2iv_p(program, location, count, ...)
  GLuint program;
  GLint location;
  GLsizei count;
ALIAS:
  glProgramUniform2ivEXT_p = 1
CODE:
  OGLM_GLEWINIT
  OGLM_CHECK_ERR(glProgramUniform2iv, )
  OGLM_AVAIL_CHECK(__glewProgramUniform2iv, glProgramUniform2iv)
  GLint* value = OGLM_GET_VARARGS(value,3,GLint,IV,count*2);
  glProgramUniform2iv((GLuint )program, (GLint )location, (GLsizei )count, (const GLint* )value);
  OGLM_CHECK_ERR(glProgramUniform2iv, free(value);)
  free(value);

void
glProgramUniform2ui(program, location, x, y)
  GLuint program;
  GLint location;
  GLuint x;
  GLuint y;
ALIAS:
  glProgramUniform2uiEXT = 1
CODE:
  OGLM_GLEWINIT
  OGLM_CHECK_ERR(glProgramUniform2ui, )
  OGLM_AVAIL_CHECK(__glewProgramUniform2ui, glProgramUniform2ui)
  glProgramUniform2ui(program, location, x, y);
  OGLM_CHECK_ERR(glProgramUniform2ui, )

void
glProgramUniform2ui64ARB(program, location, x, y)
  GLuint program;
  GLint location;
  GLuint64 x;
  GLuint64 y;
CODE:
  OGLM_GLEWINIT
  OGLM_CHECK_ERR(glProgramUniform2ui64ARB, )
  OGLM_AVAIL_CHECK(__glewProgramUniform2ui64ARB, glProgramUniform2ui64ARB)
  glProgramUniform2ui64ARB(program, location, x, y);
  OGLM_CHECK_ERR(glProgramUniform2ui64ARB, )

void
glProgramUniform2ui64NV(program, location, x, y)
  GLuint program;
  GLint location;
  GLuint64EXT x;
  GLuint64EXT y;
CODE:
  OGLM_GLEWINIT
  OGLM_CHECK_ERR(glProgramUniform2ui64NV, )
  OGLM_AVAIL_CHECK(__glewProgramUniform2ui64NV, glProgramUniform2ui64NV)
  glProgramUniform2ui64NV(program, location, x, y);
  OGLM_CHECK_ERR(glProgramUniform2ui64NV, )

void
glProgramUniform2ui64vARB_c(program, location, count, value)
  GLuint program;
  GLint location;
  GLsizei count;
  const GLuint64* value;
CODE:
  OGLM_GLEWINIT
  OGLM_CHECK_ERR(glProgramUniform2ui64vARB, )
  OGLM_AVAIL_CHECK(__glewProgramUniform2ui64vARB, glProgramUniform2ui64vARB)
  glProgramUniform2ui64vARB(program, location, count, value);
  OGLM_CHECK_ERR(glProgramUniform2ui64vARB, )

void
glProgramUniform2ui64vARB_p(program, location, count, ...)
  GLuint program;
  GLint location;
  GLsizei count;
CODE:
  OGLM_GLEWINIT
  OGLM_CHECK_ERR(glProgramUniform2ui64vARB, )
  OGLM_AVAIL_CHECK(__glewProgramUniform2ui64vARB, glProgramUniform2ui64vARB)
  GLuint64* value = OGLM_GET_VARARGS(value,3,GLuint64,UV,count*2);
  glProgramUniform2ui64vARB((GLuint )program, (GLint )location, (GLsizei )count, (const GLuint64* )value);
  OGLM_CHECK_ERR(glProgramUniform2ui64vARB, free(value);)
  free(value);

void
glProgramUniform2ui64vNV_c(program, location, count, value)
  GLuint program;
  GLint location;
  GLsizei count;
  const GLuint64EXT* value;
CODE:
  OGLM_GLEWINIT
  OGLM_CHECK_ERR(glProgramUniform2ui64vNV, )
  OGLM_AVAIL_CHECK(__glewProgramUniform2ui64vNV, glProgramUniform2ui64vNV)
  glProgramUniform2ui64vNV(program, location, count, value);
  OGLM_CHECK_ERR(glProgramUniform2ui64vNV, )

void
glProgramUniform2ui64vNV_p(program, location, count, ...)
  GLuint program;
  GLint location;
  GLsizei count;
CODE:
  OGLM_GLEWINIT
  OGLM_CHECK_ERR(glProgramUniform2ui64vNV, )
  OGLM_AVAIL_CHECK(__glewProgramUniform2ui64vNV, glProgramUniform2ui64vNV)
  GLuint64EXT* value = OGLM_GET_VARARGS(value,3,GLuint64EXT,UV,count*2);
  glProgramUniform2ui64vNV((GLuint )program, (GLint )location, (GLsizei )count, (const GLuint64EXT* )value);
  OGLM_CHECK_ERR(glProgramUniform2ui64vNV, free(value);)
  free(value);

void
glProgramUniform2uiv_c(program, location, count, value)
  GLuint program;
  GLint location;
  GLsizei count;
  const GLuint* value;
ALIAS:
  glProgramUniform2uivEXT_c = 1
CODE:
  OGLM_GLEWINIT
  OGLM_CHECK_ERR(glProgramUniform2uiv, )
  OGLM_AVAIL_CHECK(__glewProgramUniform2uiv, glProgramUniform2uiv)
  glProgramUniform2uiv(program, location, count, value);
  OGLM_CHECK_ERR(glProgramUniform2uiv, )

void
glProgramUniform2uiv_p(program, location, count, ...)
  GLuint program;
  GLint location;
  GLsizei count;
ALIAS:
  glProgramUniform2uivEXT_p = 1
CODE:
  OGLM_GLEWINIT
  OGLM_CHECK_ERR(glProgramUniform2uiv, )
  OGLM_AVAIL_CHECK(__glewProgramUniform2uiv, glProgramUniform2uiv)
  GLuint* value = OGLM_GET_VARARGS(value,3,GLuint,UV,count*2);
  glProgramUniform2uiv((GLuint )program, (GLint )location, (GLsizei )count, (const GLuint* )value);
  OGLM_CHECK_ERR(glProgramUniform2uiv, free(value);)
  free(value);

void
glProgramUniform3d(program, location, x, y, z)
  GLuint program;
  GLint location;
  GLdouble x;
  GLdouble y;
  GLdouble z;
CODE:
  OGLM_GLEWINIT
  OGLM_CHECK_ERR(glProgramUniform3d, )
  OGLM_AVAIL_CHECK(__glewProgramUniform3d, glProgramUniform3d)
  glProgramUniform3d(program, location, x, y, z);
  OGLM_CHECK_ERR(glProgramUniform3d, )

void
glProgramUniform3dv_c(program, location, count, value)
  GLuint program;
  GLint location;
  GLsizei count;
  const GLdouble* value;
CODE:
  OGLM_GLEWINIT
  OGLM_CHECK_ERR(glProgramUniform3dv, )
  OGLM_AVAIL_CHECK(__glewProgramUniform3dv, glProgramUniform3dv)
  glProgramUniform3dv(program, location, count, value);
  OGLM_CHECK_ERR(glProgramUniform3dv, )

void
glProgramUniform3dv_p(program, location, count, ...)
  GLuint program;
  GLint location;
  GLsizei count;
CODE:
  OGLM_GLEWINIT
  OGLM_CHECK_ERR(glProgramUniform3dv, )
  OGLM_AVAIL_CHECK(__glewProgramUniform3dv, glProgramUniform3dv)
  GLdouble* value = OGLM_GET_VARARGS(value,3,GLdouble,NV,count*3);
  glProgramUniform3dv((GLuint )program, (GLint )location, (GLsizei )count, (const GLdouble* )value);
  OGLM_CHECK_ERR(glProgramUniform3dv, free(value);)
  free(value);

void
glProgramUniform3f(program, location, x, y, z)
  GLuint program;
  GLint location;
  GLfloat x;
  GLfloat y;
  GLfloat z;
ALIAS:
  glProgramUniform3fEXT = 1
CODE:
  OGLM_GLEWINIT
  OGLM_CHECK_ERR(glProgramUniform3f, )
  OGLM_AVAIL_CHECK(__glewProgramUniform3f, glProgramUniform3f)
  glProgramUniform3f(program, location, x, y, z);
  OGLM_CHECK_ERR(glProgramUniform3f, )

void
glProgramUniform3fv_c(program, location, count, value)
  GLuint program;
  GLint location;
  GLsizei count;
  const GLfloat* value;
ALIAS:
  glProgramUniform3fvEXT_c = 1
CODE:
  OGLM_GLEWINIT
  OGLM_CHECK_ERR(glProgramUniform3fv, )
  OGLM_AVAIL_CHECK(__glewProgramUniform3fv, glProgramUniform3fv)
  glProgramUniform3fv(program, location, count, value);
  OGLM_CHECK_ERR(glProgramUniform3fv, )

void
glProgramUniform3fv_p(program, location, count, ...)
  GLuint program;
  GLint location;
  GLsizei count;
ALIAS:
  glProgramUniform3fvEXT_p = 1
CODE:
  OGLM_GLEWINIT
  OGLM_CHECK_ERR(glProgramUniform3fv, )
  OGLM_AVAIL_CHECK(__glewProgramUniform3fv, glProgramUniform3fv)
  GLfloat* value = OGLM_GET_VARARGS(value,3,GLfloat,NV,count*3);
  glProgramUniform3fv((GLuint )program, (GLint )location, (GLsizei )count, (const GLfloat* )value);
  OGLM_CHECK_ERR(glProgramUniform3fv, free(value);)
  free(value);

void
glProgramUniform3i(program, location, x, y, z)
  GLuint program;
  GLint location;
  GLint x;
  GLint y;
  GLint z;
ALIAS:
  glProgramUniform3iEXT = 1
CODE:
  OGLM_GLEWINIT
  OGLM_CHECK_ERR(glProgramUniform3i, )
  OGLM_AVAIL_CHECK(__glewProgramUniform3i, glProgramUniform3i)
  glProgramUniform3i(program, location, x, y, z);
  OGLM_CHECK_ERR(glProgramUniform3i, )

void
glProgramUniform3i64ARB(program, location, x, y, z)
  GLuint program;
  GLint location;
  GLint64 x;
  GLint64 y;
  GLint64 z;
CODE:
  OGLM_GLEWINIT
  OGLM_CHECK_ERR(glProgramUniform3i64ARB, )
  OGLM_AVAIL_CHECK(__glewProgramUniform3i64ARB, glProgramUniform3i64ARB)
  glProgramUniform3i64ARB(program, location, x, y, z);
  OGLM_CHECK_ERR(glProgramUniform3i64ARB, )

void
glProgramUniform3i64NV(program, location, x, y, z)
  GLuint program;
  GLint location;
  GLint64EXT x;
  GLint64EXT y;
  GLint64EXT z;
CODE:
  OGLM_GLEWINIT
  OGLM_CHECK_ERR(glProgramUniform3i64NV, )
  OGLM_AVAIL_CHECK(__glewProgramUniform3i64NV, glProgramUniform3i64NV)
  glProgramUniform3i64NV(program, location, x, y, z);
  OGLM_CHECK_ERR(glProgramUniform3i64NV, )

void
glProgramUniform3i64vARB_c(program, location, count, value)
  GLuint program;
  GLint location;
  GLsizei count;
  const GLint64* value;
CODE:
  OGLM_GLEWINIT
  OGLM_CHECK_ERR(glProgramUniform3i64vARB, )
  OGLM_AVAIL_CHECK(__glewProgramUniform3i64vARB, glProgramUniform3i64vARB)
  glProgramUniform3i64vARB(program, location, count, value);
  OGLM_CHECK_ERR(glProgramUniform3i64vARB, )

void
glProgramUniform3i64vARB_p(program, location, count, ...)
  GLuint program;
  GLint location;
  GLsizei count;
CODE:
  OGLM_GLEWINIT
  OGLM_CHECK_ERR(glProgramUniform3i64vARB, )
  OGLM_AVAIL_CHECK(__glewProgramUniform3i64vARB, glProgramUniform3i64vARB)
  GLint64* value = OGLM_GET_VARARGS(value,3,GLint64,IV,count*3);
  glProgramUniform3i64vARB((GLuint )program, (GLint )location, (GLsizei )count, (const GLint64* )value);
  OGLM_CHECK_ERR(glProgramUniform3i64vARB, free(value);)
  free(value);

void
glProgramUniform3i64vNV_c(program, location, count, value)
  GLuint program;
  GLint location;
  GLsizei count;
  const GLint64EXT* value;
CODE:
  OGLM_GLEWINIT
  OGLM_CHECK_ERR(glProgramUniform3i64vNV, )
  OGLM_AVAIL_CHECK(__glewProgramUniform3i64vNV, glProgramUniform3i64vNV)
  glProgramUniform3i64vNV(program, location, count, value);
  OGLM_CHECK_ERR(glProgramUniform3i64vNV, )

void
glProgramUniform3i64vNV_p(program, location, count, ...)
  GLuint program;
  GLint location;
  GLsizei count;
CODE:
  OGLM_GLEWINIT
  OGLM_CHECK_ERR(glProgramUniform3i64vNV, )
  OGLM_AVAIL_CHECK(__glewProgramUniform3i64vNV, glProgramUniform3i64vNV)
  GLint64EXT* value = OGLM_GET_VARARGS(value,3,GLint64EXT,IV,count*3);
  glProgramUniform3i64vNV((GLuint )program, (GLint )location, (GLsizei )count, (const GLint64EXT* )value);
  OGLM_CHECK_ERR(glProgramUniform3i64vNV, free(value);)
  free(value);

void
glProgramUniform3iv_c(program, location, count, value)
  GLuint program;
  GLint location;
  GLsizei count;
  const GLint* value;
ALIAS:
  glProgramUniform3ivEXT_c = 1
CODE:
  OGLM_GLEWINIT
  OGLM_CHECK_ERR(glProgramUniform3iv, )
  OGLM_AVAIL_CHECK(__glewProgramUniform3iv, glProgramUniform3iv)
  glProgramUniform3iv(program, location, count, value);
  OGLM_CHECK_ERR(glProgramUniform3iv, )

void
glProgramUniform3iv_p(program, location, count, ...)
  GLuint program;
  GLint location;
  GLsizei count;
ALIAS:
  glProgramUniform3ivEXT_p = 1
CODE:
  OGLM_GLEWINIT
  OGLM_CHECK_ERR(glProgramUniform3iv, )
  OGLM_AVAIL_CHECK(__glewProgramUniform3iv, glProgramUniform3iv)
  GLint* value = OGLM_GET_VARARGS(value,3,GLint,IV,count*3);
  glProgramUniform3iv((GLuint )program, (GLint )location, (GLsizei )count, (const GLint* )value);
  OGLM_CHECK_ERR(glProgramUniform3iv, free(value);)
  free(value);

void
glProgramUniform3ui(program, location, x, y, z)
  GLuint program;
  GLint location;
  GLuint x;
  GLuint y;
  GLuint z;
ALIAS:
  glProgramUniform3uiEXT = 1
CODE:
  OGLM_GLEWINIT
  OGLM_CHECK_ERR(glProgramUniform3ui, )
  OGLM_AVAIL_CHECK(__glewProgramUniform3ui, glProgramUniform3ui)
  glProgramUniform3ui(program, location, x, y, z);
  OGLM_CHECK_ERR(glProgramUniform3ui, )

void
glProgramUniform3ui64ARB(program, location, x, y, z)
  GLuint program;
  GLint location;
  GLuint64 x;
  GLuint64 y;
  GLuint64 z;
CODE:
  OGLM_GLEWINIT
  OGLM_CHECK_ERR(glProgramUniform3ui64ARB, )
  OGLM_AVAIL_CHECK(__glewProgramUniform3ui64ARB, glProgramUniform3ui64ARB)
  glProgramUniform3ui64ARB(program, location, x, y, z);
  OGLM_CHECK_ERR(glProgramUniform3ui64ARB, )

void
glProgramUniform3ui64NV(program, location, x, y, z)
  GLuint program;
  GLint location;
  GLuint64EXT x;
  GLuint64EXT y;
  GLuint64EXT z;
CODE:
  OGLM_GLEWINIT
  OGLM_CHECK_ERR(glProgramUniform3ui64NV, )
  OGLM_AVAIL_CHECK(__glewProgramUniform3ui64NV, glProgramUniform3ui64NV)
  glProgramUniform3ui64NV(program, location, x, y, z);
  OGLM_CHECK_ERR(glProgramUniform3ui64NV, )

void
glProgramUniform3ui64vARB_c(program, location, count, value)
  GLuint program;
  GLint location;
  GLsizei count;
  const GLuint64* value;
CODE:
  OGLM_GLEWINIT
  OGLM_CHECK_ERR(glProgramUniform3ui64vARB, )
  OGLM_AVAIL_CHECK(__glewProgramUniform3ui64vARB, glProgramUniform3ui64vARB)
  glProgramUniform3ui64vARB(program, location, count, value);
  OGLM_CHECK_ERR(glProgramUniform3ui64vARB, )

void
glProgramUniform3ui64vARB_p(program, location, count, ...)
  GLuint program;
  GLint location;
  GLsizei count;
CODE:
  OGLM_GLEWINIT
  OGLM_CHECK_ERR(glProgramUniform3ui64vARB, )
  OGLM_AVAIL_CHECK(__glewProgramUniform3ui64vARB, glProgramUniform3ui64vARB)
  GLuint64* value = OGLM_GET_VARARGS(value,3,GLuint64,UV,count*3);
  glProgramUniform3ui64vARB((GLuint )program, (GLint )location, (GLsizei )count, (const GLuint64* )value);
  OGLM_CHECK_ERR(glProgramUniform3ui64vARB, free(value);)
  free(value);

void
glProgramUniform3ui64vNV_c(program, location, count, value)
  GLuint program;
  GLint location;
  GLsizei count;
  const GLuint64EXT* value;
CODE:
  OGLM_GLEWINIT
  OGLM_CHECK_ERR(glProgramUniform3ui64vNV, )
  OGLM_AVAIL_CHECK(__glewProgramUniform3ui64vNV, glProgramUniform3ui64vNV)
  glProgramUniform3ui64vNV(program, location, count, value);
  OGLM_CHECK_ERR(glProgramUniform3ui64vNV, )

void
glProgramUniform3ui64vNV_p(program, location, count, ...)
  GLuint program;
  GLint location;
  GLsizei count;
CODE:
  OGLM_GLEWINIT
  OGLM_CHECK_ERR(glProgramUniform3ui64vNV, )
  OGLM_AVAIL_CHECK(__glewProgramUniform3ui64vNV, glProgramUniform3ui64vNV)
  GLuint64EXT* value = OGLM_GET_VARARGS(value,3,GLuint64EXT,UV,count*3);
  glProgramUniform3ui64vNV((GLuint )program, (GLint )location, (GLsizei )count, (const GLuint64EXT* )value);
  OGLM_CHECK_ERR(glProgramUniform3ui64vNV, free(value);)
  free(value);

void
glProgramUniform3uiv_c(program, location, count, value)
  GLuint program;
  GLint location;
  GLsizei count;
  const GLuint* value;
ALIAS:
  glProgramUniform3uivEXT_c = 1
CODE:
  OGLM_GLEWINIT
  OGLM_CHECK_ERR(glProgramUniform3uiv, )
  OGLM_AVAIL_CHECK(__glewProgramUniform3uiv, glProgramUniform3uiv)
  glProgramUniform3uiv(program, location, count, value);
  OGLM_CHECK_ERR(glProgramUniform3uiv, )

void
glProgramUniform3uiv_p(program, location, count, ...)
  GLuint program;
  GLint location;
  GLsizei count;
ALIAS:
  glProgramUniform3uivEXT_p = 1
CODE:
  OGLM_GLEWINIT
  OGLM_CHECK_ERR(glProgramUniform3uiv, )
  OGLM_AVAIL_CHECK(__glewProgramUniform3uiv, glProgramUniform3uiv)
  GLuint* value = OGLM_GET_VARARGS(value,3,GLuint,UV,count*3);
  glProgramUniform3uiv((GLuint )program, (GLint )location, (GLsizei )count, (const GLuint* )value);
  OGLM_CHECK_ERR(glProgramUniform3uiv, free(value);)
  free(value);

void
glProgramUniform4d(program, location, x, y, z, w)
  GLuint program;
  GLint location;
  GLdouble x;
  GLdouble y;
  GLdouble z;
  GLdouble w;
CODE:
  OGLM_GLEWINIT
  OGLM_CHECK_ERR(glProgramUniform4d, )
  OGLM_AVAIL_CHECK(__glewProgramUniform4d, glProgramUniform4d)
  glProgramUniform4d(program, location, x, y, z, w);
  OGLM_CHECK_ERR(glProgramUniform4d, )

void
glProgramUniform4dv_c(program, location, count, value)
  GLuint program;
  GLint location;
  GLsizei count;
  const GLdouble* value;
CODE:
  OGLM_GLEWINIT
  OGLM_CHECK_ERR(glProgramUniform4dv, )
  OGLM_AVAIL_CHECK(__glewProgramUniform4dv, glProgramUniform4dv)
  glProgramUniform4dv(program, location, count, value);
  OGLM_CHECK_ERR(glProgramUniform4dv, )

void
glProgramUniform4dv_p(program, location, count, ...)
  GLuint program;
  GLint location;
  GLsizei count;
CODE:
  OGLM_GLEWINIT
  OGLM_CHECK_ERR(glProgramUniform4dv, )
  OGLM_AVAIL_CHECK(__glewProgramUniform4dv, glProgramUniform4dv)
  GLdouble* value = OGLM_GET_VARARGS(value,3,GLdouble,NV,count*4);
  glProgramUniform4dv((GLuint )program, (GLint )location, (GLsizei )count, (const GLdouble* )value);
  OGLM_CHECK_ERR(glProgramUniform4dv, free(value);)
  free(value);

void
glProgramUniform4f(program, location, x, y, z, w)
  GLuint program;
  GLint location;
  GLfloat x;
  GLfloat y;
  GLfloat z;
  GLfloat w;
ALIAS:
  glProgramUniform4fEXT = 1
CODE:
  OGLM_GLEWINIT
  OGLM_CHECK_ERR(glProgramUniform4f, )
  OGLM_AVAIL_CHECK(__glewProgramUniform4f, glProgramUniform4f)
  glProgramUniform4f(program, location, x, y, z, w);
  OGLM_CHECK_ERR(glProgramUniform4f, )

void
glProgramUniform4fv_c(program, location, count, value)
  GLuint program;
  GLint location;
  GLsizei count;
  const GLfloat* value;
ALIAS:
  glProgramUniform4fvEXT_c = 1
CODE:
  OGLM_GLEWINIT
  OGLM_CHECK_ERR(glProgramUniform4fv, )
  OGLM_AVAIL_CHECK(__glewProgramUniform4fv, glProgramUniform4fv)
  glProgramUniform4fv(program, location, count, value);
  OGLM_CHECK_ERR(glProgramUniform4fv, )

void
glProgramUniform4fv_p(program, location, count, ...)
  GLuint program;
  GLint location;
  GLsizei count;
ALIAS:
  glProgramUniform4fvEXT_p = 1
CODE:
  OGLM_GLEWINIT
  OGLM_CHECK_ERR(glProgramUniform4fv, )
  OGLM_AVAIL_CHECK(__glewProgramUniform4fv, glProgramUniform4fv)
  GLfloat* value = OGLM_GET_VARARGS(value,3,GLfloat,NV,count*4);
  glProgramUniform4fv((GLuint )program, (GLint )location, (GLsizei )count, (const GLfloat* )value);
  OGLM_CHECK_ERR(glProgramUniform4fv, free(value);)
  free(value);

void
glProgramUniform4i(program, location, x, y, z, w)
  GLuint program;
  GLint location;
  GLint x;
  GLint y;
  GLint z;
  GLint w;
ALIAS:
  glProgramUniform4iEXT = 1
CODE:
  OGLM_GLEWINIT
  OGLM_CHECK_ERR(glProgramUniform4i, )
  OGLM_AVAIL_CHECK(__glewProgramUniform4i, glProgramUniform4i)
  glProgramUniform4i(program, location, x, y, z, w);
  OGLM_CHECK_ERR(glProgramUniform4i, )

void
glProgramUniform4i64ARB(program, location, x, y, z, w)
  GLuint program;
  GLint location;
  GLint64 x;
  GLint64 y;
  GLint64 z;
  GLint64 w;
CODE:
  OGLM_GLEWINIT
  OGLM_CHECK_ERR(glProgramUniform4i64ARB, )
  OGLM_AVAIL_CHECK(__glewProgramUniform4i64ARB, glProgramUniform4i64ARB)
  glProgramUniform4i64ARB(program, location, x, y, z, w);
  OGLM_CHECK_ERR(glProgramUniform4i64ARB, )

void
glProgramUniform4i64NV(program, location, x, y, z, w)
  GLuint program;
  GLint location;
  GLint64EXT x;
  GLint64EXT y;
  GLint64EXT z;
  GLint64EXT w;
CODE:
  OGLM_GLEWINIT
  OGLM_CHECK_ERR(glProgramUniform4i64NV, )
  OGLM_AVAIL_CHECK(__glewProgramUniform4i64NV, glProgramUniform4i64NV)
  glProgramUniform4i64NV(program, location, x, y, z, w);
  OGLM_CHECK_ERR(glProgramUniform4i64NV, )

void
glProgramUniform4i64vARB_c(program, location, count, value)
  GLuint program;
  GLint location;
  GLsizei count;
  const GLint64* value;
CODE:
  OGLM_GLEWINIT
  OGLM_CHECK_ERR(glProgramUniform4i64vARB, )
  OGLM_AVAIL_CHECK(__glewProgramUniform4i64vARB, glProgramUniform4i64vARB)
  glProgramUniform4i64vARB(program, location, count, value);
  OGLM_CHECK_ERR(glProgramUniform4i64vARB, )

void
glProgramUniform4i64vARB_p(program, location, count, ...)
  GLuint program;
  GLint location;
  GLsizei count;
CODE:
  OGLM_GLEWINIT
  OGLM_CHECK_ERR(glProgramUniform4i64vARB, )
  OGLM_AVAIL_CHECK(__glewProgramUniform4i64vARB, glProgramUniform4i64vARB)
  GLint64* value = OGLM_GET_VARARGS(value,3,GLint64,IV,count*4);
  glProgramUniform4i64vARB((GLuint )program, (GLint )location, (GLsizei )count, (const GLint64* )value);
  OGLM_CHECK_ERR(glProgramUniform4i64vARB, free(value);)
  free(value);

void
glProgramUniform4i64vNV_c(program, location, count, value)
  GLuint program;
  GLint location;
  GLsizei count;
  const GLint64EXT* value;
CODE:
  OGLM_GLEWINIT
  OGLM_CHECK_ERR(glProgramUniform4i64vNV, )
  OGLM_AVAIL_CHECK(__glewProgramUniform4i64vNV, glProgramUniform4i64vNV)
  glProgramUniform4i64vNV(program, location, count, value);
  OGLM_CHECK_ERR(glProgramUniform4i64vNV, )

void
glProgramUniform4i64vNV_p(program, location, count, ...)
  GLuint program;
  GLint location;
  GLsizei count;
CODE:
  OGLM_GLEWINIT
  OGLM_CHECK_ERR(glProgramUniform4i64vNV, )
  OGLM_AVAIL_CHECK(__glewProgramUniform4i64vNV, glProgramUniform4i64vNV)
  GLint64EXT* value = OGLM_GET_VARARGS(value,3,GLint64EXT,IV,count*4);
  glProgramUniform4i64vNV((GLuint )program, (GLint )location, (GLsizei )count, (const GLint64EXT* )value);
  OGLM_CHECK_ERR(glProgramUniform4i64vNV, free(value);)
  free(value);

void
glProgramUniform4iv_c(program, location, count, value)
  GLuint program;
  GLint location;
  GLsizei count;
  const GLint* value;
ALIAS:
  glProgramUniform4ivEXT_c = 1
CODE:
  OGLM_GLEWINIT
  OGLM_CHECK_ERR(glProgramUniform4iv, )
  OGLM_AVAIL_CHECK(__glewProgramUniform4iv, glProgramUniform4iv)
  glProgramUniform4iv(program, location, count, value);
  OGLM_CHECK_ERR(glProgramUniform4iv, )

void
glProgramUniform4iv_p(program, location, count, ...)
  GLuint program;
  GLint location;
  GLsizei count;
ALIAS:
  glProgramUniform4ivEXT_p = 1
CODE:
  OGLM_GLEWINIT
  OGLM_CHECK_ERR(glProgramUniform4iv, )
  OGLM_AVAIL_CHECK(__glewProgramUniform4iv, glProgramUniform4iv)
  GLint* value = OGLM_GET_VARARGS(value,3,GLint,IV,count*4);
  glProgramUniform4iv((GLuint )program, (GLint )location, (GLsizei )count, (const GLint* )value);
  OGLM_CHECK_ERR(glProgramUniform4iv, free(value);)
  free(value);

void
glProgramUniform4ui(program, location, x, y, z, w)
  GLuint program;
  GLint location;
  GLuint x;
  GLuint y;
  GLuint z;
  GLuint w;
ALIAS:
  glProgramUniform4uiEXT = 1
CODE:
  OGLM_GLEWINIT
  OGLM_CHECK_ERR(glProgramUniform4ui, )
  OGLM_AVAIL_CHECK(__glewProgramUniform4ui, glProgramUniform4ui)
  glProgramUniform4ui(program, location, x, y, z, w);
  OGLM_CHECK_ERR(glProgramUniform4ui, )

void
glProgramUniform4ui64ARB(program, location, x, y, z, w)
  GLuint program;
  GLint location;
  GLuint64 x;
  GLuint64 y;
  GLuint64 z;
  GLuint64 w;
CODE:
  OGLM_GLEWINIT
  OGLM_CHECK_ERR(glProgramUniform4ui64ARB, )
  OGLM_AVAIL_CHECK(__glewProgramUniform4ui64ARB, glProgramUniform4ui64ARB)
  glProgramUniform4ui64ARB(program, location, x, y, z, w);
  OGLM_CHECK_ERR(glProgramUniform4ui64ARB, )

void
glProgramUniform4ui64NV(program, location, x, y, z, w)
  GLuint program;
  GLint location;
  GLuint64EXT x;
  GLuint64EXT y;
  GLuint64EXT z;
  GLuint64EXT w;
CODE:
  OGLM_GLEWINIT
  OGLM_CHECK_ERR(glProgramUniform4ui64NV, )
  OGLM_AVAIL_CHECK(__glewProgramUniform4ui64NV, glProgramUniform4ui64NV)
  glProgramUniform4ui64NV(program, location, x, y, z, w);
  OGLM_CHECK_ERR(glProgramUniform4ui64NV, )

void
glProgramUniform4ui64vARB_c(program, location, count, value)
  GLuint program;
  GLint location;
  GLsizei count;
  const GLuint64* value;
CODE:
  OGLM_GLEWINIT
  OGLM_CHECK_ERR(glProgramUniform4ui64vARB, )
  OGLM_AVAIL_CHECK(__glewProgramUniform4ui64vARB, glProgramUniform4ui64vARB)
  glProgramUniform4ui64vARB(program, location, count, value);
  OGLM_CHECK_ERR(glProgramUniform4ui64vARB, )

void
glProgramUniform4ui64vARB_p(program, location, count, ...)
  GLuint program;
  GLint location;
  GLsizei count;
CODE:
  OGLM_GLEWINIT
  OGLM_CHECK_ERR(glProgramUniform4ui64vARB, )
  OGLM_AVAIL_CHECK(__glewProgramUniform4ui64vARB, glProgramUniform4ui64vARB)
  GLuint64* value = OGLM_GET_VARARGS(value,3,GLuint64,UV,count*4);
  glProgramUniform4ui64vARB((GLuint )program, (GLint )location, (GLsizei )count, (const GLuint64* )value);
  OGLM_CHECK_ERR(glProgramUniform4ui64vARB, free(value);)
  free(value);

void
glProgramUniform4ui64vNV_c(program, location, count, value)
  GLuint program;
  GLint location;
  GLsizei count;
  const GLuint64EXT* value;
CODE:
  OGLM_GLEWINIT
  OGLM_CHECK_ERR(glProgramUniform4ui64vNV, )
  OGLM_AVAIL_CHECK(__glewProgramUniform4ui64vNV, glProgramUniform4ui64vNV)
  glProgramUniform4ui64vNV(program, location, count, value);
  OGLM_CHECK_ERR(glProgramUniform4ui64vNV, )

void
glProgramUniform4ui64vNV_p(program, location, count, ...)
  GLuint program;
  GLint location;
  GLsizei count;
CODE:
  OGLM_GLEWINIT
  OGLM_CHECK_ERR(glProgramUniform4ui64vNV, )
  OGLM_AVAIL_CHECK(__glewProgramUniform4ui64vNV, glProgramUniform4ui64vNV)
  GLuint64EXT* value = OGLM_GET_VARARGS(value,3,GLuint64EXT,UV,count*4);
  glProgramUniform4ui64vNV((GLuint )program, (GLint )location, (GLsizei )count, (const GLuint64EXT* )value);
  OGLM_CHECK_ERR(glProgramUniform4ui64vNV, free(value);)
  free(value);

void
glProgramUniform4uiv_c(program, location, count, value)
  GLuint program;
  GLint location;
  GLsizei count;
  const GLuint* value;
ALIAS:
  glProgramUniform4uivEXT_c = 1
CODE:
  OGLM_GLEWINIT
  OGLM_CHECK_ERR(glProgramUniform4uiv, )
  OGLM_AVAIL_CHECK(__glewProgramUniform4uiv, glProgramUniform4uiv)
  glProgramUniform4uiv(program, location, count, value);
  OGLM_CHECK_ERR(glProgramUniform4uiv, )

void
glProgramUniform4uiv_p(program, location, count, ...)
  GLuint program;
  GLint location;
  GLsizei count;
ALIAS:
  glProgramUniform4uivEXT_p = 1
CODE:
  OGLM_GLEWINIT
  OGLM_CHECK_ERR(glProgramUniform4uiv, )
  OGLM_AVAIL_CHECK(__glewProgramUniform4uiv, glProgramUniform4uiv)
  GLuint* value = OGLM_GET_VARARGS(value,3,GLuint,UV,count*4);
  glProgramUniform4uiv((GLuint )program, (GLint )location, (GLsizei )count, (const GLuint* )value);
  OGLM_CHECK_ERR(glProgramUniform4uiv, free(value);)
  free(value);

void
glProgramUniformHandleui64ARB(program, location, value)
  GLuint program;
  GLint location;
  GLuint64 value;
ALIAS:
  glProgramUniformHandleui64IMG = 1
CODE:
  OGLM_GLEWINIT
  OGLM_CHECK_ERR(glProgramUniformHandleui64ARB, )
  OGLM_AVAIL_CHECK(__glewProgramUniformHandleui64ARB, glProgramUniformHandleui64ARB)
  glProgramUniformHandleui64ARB(program, location, value);
  OGLM_CHECK_ERR(glProgramUniformHandleui64ARB, )

void
glProgramUniformHandleui64NV(program, location, value)
  GLuint program;
  GLint location;
  GLuint64 value;
CODE:
  OGLM_GLEWINIT
  OGLM_CHECK_ERR(glProgramUniformHandleui64NV, )
  OGLM_AVAIL_CHECK(__glewProgramUniformHandleui64NV, glProgramUniformHandleui64NV)
  glProgramUniformHandleui64NV(program, location, value);
  OGLM_CHECK_ERR(glProgramUniformHandleui64NV, )

void
glProgramUniformHandleui64vARB_c(program, location, count, values)
  GLuint program;
  GLint location;
  GLsizei count;
  const GLuint64* values;
ALIAS:
  glProgramUniformHandleui64vIMG_c = 1
CODE:
  OGLM_GLEWINIT
  OGLM_CHECK_ERR(glProgramUniformHandleui64vARB, )
  OGLM_AVAIL_CHECK(__glewProgramUniformHandleui64vARB, glProgramUniformHandleui64vARB)
  glProgramUniformHandleui64vARB(program, location, count, values);
  OGLM_CHECK_ERR(glProgramUniformHandleui64vARB, )

void
glProgramUniformHandleui64vARB_p(program, location, ...)
  GLuint program;
  GLint location;
ALIAS:
  glProgramUniformHandleui64vIMG_p = 1
CODE:
  OGLM_GLEWINIT
  OGLM_CHECK_ERR(glProgramUniformHandleui64vARB, )
  OGLM_AVAIL_CHECK(__glewProgramUniformHandleui64vARB, glProgramUniformHandleui64vARB)
  GLsizei count = items-2;
  GLuint64* values = OGLM_GET_VARARGS(values,2,GLuint64,UV,count);
  glProgramUniformHandleui64vARB((GLuint )program, (GLint )location, (GLsizei )count, (const GLuint64* )values);
  OGLM_CHECK_ERR(glProgramUniformHandleui64vARB, free(values);)
  free(values);

void
glProgramUniformHandleui64vNV_c(program, location, count, values)
  GLuint program;
  GLint location;
  GLsizei count;
  const GLuint64* values;
CODE:
  OGLM_GLEWINIT
  OGLM_CHECK_ERR(glProgramUniformHandleui64vNV, )
  OGLM_AVAIL_CHECK(__glewProgramUniformHandleui64vNV, glProgramUniformHandleui64vNV)
  glProgramUniformHandleui64vNV(program, location, count, values);
  OGLM_CHECK_ERR(glProgramUniformHandleui64vNV, )

void
glProgramUniformHandleui64vNV_p(program, location, ...)
  GLuint program;
  GLint location;
CODE:
  OGLM_GLEWINIT
  OGLM_CHECK_ERR(glProgramUniformHandleui64vNV, )
  OGLM_AVAIL_CHECK(__glewProgramUniformHandleui64vNV, glProgramUniformHandleui64vNV)
  GLsizei count = items-2;
  GLuint64* values = OGLM_GET_VARARGS(values,2,GLuint64,UV,count);
  glProgramUniformHandleui64vNV((GLuint )program, (GLint )location, (GLsizei )count, (const GLuint64* )values);
  OGLM_CHECK_ERR(glProgramUniformHandleui64vNV, free(values);)
  free(values);

void
glProgramUniformMatrix2dv_c(program, location, count, transpose, value)
  GLuint program;
  GLint location;
  GLsizei count;
  GLboolean transpose;
  const GLdouble* value;
CODE:
  OGLM_GLEWINIT
  OGLM_CHECK_ERR(glProgramUniformMatrix2dv, )
  OGLM_AVAIL_CHECK(__glewProgramUniformMatrix2dv, glProgramUniformMatrix2dv)
  glProgramUniformMatrix2dv(program, location, count, transpose, value);
  OGLM_CHECK_ERR(glProgramUniformMatrix2dv, )

void
glProgramUniformMatrix2dv_p(program, location, count, transpose, ...)
  GLuint program;
  GLint location;
  GLsizei count;
  GLboolean transpose;
CODE:
  OGLM_GLEWINIT
  OGLM_CHECK_ERR(glProgramUniformMatrix2dv, )
  OGLM_AVAIL_CHECK(__glewProgramUniformMatrix2dv, glProgramUniformMatrix2dv)
  GLdouble* value = OGLM_GET_VARARGS(value,4,GLdouble,NV,count*4);
  glProgramUniformMatrix2dv((GLuint )program, (GLint )location, (GLsizei )count, (GLboolean )transpose, (const GLdouble* )value);
  OGLM_CHECK_ERR(glProgramUniformMatrix2dv, free(value);)
  free(value);

void
glProgramUniformMatrix2fv_c(program, location, count, transpose, value)
  GLuint program;
  GLint location;
  GLsizei count;
  GLboolean transpose;
  const GLfloat* value;
ALIAS:
  glProgramUniformMatrix2fvEXT_c = 1
CODE:
  OGLM_GLEWINIT
  OGLM_CHECK_ERR(glProgramUniformMatrix2fv, )
  OGLM_AVAIL_CHECK(__glewProgramUniformMatrix2fv, glProgramUniformMatrix2fv)
  glProgramUniformMatrix2fv(program, location, count, transpose, value);
  OGLM_CHECK_ERR(glProgramUniformMatrix2fv, )

void
glProgramUniformMatrix2fv_p(program, location, count, transpose, ...)
  GLuint program;
  GLint location;
  GLsizei count;
  GLboolean transpose;
ALIAS:
  glProgramUniformMatrix2fvEXT_p = 1
CODE:
  OGLM_GLEWINIT
  OGLM_CHECK_ERR(glProgramUniformMatrix2fv, )
  OGLM_AVAIL_CHECK(__glewProgramUniformMatrix2fv, glProgramUniformMatrix2fv)
  GLfloat* value = OGLM_GET_VARARGS(value,4,GLfloat,NV,count*4);
  glProgramUniformMatrix2fv((GLuint )program, (GLint )location, (GLsizei )count, (GLboolean )transpose, (const GLfloat* )value);
  OGLM_CHECK_ERR(glProgramUniformMatrix2fv, free(value);)
  free(value);

void
glProgramUniformMatrix2x3dv_c(program, location, count, transpose, value)
  GLuint program;
  GLint location;
  GLsizei count;
  GLboolean transpose;
  const GLdouble* value;
CODE:
  OGLM_GLEWINIT
  OGLM_CHECK_ERR(glProgramUniformMatrix2x3dv, )
  OGLM_AVAIL_CHECK(__glewProgramUniformMatrix2x3dv, glProgramUniformMatrix2x3dv)
  glProgramUniformMatrix2x3dv(program, location, count, transpose, value);
  OGLM_CHECK_ERR(glProgramUniformMatrix2x3dv, )

void
glProgramUniformMatrix2x3dv_p(program, location, count, transpose, ...)
  GLuint program;
  GLint location;
  GLsizei count;
  GLboolean transpose;
CODE:
  OGLM_GLEWINIT
  OGLM_CHECK_ERR(glProgramUniformMatrix2x3dv, )
  OGLM_AVAIL_CHECK(__glewProgramUniformMatrix2x3dv, glProgramUniformMatrix2x3dv)
  GLdouble* value = OGLM_GET_VARARGS(value,4,GLdouble,NV,count*6);
  glProgramUniformMatrix2x3dv((GLuint )program, (GLint )location, (GLsizei )count, (GLboolean )transpose, (const GLdouble* )value);
  OGLM_CHECK_ERR(glProgramUniformMatrix2x3dv, free(value);)
  free(value);

void
glProgramUniformMatrix2x3fv_c(program, location, count, transpose, value)
  GLuint program;
  GLint location;
  GLsizei count;
  GLboolean transpose;
  const GLfloat* value;
ALIAS:
  glProgramUniformMatrix2x3fvEXT_c = 1
CODE:
  OGLM_GLEWINIT
  OGLM_CHECK_ERR(glProgramUniformMatrix2x3fv, )
  OGLM_AVAIL_CHECK(__glewProgramUniformMatrix2x3fv, glProgramUniformMatrix2x3fv)
  glProgramUniformMatrix2x3fv(program, location, count, transpose, value);
  OGLM_CHECK_ERR(glProgramUniformMatrix2x3fv, )

void
glProgramUniformMatrix2x3fv_p(program, location, count, transpose, ...)
  GLuint program;
  GLint location;
  GLsizei count;
  GLboolean transpose;
ALIAS:
  glProgramUniformMatrix2x3fvEXT_p = 1
CODE:
  OGLM_GLEWINIT
  OGLM_CHECK_ERR(glProgramUniformMatrix2x3fv, )
  OGLM_AVAIL_CHECK(__glewProgramUniformMatrix2x3fv, glProgramUniformMatrix2x3fv)
  GLfloat* value = OGLM_GET_VARARGS(value,4,GLfloat,NV,count*6);
  glProgramUniformMatrix2x3fv((GLuint )program, (GLint )location, (GLsizei )count, (GLboolean )transpose, (const GLfloat* )value);
  OGLM_CHECK_ERR(glProgramUniformMatrix2x3fv, free(value);)
  free(value);

void
glProgramUniformMatrix2x4dv_c(program, location, count, transpose, value)
  GLuint program;
  GLint location;
  GLsizei count;
  GLboolean transpose;
  const GLdouble* value;
CODE:
  OGLM_GLEWINIT
  OGLM_CHECK_ERR(glProgramUniformMatrix2x4dv, )
  OGLM_AVAIL_CHECK(__glewProgramUniformMatrix2x4dv, glProgramUniformMatrix2x4dv)
  glProgramUniformMatrix2x4dv(program, location, count, transpose, value);
  OGLM_CHECK_ERR(glProgramUniformMatrix2x4dv, )

void
glProgramUniformMatrix2x4dv_p(program, location, count, transpose, ...)
  GLuint program;
  GLint location;
  GLsizei count;
  GLboolean transpose;
CODE:
  OGLM_GLEWINIT
  OGLM_CHECK_ERR(glProgramUniformMatrix2x4dv, )
  OGLM_AVAIL_CHECK(__glewProgramUniformMatrix2x4dv, glProgramUniformMatrix2x4dv)
  GLdouble* value = OGLM_GET_VARARGS(value,4,GLdouble,NV,count*8);
  glProgramUniformMatrix2x4dv((GLuint )program, (GLint )location, (GLsizei )count, (GLboolean )transpose, (const GLdouble* )value);
  OGLM_CHECK_ERR(glProgramUniformMatrix2x4dv, free(value);)
  free(value);

void
glProgramUniformMatrix2x4fv_c(program, location, count, transpose, value)
  GLuint program;
  GLint location;
  GLsizei count;
  GLboolean transpose;
  const GLfloat* value;
ALIAS:
  glProgramUniformMatrix2x4fvEXT_c = 1
CODE:
  OGLM_GLEWINIT
  OGLM_CHECK_ERR(glProgramUniformMatrix2x4fv, )
  OGLM_AVAIL_CHECK(__glewProgramUniformMatrix2x4fv, glProgramUniformMatrix2x4fv)
  glProgramUniformMatrix2x4fv(program, location, count, transpose, value);
  OGLM_CHECK_ERR(glProgramUniformMatrix2x4fv, )

void
glProgramUniformMatrix2x4fv_p(program, location, count, transpose, ...)
  GLuint program;
  GLint location;
  GLsizei count;
  GLboolean transpose;
ALIAS:
  glProgramUniformMatrix2x4fvEXT_p = 1
CODE:
  OGLM_GLEWINIT
  OGLM_CHECK_ERR(glProgramUniformMatrix2x4fv, )
  OGLM_AVAIL_CHECK(__glewProgramUniformMatrix2x4fv, glProgramUniformMatrix2x4fv)
  GLfloat* value = OGLM_GET_VARARGS(value,4,GLfloat,NV,count*8);
  glProgramUniformMatrix2x4fv((GLuint )program, (GLint )location, (GLsizei )count, (GLboolean )transpose, (const GLfloat* )value);
  OGLM_CHECK_ERR(glProgramUniformMatrix2x4fv, free(value);)
  free(value);

void
glProgramUniformMatrix3dv_c(program, location, count, transpose, value)
  GLuint program;
  GLint location;
  GLsizei count;
  GLboolean transpose;
  const GLdouble* value;
CODE:
  OGLM_GLEWINIT
  OGLM_CHECK_ERR(glProgramUniformMatrix3dv, )
  OGLM_AVAIL_CHECK(__glewProgramUniformMatrix3dv, glProgramUniformMatrix3dv)
  glProgramUniformMatrix3dv(program, location, count, transpose, value);
  OGLM_CHECK_ERR(glProgramUniformMatrix3dv, )

void
glProgramUniformMatrix3dv_p(program, location, count, transpose, ...)
  GLuint program;
  GLint location;
  GLsizei count;
  GLboolean transpose;
CODE:
  OGLM_GLEWINIT
  OGLM_CHECK_ERR(glProgramUniformMatrix3dv, )
  OGLM_AVAIL_CHECK(__glewProgramUniformMatrix3dv, glProgramUniformMatrix3dv)
  GLdouble* value = OGLM_GET_VARARGS(value,4,GLdouble,NV,count*9);
  glProgramUniformMatrix3dv((GLuint )program, (GLint )location, (GLsizei )count, (GLboolean )transpose, (const GLdouble* )value);
  OGLM_CHECK_ERR(glProgramUniformMatrix3dv, free(value);)
  free(value);

void
glProgramUniformMatrix3fv_c(program, location, count, transpose, value)
  GLuint program;
  GLint location;
  GLsizei count;
  GLboolean transpose;
  const GLfloat* value;
ALIAS:
  glProgramUniformMatrix3fvEXT_c = 1
CODE:
  OGLM_GLEWINIT
  OGLM_CHECK_ERR(glProgramUniformMatrix3fv, )
  OGLM_AVAIL_CHECK(__glewProgramUniformMatrix3fv, glProgramUniformMatrix3fv)
  glProgramUniformMatrix3fv(program, location, count, transpose, value);
  OGLM_CHECK_ERR(glProgramUniformMatrix3fv, )

void
glProgramUniformMatrix3fv_p(program, location, count, transpose, ...)
  GLuint program;
  GLint location;
  GLsizei count;
  GLboolean transpose;
ALIAS:
  glProgramUniformMatrix3fvEXT_p = 1
CODE:
  OGLM_GLEWINIT
  OGLM_CHECK_ERR(glProgramUniformMatrix3fv, )
  OGLM_AVAIL_CHECK(__glewProgramUniformMatrix3fv, glProgramUniformMatrix3fv)
  GLfloat* value = OGLM_GET_VARARGS(value,4,GLfloat,NV,count*9);
  glProgramUniformMatrix3fv((GLuint )program, (GLint )location, (GLsizei )count, (GLboolean )transpose, (const GLfloat* )value);
  OGLM_CHECK_ERR(glProgramUniformMatrix3fv, free(value);)
  free(value);

void
glProgramUniformMatrix3x2dv_c(program, location, count, transpose, value)
  GLuint program;
  GLint location;
  GLsizei count;
  GLboolean transpose;
  const GLdouble* value;
CODE:
  OGLM_GLEWINIT
  OGLM_CHECK_ERR(glProgramUniformMatrix3x2dv, )
  OGLM_AVAIL_CHECK(__glewProgramUniformMatrix3x2dv, glProgramUniformMatrix3x2dv)
  glProgramUniformMatrix3x2dv(program, location, count, transpose, value);
  OGLM_CHECK_ERR(glProgramUniformMatrix3x2dv, )

void
glProgramUniformMatrix3x2dv_p(program, location, count, transpose, ...)
  GLuint program;
  GLint location;
  GLsizei count;
  GLboolean transpose;
CODE:
  OGLM_GLEWINIT
  OGLM_CHECK_ERR(glProgramUniformMatrix3x2dv, )
  OGLM_AVAIL_CHECK(__glewProgramUniformMatrix3x2dv, glProgramUniformMatrix3x2dv)
  GLdouble* value = OGLM_GET_VARARGS(value,4,GLdouble,NV,count*6);
  glProgramUniformMatrix3x2dv((GLuint )program, (GLint )location, (GLsizei )count, (GLboolean )transpose, (const GLdouble* )value);
  OGLM_CHECK_ERR(glProgramUniformMatrix3x2dv, free(value);)
  free(value);

void
glProgramUniformMatrix3x2fv_c(program, location, count, transpose, value)
  GLuint program;
  GLint location;
  GLsizei count;
  GLboolean transpose;
  const GLfloat* value;
ALIAS:
  glProgramUniformMatrix3x2fvEXT_c = 1
CODE:
  OGLM_GLEWINIT
  OGLM_CHECK_ERR(glProgramUniformMatrix3x2fv, )
  OGLM_AVAIL_CHECK(__glewProgramUniformMatrix3x2fv, glProgramUniformMatrix3x2fv)
  glProgramUniformMatrix3x2fv(program, location, count, transpose, value);
  OGLM_CHECK_ERR(glProgramUniformMatrix3x2fv, )

void
glProgramUniformMatrix3x2fv_p(program, location, count, transpose, ...)
  GLuint program;
  GLint location;
  GLsizei count;
  GLboolean transpose;
ALIAS:
  glProgramUniformMatrix3x2fvEXT_p = 1
CODE:
  OGLM_GLEWINIT
  OGLM_CHECK_ERR(glProgramUniformMatrix3x2fv, )
  OGLM_AVAIL_CHECK(__glewProgramUniformMatrix3x2fv, glProgramUniformMatrix3x2fv)
  GLfloat* value = OGLM_GET_VARARGS(value,4,GLfloat,NV,count*6);
  glProgramUniformMatrix3x2fv((GLuint )program, (GLint )location, (GLsizei )count, (GLboolean )transpose, (const GLfloat* )value);
  OGLM_CHECK_ERR(glProgramUniformMatrix3x2fv, free(value);)
  free(value);

void
glProgramUniformMatrix3x4dv_c(program, location, count, transpose, value)
  GLuint program;
  GLint location;
  GLsizei count;
  GLboolean transpose;
  const GLdouble* value;
CODE:
  OGLM_GLEWINIT
  OGLM_CHECK_ERR(glProgramUniformMatrix3x4dv, )
  OGLM_AVAIL_CHECK(__glewProgramUniformMatrix3x4dv, glProgramUniformMatrix3x4dv)
  glProgramUniformMatrix3x4dv(program, location, count, transpose, value);
  OGLM_CHECK_ERR(glProgramUniformMatrix3x4dv, )

void
glProgramUniformMatrix3x4dv_p(program, location, count, transpose, ...)
  GLuint program;
  GLint location;
  GLsizei count;
  GLboolean transpose;
CODE:
  OGLM_GLEWINIT
  OGLM_CHECK_ERR(glProgramUniformMatrix3x4dv, )
  OGLM_AVAIL_CHECK(__glewProgramUniformMatrix3x4dv, glProgramUniformMatrix3x4dv)
  GLdouble* value = OGLM_GET_VARARGS(value,4,GLdouble,NV,count*12);
  glProgramUniformMatrix3x4dv((GLuint )program, (GLint )location, (GLsizei )count, (GLboolean )transpose, (const GLdouble* )value);
  OGLM_CHECK_ERR(glProgramUniformMatrix3x4dv, free(value);)
  free(value);

void
glProgramUniformMatrix3x4fv_c(program, location, count, transpose, value)
  GLuint program;
  GLint location;
  GLsizei count;
  GLboolean transpose;
  const GLfloat* value;
ALIAS:
  glProgramUniformMatrix3x4fvEXT_c = 1
CODE:
  OGLM_GLEWINIT
  OGLM_CHECK_ERR(glProgramUniformMatrix3x4fv, )
  OGLM_AVAIL_CHECK(__glewProgramUniformMatrix3x4fv, glProgramUniformMatrix3x4fv)
  glProgramUniformMatrix3x4fv(program, location, count, transpose, value);
  OGLM_CHECK_ERR(glProgramUniformMatrix3x4fv, )

void
glProgramUniformMatrix3x4fv_p(program, location, count, transpose, ...)
  GLuint program;
  GLint location;
  GLsizei count;
  GLboolean transpose;
ALIAS:
  glProgramUniformMatrix3x4fvEXT_p = 1
CODE:
  OGLM_GLEWINIT
  OGLM_CHECK_ERR(glProgramUniformMatrix3x4fv, )
  OGLM_AVAIL_CHECK(__glewProgramUniformMatrix3x4fv, glProgramUniformMatrix3x4fv)
  GLfloat* value = OGLM_GET_VARARGS(value,4,GLfloat,NV,count*12);
  glProgramUniformMatrix3x4fv((GLuint )program, (GLint )location, (GLsizei )count, (GLboolean )transpose, (const GLfloat* )value);
  OGLM_CHECK_ERR(glProgramUniformMatrix3x4fv, free(value);)
  free(value);

void
glProgramUniformMatrix4dv_c(program, location, count, transpose, value)
  GLuint program;
  GLint location;
  GLsizei count;
  GLboolean transpose;
  const GLdouble* value;
CODE:
  OGLM_GLEWINIT
  OGLM_CHECK_ERR(glProgramUniformMatrix4dv, )
  OGLM_AVAIL_CHECK(__glewProgramUniformMatrix4dv, glProgramUniformMatrix4dv)
  glProgramUniformMatrix4dv(program, location, count, transpose, value);
  OGLM_CHECK_ERR(glProgramUniformMatrix4dv, )

void
glProgramUniformMatrix4dv_p(program, location, count, transpose, ...)
  GLuint program;
  GLint location;
  GLsizei count;
  GLboolean transpose;
CODE:
  OGLM_GLEWINIT
  OGLM_CHECK_ERR(glProgramUniformMatrix4dv, )
  OGLM_AVAIL_CHECK(__glewProgramUniformMatrix4dv, glProgramUniformMatrix4dv)
  GLdouble* value = OGLM_GET_VARARGS(value,4,GLdouble,NV,count*16);
  glProgramUniformMatrix4dv((GLuint )program, (GLint )location, (GLsizei )count, (GLboolean )transpose, (const GLdouble* )value);
  OGLM_CHECK_ERR(glProgramUniformMatrix4dv, free(value);)
  free(value);

void
glProgramUniformMatrix4fv_c(program, location, count, transpose, value)
  GLuint program;
  GLint location;
  GLsizei count;
  GLboolean transpose;
  const GLfloat* value;
ALIAS:
  glProgramUniformMatrix4fvEXT_c = 1
CODE:
  OGLM_GLEWINIT
  OGLM_CHECK_ERR(glProgramUniformMatrix4fv, )
  OGLM_AVAIL_CHECK(__glewProgramUniformMatrix4fv, glProgramUniformMatrix4fv)
  glProgramUniformMatrix4fv(program, location, count, transpose, value);
  OGLM_CHECK_ERR(glProgramUniformMatrix4fv, )

void
glProgramUniformMatrix4fv_p(program, location, count, transpose, ...)
  GLuint program;
  GLint location;
  GLsizei count;
  GLboolean transpose;
ALIAS:
  glProgramUniformMatrix4fvEXT_p = 1
CODE:
  OGLM_GLEWINIT
  OGLM_CHECK_ERR(glProgramUniformMatrix4fv, )
  OGLM_AVAIL_CHECK(__glewProgramUniformMatrix4fv, glProgramUniformMatrix4fv)
  GLfloat* value = OGLM_GET_VARARGS(value,4,GLfloat,NV,count*16);
  glProgramUniformMatrix4fv((GLuint )program, (GLint )location, (GLsizei )count, (GLboolean )transpose, (const GLfloat* )value);
  OGLM_CHECK_ERR(glProgramUniformMatrix4fv, free(value);)
  free(value);

void
glProgramUniformMatrix4x2dv_c(program, location, count, transpose, value)
  GLuint program;
  GLint location;
  GLsizei count;
  GLboolean transpose;
  const GLdouble* value;
CODE:
  OGLM_GLEWINIT
  OGLM_CHECK_ERR(glProgramUniformMatrix4x2dv, )
  OGLM_AVAIL_CHECK(__glewProgramUniformMatrix4x2dv, glProgramUniformMatrix4x2dv)
  glProgramUniformMatrix4x2dv(program, location, count, transpose, value);
  OGLM_CHECK_ERR(glProgramUniformMatrix4x2dv, )

void
glProgramUniformMatrix4x2dv_p(program, location, count, transpose, ...)
  GLuint program;
  GLint location;
  GLsizei count;
  GLboolean transpose;
CODE:
  OGLM_GLEWINIT
  OGLM_CHECK_ERR(glProgramUniformMatrix4x2dv, )
  OGLM_AVAIL_CHECK(__glewProgramUniformMatrix4x2dv, glProgramUniformMatrix4x2dv)
  GLdouble* value = OGLM_GET_VARARGS(value,4,GLdouble,NV,count*8);
  glProgramUniformMatrix4x2dv((GLuint )program, (GLint )location, (GLsizei )count, (GLboolean )transpose, (const GLdouble* )value);
  OGLM_CHECK_ERR(glProgramUniformMatrix4x2dv, free(value);)
  free(value);

void
glProgramUniformMatrix4x2fv_c(program, location, count, transpose, value)
  GLuint program;
  GLint location;
  GLsizei count;
  GLboolean transpose;
  const GLfloat* value;
ALIAS:
  glProgramUniformMatrix4x2fvEXT_c = 1
CODE:
  OGLM_GLEWINIT
  OGLM_CHECK_ERR(glProgramUniformMatrix4x2fv, )
  OGLM_AVAIL_CHECK(__glewProgramUniformMatrix4x2fv, glProgramUniformMatrix4x2fv)
  glProgramUniformMatrix4x2fv(program, location, count, transpose, value);
  OGLM_CHECK_ERR(glProgramUniformMatrix4x2fv, )

void
glProgramUniformMatrix4x2fv_p(program, location, count, transpose, ...)
  GLuint program;
  GLint location;
  GLsizei count;
  GLboolean transpose;
ALIAS:
  glProgramUniformMatrix4x2fvEXT_p = 1
CODE:
  OGLM_GLEWINIT
  OGLM_CHECK_ERR(glProgramUniformMatrix4x2fv, )
  OGLM_AVAIL_CHECK(__glewProgramUniformMatrix4x2fv, glProgramUniformMatrix4x2fv)
  GLfloat* value = OGLM_GET_VARARGS(value,4,GLfloat,NV,count*8);
  glProgramUniformMatrix4x2fv((GLuint )program, (GLint )location, (GLsizei )count, (GLboolean )transpose, (const GLfloat* )value);
  OGLM_CHECK_ERR(glProgramUniformMatrix4x2fv, free(value);)
  free(value);

void
glProgramUniformMatrix4x3dv_c(program, location, count, transpose, value)
  GLuint program;
  GLint location;
  GLsizei count;
  GLboolean transpose;
  const GLdouble* value;
CODE:
  OGLM_GLEWINIT
  OGLM_CHECK_ERR(glProgramUniformMatrix4x3dv, )
  OGLM_AVAIL_CHECK(__glewProgramUniformMatrix4x3dv, glProgramUniformMatrix4x3dv)
  glProgramUniformMatrix4x3dv(program, location, count, transpose, value);
  OGLM_CHECK_ERR(glProgramUniformMatrix4x3dv, )

void
glProgramUniformMatrix4x3dv_p(program, location, count, transpose, ...)
  GLuint program;
  GLint location;
  GLsizei count;
  GLboolean transpose;
CODE:
  OGLM_GLEWINIT
  OGLM_CHECK_ERR(glProgramUniformMatrix4x3dv, )
  OGLM_AVAIL_CHECK(__glewProgramUniformMatrix4x3dv, glProgramUniformMatrix4x3dv)
  GLdouble* value = OGLM_GET_VARARGS(value,4,GLdouble,NV,count*12);
  glProgramUniformMatrix4x3dv((GLuint )program, (GLint )location, (GLsizei )count, (GLboolean )transpose, (const GLdouble* )value);
  OGLM_CHECK_ERR(glProgramUniformMatrix4x3dv, free(value);)
  free(value);

void
glProgramUniformMatrix4x3fv_c(program, location, count, transpose, value)
  GLuint program;
  GLint location;
  GLsizei count;
  GLboolean transpose;
  const GLfloat* value;
ALIAS:
  glProgramUniformMatrix4x3fvEXT_c = 1
CODE:
  OGLM_GLEWINIT
  OGLM_CHECK_ERR(glProgramUniformMatrix4x3fv, )
  OGLM_AVAIL_CHECK(__glewProgramUniformMatrix4x3fv, glProgramUniformMatrix4x3fv)
  glProgramUniformMatrix4x3fv(program, location, count, transpose, value);
  OGLM_CHECK_ERR(glProgramUniformMatrix4x3fv, )

void
glProgramUniformMatrix4x3fv_p(program, location, count, transpose, ...)
  GLuint program;
  GLint location;
  GLsizei count;
  GLboolean transpose;
ALIAS:
  glProgramUniformMatrix4x3fvEXT_p = 1
CODE:
  OGLM_GLEWINIT
  OGLM_CHECK_ERR(glProgramUniformMatrix4x3fv, )
  OGLM_AVAIL_CHECK(__glewProgramUniformMatrix4x3fv, glProgramUniformMatrix4x3fv)
  GLfloat* value = OGLM_GET_VARARGS(value,4,GLfloat,NV,count*12);
  glProgramUniformMatrix4x3fv((GLuint )program, (GLint )location, (GLsizei )count, (GLboolean )transpose, (const GLfloat* )value);
  OGLM_CHECK_ERR(glProgramUniformMatrix4x3fv, free(value);)
  free(value);

void
glProgramUniformui64NV(program, location, value)
  GLuint program;
  GLint location;
  GLuint64EXT value;
CODE:
  OGLM_GLEWINIT
  OGLM_CHECK_ERR(glProgramUniformui64NV, )
  OGLM_AVAIL_CHECK(__glewProgramUniformui64NV, glProgramUniformui64NV)
  glProgramUniformui64NV(program, location, value);
  OGLM_CHECK_ERR(glProgramUniformui64NV, )

void
glProgramUniformui64vNV_c(program, location, count, value)
  GLuint program;
  GLint location;
  GLsizei count;
  const GLuint64EXT* value;
CODE:
  OGLM_GLEWINIT
  OGLM_CHECK_ERR(glProgramUniformui64vNV, )
  OGLM_AVAIL_CHECK(__glewProgramUniformui64vNV, glProgramUniformui64vNV)
  glProgramUniformui64vNV(program, location, count, value);
  OGLM_CHECK_ERR(glProgramUniformui64vNV, )

void
glProgramUniformui64vNV_p(program, location, ...)
  GLuint program;
  GLint location;
CODE:
  OGLM_GLEWINIT
  OGLM_CHECK_ERR(glProgramUniformui64vNV, )
  OGLM_AVAIL_CHECK(__glewProgramUniformui64vNV, glProgramUniformui64vNV)
  GLsizei count = items-2;
  GLuint64EXT* value = OGLM_GET_VARARGS(value,2,GLuint64EXT,UV,count);
  glProgramUniformui64vNV((GLuint )program, (GLint )location, (GLsizei )count, (const GLuint64EXT* )value);
  OGLM_CHECK_ERR(glProgramUniformui64vNV, free(value);)
  free(value);

void
glProgramVertexLimitNV(target, limit)
  GLenum target;
  GLint limit;
CODE:
  OGLM_GLEWINIT
  OGLM_CHECK_ERR(glProgramVertexLimitNV, )
  OGLM_AVAIL_CHECK(__glewProgramVertexLimitNV, glProgramVertexLimitNV)
  glProgramVertexLimitNV(target, limit);
  OGLM_CHECK_ERR(glProgramVertexLimitNV, )

void
glProvokingVertex(mode)
  GLenum mode;
ALIAS:
  glProvokingVertexEXT = 1
CODE:
  OGLM_GLEWINIT
  OGLM_CHECK_ERR(glProvokingVertex, )
  OGLM_AVAIL_CHECK(__glewProvokingVertex, glProvokingVertex)
  glProvokingVertex(mode);
  OGLM_CHECK_ERR(glProvokingVertex, )

void
glPushAttrib(mask)
  GLbitfield mask;
CODE:
  OGLM_GLEWINIT
  OGLM_CHECK_ERR(glPushAttrib, )
  glPushAttrib(mask);
  OGLM_CHECK_ERR(glPushAttrib, )

void
glPushClientAttrib(mask)
  GLbitfield mask;
CODE:
  OGLM_GLEWINIT
  OGLM_CHECK_ERR(glPushClientAttrib, )
  glPushClientAttrib(mask);
  OGLM_CHECK_ERR(glPushClientAttrib, )

void
glPushClientAttribDefaultEXT(mask)
  GLbitfield mask;
CODE:
  OGLM_GLEWINIT
  OGLM_CHECK_ERR(glPushClientAttribDefaultEXT, )
  OGLM_AVAIL_CHECK(__glewPushClientAttribDefaultEXT, glPushClientAttribDefaultEXT)
  glPushClientAttribDefaultEXT(mask);
  OGLM_CHECK_ERR(glPushClientAttribDefaultEXT, )

void
glPushDebugGroup(source, id, length, message)
  GLenum source;
  GLuint id;
  GLsizei length;
  const GLchar * message;
ALIAS:
  glPushDebugGroupKHR = 1
CODE:
  OGLM_GLEWINIT
  OGLM_CHECK_ERR(glPushDebugGroup, )
  OGLM_AVAIL_CHECK(__glewPushDebugGroup, glPushDebugGroup)
  glPushDebugGroup(source, id, length, message);
  OGLM_CHECK_ERR(glPushDebugGroup, )

void
glPushGroupMarkerEXT(length, marker)
  GLsizei length;
  const GLchar* marker;
CODE:
  OGLM_GLEWINIT
  OGLM_CHECK_ERR(glPushGroupMarkerEXT, )
  OGLM_AVAIL_CHECK(__glewPushGroupMarkerEXT, glPushGroupMarkerEXT)
  glPushGroupMarkerEXT(length, marker);
  OGLM_CHECK_ERR(glPushGroupMarkerEXT, )

void
glPushMatrix()
CODE:
  OGLM_GLEWINIT
  OGLM_CHECK_ERR(glPushMatrix, )
  glPushMatrix();
  OGLM_CHECK_ERR(glPushMatrix, )

void
glPushName(name)
  GLuint name;
CODE:
  OGLM_GLEWINIT
  OGLM_CHECK_ERR(glPushName, )
  glPushName(name);
  OGLM_CHECK_ERR(glPushName, )

void
glQueryCounter(id, target)
  GLuint id;
  GLenum target;
ALIAS:
  glQueryCounterEXT = 1
CODE:
  OGLM_GLEWINIT
  OGLM_CHECK_ERR(glQueryCounter, )
  OGLM_AVAIL_CHECK(__glewQueryCounter, glQueryCounter)
  glQueryCounter(id, target);
  OGLM_CHECK_ERR(glQueryCounter, )

void
glQueryCounterANGLE(id, target)
  GLuint id;
  GLenum target;
CODE:
  OGLM_GLEWINIT
  OGLM_CHECK_ERR(glQueryCounterANGLE, )
  OGLM_AVAIL_CHECK(__glewQueryCounterANGLE, glQueryCounterANGLE)
  glQueryCounterANGLE(id, target);
  OGLM_CHECK_ERR(glQueryCounterANGLE, )

void
glQueryObjectParameteruiAMD(target, id, pname, param)
  GLenum target;
  GLuint id;
  GLenum pname;
  GLuint param;
CODE:
  OGLM_GLEWINIT
  OGLM_CHECK_ERR(glQueryObjectParameteruiAMD, )
  OGLM_AVAIL_CHECK(__glewQueryObjectParameteruiAMD, glQueryObjectParameteruiAMD)
  glQueryObjectParameteruiAMD(target, id, pname, param);
  OGLM_CHECK_ERR(glQueryObjectParameteruiAMD, )

void
glRasterPos2d(x, y)
  GLdouble x;
  GLdouble y;
CODE:
  OGLM_GLEWINIT
  OGLM_CHECK_ERR(glRasterPos2d, )
  glRasterPos2d(x, y);
  OGLM_CHECK_ERR(glRasterPos2d, )

void
glRasterPos2dv_c(v)
  const GLdouble *v;
CODE:
  OGLM_GLEWINIT
  OGLM_CHECK_ERR(glRasterPos2dv, )
  glRasterPos2dv(v);
  OGLM_CHECK_ERR(glRasterPos2dv, )

void
glRasterPos2dv_p(...)
CODE:
  OGLM_GLEWINIT
  OGLM_CHECK_ERR(glRasterPos2dv, )
  GLdouble *v = OGLM_GET_VARARGS(v,0,GLdouble,NV,2);
  glRasterPos2dv((const GLdouble *)v);
  OGLM_CHECK_ERR(glRasterPos2dv, free(v);)
  free(v);

void
glRasterPos2f(x, y)
  GLfloat x;
  GLfloat y;
CODE:
  OGLM_GLEWINIT
  OGLM_CHECK_ERR(glRasterPos2f, )
  glRasterPos2f(x, y);
  OGLM_CHECK_ERR(glRasterPos2f, )

void
glRasterPos2fv_c(v)
  const GLfloat *v;
CODE:
  OGLM_GLEWINIT
  OGLM_CHECK_ERR(glRasterPos2fv, )
  glRasterPos2fv(v);
  OGLM_CHECK_ERR(glRasterPos2fv, )

void
glRasterPos2fv_p(...)
CODE:
  OGLM_GLEWINIT
  OGLM_CHECK_ERR(glRasterPos2fv, )
  GLfloat *v = OGLM_GET_VARARGS(v,0,GLfloat,NV,2);
  glRasterPos2fv((const GLfloat *)v);
  OGLM_CHECK_ERR(glRasterPos2fv, free(v);)
  free(v);

void
glRasterPos2i(x, y)
  GLint x;
  GLint y;
CODE:
  OGLM_GLEWINIT
  OGLM_CHECK_ERR(glRasterPos2i, )
  glRasterPos2i(x, y);
  OGLM_CHECK_ERR(glRasterPos2i, )

void
glRasterPos2iv_c(v)
  const GLint *v;
CODE:
  OGLM_GLEWINIT
  OGLM_CHECK_ERR(glRasterPos2iv, )
  glRasterPos2iv(v);
  OGLM_CHECK_ERR(glRasterPos2iv, )

void
glRasterPos2iv_p(...)
CODE:
  OGLM_GLEWINIT
  OGLM_CHECK_ERR(glRasterPos2iv, )
  GLint *v = OGLM_GET_VARARGS(v,0,GLint,IV,2);
  glRasterPos2iv((const GLint *)v);
  OGLM_CHECK_ERR(glRasterPos2iv, free(v);)
  free(v);

void
glRasterPos2s(x, y)
  GLshort x;
  GLshort y;
CODE:
  OGLM_GLEWINIT
  OGLM_CHECK_ERR(glRasterPos2s, )
  glRasterPos2s(x, y);
  OGLM_CHECK_ERR(glRasterPos2s, )

void
glRasterPos2sv_c(v)
  const GLshort *v;
CODE:
  OGLM_GLEWINIT
  OGLM_CHECK_ERR(glRasterPos2sv, )
  glRasterPos2sv(v);
  OGLM_CHECK_ERR(glRasterPos2sv, )

void
glRasterPos2sv_p(...)
CODE:
  OGLM_GLEWINIT
  OGLM_CHECK_ERR(glRasterPos2sv, )
  GLshort *v = OGLM_GET_VARARGS(v,0,GLshort,IV,2);
  glRasterPos2sv((const GLshort *)v);
  OGLM_CHECK_ERR(glRasterPos2sv, free(v);)
  free(v);

void
glRasterPos3d(x, y, z)
  GLdouble x;
  GLdouble y;
  GLdouble z;
CODE:
  OGLM_GLEWINIT
  OGLM_CHECK_ERR(glRasterPos3d, )
  glRasterPos3d(x, y, z);
  OGLM_CHECK_ERR(glRasterPos3d, )

void
glRasterPos3dv_c(v)
  const GLdouble *v;
CODE:
  OGLM_GLEWINIT
  OGLM_CHECK_ERR(glRasterPos3dv, )
  glRasterPos3dv(v);
  OGLM_CHECK_ERR(glRasterPos3dv, )

void
glRasterPos3dv_p(...)
CODE:
  OGLM_GLEWINIT
  OGLM_CHECK_ERR(glRasterPos3dv, )
  GLdouble *v = OGLM_GET_VARARGS(v,0,GLdouble,NV,3);
  glRasterPos3dv((const GLdouble *)v);
  OGLM_CHECK_ERR(glRasterPos3dv, free(v);)
  free(v);

void
glRasterPos3f(x, y, z)
  GLfloat x;
  GLfloat y;
  GLfloat z;
CODE:
  OGLM_GLEWINIT
  OGLM_CHECK_ERR(glRasterPos3f, )
  glRasterPos3f(x, y, z);
  OGLM_CHECK_ERR(glRasterPos3f, )

void
glRasterPos3fv_c(v)
  const GLfloat *v;
CODE:
  OGLM_GLEWINIT
  OGLM_CHECK_ERR(glRasterPos3fv, )
  glRasterPos3fv(v);
  OGLM_CHECK_ERR(glRasterPos3fv, )

void
glRasterPos3fv_p(...)
CODE:
  OGLM_GLEWINIT
  OGLM_CHECK_ERR(glRasterPos3fv, )
  GLfloat *v = OGLM_GET_VARARGS(v,0,GLfloat,NV,3);
  glRasterPos3fv((const GLfloat *)v);
  OGLM_CHECK_ERR(glRasterPos3fv, free(v);)
  free(v);

void
glRasterPos3i(x, y, z)
  GLint x;
  GLint y;
  GLint z;
CODE:
  OGLM_GLEWINIT
  OGLM_CHECK_ERR(glRasterPos3i, )
  glRasterPos3i(x, y, z);
  OGLM_CHECK_ERR(glRasterPos3i, )

void
glRasterPos3iv_c(v)
  const GLint *v;
CODE:
  OGLM_GLEWINIT
  OGLM_CHECK_ERR(glRasterPos3iv, )
  glRasterPos3iv(v);
  OGLM_CHECK_ERR(glRasterPos3iv, )

void
glRasterPos3iv_p(...)
CODE:
  OGLM_GLEWINIT
  OGLM_CHECK_ERR(glRasterPos3iv, )
  GLint *v = OGLM_GET_VARARGS(v,0,GLint,IV,3);
  glRasterPos3iv((const GLint *)v);
  OGLM_CHECK_ERR(glRasterPos3iv, free(v);)
  free(v);

void
glRasterPos3s(x, y, z)
  GLshort x;
  GLshort y;
  GLshort z;
CODE:
  OGLM_GLEWINIT
  OGLM_CHECK_ERR(glRasterPos3s, )
  glRasterPos3s(x, y, z);
  OGLM_CHECK_ERR(glRasterPos3s, )

void
glRasterPos3sv_c(v)
  const GLshort *v;
CODE:
  OGLM_GLEWINIT
  OGLM_CHECK_ERR(glRasterPos3sv, )
  glRasterPos3sv(v);
  OGLM_CHECK_ERR(glRasterPos3sv, )

void
glRasterPos3sv_p(...)
CODE:
  OGLM_GLEWINIT
  OGLM_CHECK_ERR(glRasterPos3sv, )
  GLshort *v = OGLM_GET_VARARGS(v,0,GLshort,IV,3);
  glRasterPos3sv((const GLshort *)v);
  OGLM_CHECK_ERR(glRasterPos3sv, free(v);)
  free(v);

void
glRasterPos4d(x, y, z, w)
  GLdouble x;
  GLdouble y;
  GLdouble z;
  GLdouble w;
CODE:
  OGLM_GLEWINIT
  OGLM_CHECK_ERR(glRasterPos4d, )
  glRasterPos4d(x, y, z, w);
  OGLM_CHECK_ERR(glRasterPos4d, )

void
glRasterPos4dv_c(v)
  const GLdouble *v;
CODE:
  OGLM_GLEWINIT
  OGLM_CHECK_ERR(glRasterPos4dv, )
  glRasterPos4dv(v);
  OGLM_CHECK_ERR(glRasterPos4dv, )

void
glRasterPos4dv_p(...)
CODE:
  OGLM_GLEWINIT
  OGLM_CHECK_ERR(glRasterPos4dv, )
  GLdouble *v = OGLM_GET_VARARGS(v,0,GLdouble,NV,4);
  glRasterPos4dv((const GLdouble *)v);
  OGLM_CHECK_ERR(glRasterPos4dv, free(v);)
  free(v);

void
glRasterPos4f(x, y, z, w)
  GLfloat x;
  GLfloat y;
  GLfloat z;
  GLfloat w;
CODE:
  OGLM_GLEWINIT
  OGLM_CHECK_ERR(glRasterPos4f, )
  glRasterPos4f(x, y, z, w);
  OGLM_CHECK_ERR(glRasterPos4f, )

void
glRasterPos4fv_c(v)
  const GLfloat *v;
CODE:
  OGLM_GLEWINIT
  OGLM_CHECK_ERR(glRasterPos4fv, )
  glRasterPos4fv(v);
  OGLM_CHECK_ERR(glRasterPos4fv, )

void
glRasterPos4fv_p(...)
CODE:
  OGLM_GLEWINIT
  OGLM_CHECK_ERR(glRasterPos4fv, )
  GLfloat *v = OGLM_GET_VARARGS(v,0,GLfloat,NV,4);
  glRasterPos4fv((const GLfloat *)v);
  OGLM_CHECK_ERR(glRasterPos4fv, free(v);)
  free(v);

void
glRasterPos4i(x, y, z, w)
  GLint x;
  GLint y;
  GLint z;
  GLint w;
CODE:
  OGLM_GLEWINIT
  OGLM_CHECK_ERR(glRasterPos4i, )
  glRasterPos4i(x, y, z, w);
  OGLM_CHECK_ERR(glRasterPos4i, )

void
glRasterPos4iv_c(v)
  const GLint *v;
CODE:
  OGLM_GLEWINIT
  OGLM_CHECK_ERR(glRasterPos4iv, )
  glRasterPos4iv(v);
  OGLM_CHECK_ERR(glRasterPos4iv, )

void
glRasterPos4iv_p(...)
CODE:
  OGLM_GLEWINIT
  OGLM_CHECK_ERR(glRasterPos4iv, )
  GLint *v = OGLM_GET_VARARGS(v,0,GLint,IV,4);
  glRasterPos4iv((const GLint *)v);
  OGLM_CHECK_ERR(glRasterPos4iv, free(v);)
  free(v);

void
glRasterPos4s(x, y, z, w)
  GLshort x;
  GLshort y;
  GLshort z;
  GLshort w;
CODE:
  OGLM_GLEWINIT
  OGLM_CHECK_ERR(glRasterPos4s, )
  glRasterPos4s(x, y, z, w);
  OGLM_CHECK_ERR(glRasterPos4s, )

void
glRasterPos4sv_c(v)
  const GLshort *v;
CODE:
  OGLM_GLEWINIT
  OGLM_CHECK_ERR(glRasterPos4sv, )
  glRasterPos4sv(v);
  OGLM_CHECK_ERR(glRasterPos4sv, )

void
glRasterPos4sv_p(...)
CODE:
  OGLM_GLEWINIT
  OGLM_CHECK_ERR(glRasterPos4sv, )
  GLshort *v = OGLM_GET_VARARGS(v,0,GLshort,IV,4);
  glRasterPos4sv((const GLshort *)v);
  OGLM_CHECK_ERR(glRasterPos4sv, free(v);)
  free(v);

void
glRasterSamplesEXT(samples, fixedsamplelocations)
  GLuint samples;
  GLboolean fixedsamplelocations;
CODE:
  OGLM_GLEWINIT
  OGLM_CHECK_ERR(glRasterSamplesEXT, )
  OGLM_AVAIL_CHECK(__glewRasterSamplesEXT, glRasterSamplesEXT)
  glRasterSamplesEXT(samples, fixedsamplelocations);
  OGLM_CHECK_ERR(glRasterSamplesEXT, )

void
glReadBuffer(src)
  GLenum src;
CODE:
  OGLM_GLEWINIT
  OGLM_CHECK_ERR(glReadBuffer, )
  glReadBuffer(src);
  OGLM_CHECK_ERR(glReadBuffer, )

void
glReadBufferIndexedEXT(src, index)
  GLenum src;
  GLint index;
CODE:
  OGLM_GLEWINIT
  OGLM_CHECK_ERR(glReadBufferIndexedEXT, )
  OGLM_AVAIL_CHECK(__glewReadBufferIndexedEXT, glReadBufferIndexedEXT)
  glReadBufferIndexedEXT(src, index);
  OGLM_CHECK_ERR(glReadBufferIndexedEXT, )

void
glReadBufferNV(mode)
  GLenum mode;
CODE:
  OGLM_GLEWINIT
  OGLM_CHECK_ERR(glReadBufferNV, )
  OGLM_AVAIL_CHECK(__glewReadBufferNV, glReadBufferNV)
  glReadBufferNV(mode);
  OGLM_CHECK_ERR(glReadBufferNV, )

void
glReadBufferRegion(region, x, y, width, height)
  GLuint region;
  GLint x;
  GLint y;
  GLsizei width;
  GLsizei height;
CODE:
  OGLM_GLEWINIT
  OGLM_CHECK_ERR(glReadBufferRegion, )
  OGLM_AVAIL_CHECK(__glewReadBufferRegion, glReadBufferRegion)
  glReadBufferRegion(region, x, y, width, height);
  OGLM_CHECK_ERR(glReadBufferRegion, )

void
glReadPixels_c(x, y, width, height, format, type, pixels)
  GLint x;
  GLint y;
  GLsizei width;
  GLsizei height;
  GLenum format;
  GLenum type;
  void *pixels;
CODE:
  OGLM_GLEWINIT
  OGLM_CHECK_ERR(glReadPixels, )
  glReadPixels(x, y, width, height, format, type, pixels);
  OGLM_CHECK_ERR(glReadPixels, )

void
glReadVideoPixelsSUN_c(x, y, width, height, format, type, pixels)
  GLint x;
  GLint y;
  GLsizei width;
  GLsizei height;
  GLenum format;
  GLenum type;
  void* pixels;
CODE:
  OGLM_GLEWINIT
  OGLM_CHECK_ERR(glReadVideoPixelsSUN, )
  OGLM_AVAIL_CHECK(__glewReadVideoPixelsSUN, glReadVideoPixelsSUN)
  glReadVideoPixelsSUN(x, y, width, height, format, type, pixels);
  OGLM_CHECK_ERR(glReadVideoPixelsSUN, )

void
glReadnPixels_c(x, y, width, height, format, type, bufSize, data)
  GLint x;
  GLint y;
  GLsizei width;
  GLsizei height;
  GLenum format;
  GLenum type;
  GLsizei bufSize;
  void *data;
ALIAS:
  glReadnPixelsARB_c = 1
  glReadnPixelsEXT_c = 2
  glReadnPixelsKHR_c = 3
CODE:
  OGLM_GLEWINIT
  OGLM_CHECK_ERR(glReadnPixels, )
  OGLM_AVAIL_CHECK(__glewReadnPixels, glReadnPixels)
  glReadnPixels(x, y, width, height, format, type, bufSize, data);
  OGLM_CHECK_ERR(glReadnPixels, )

void
glRectd(x1, y1, x2, y2)
  GLdouble x1;
  GLdouble y1;
  GLdouble x2;
  GLdouble y2;
CODE:
  OGLM_GLEWINIT
  OGLM_CHECK_ERR(glRectd, )
  glRectd(x1, y1, x2, y2);
  OGLM_CHECK_ERR(glRectd, )

void
glRectdv_c(v1, v2)
  const GLdouble *v1;
  const GLdouble *v2;
CODE:
  OGLM_GLEWINIT
  OGLM_CHECK_ERR(glRectdv, )
  glRectdv(v1, v2);
  OGLM_CHECK_ERR(glRectdv, )

void
glRectdv_p(v1SV, v2SV)
  SV *v1SV;
  SV *v2SV;
CODE:
  OGLM_GLEWINIT
  OGLM_CHECK_ERR(glRectdv, )
  GLdouble *v1 = OGLM_GET_ARRAY(v1, GLdouble, NV, 2);
  GLdouble *v2 = OGLM_GET_ARRAY(v2, GLdouble, NV, 2);
  glRectdv((const GLdouble *)v1, (const GLdouble *)v2);
  OGLM_CHECK_ERR(glRectdv, free(v1);free(v2);)
  free(v1);free(v2);

void
glRectf(x1, y1, x2, y2)
  GLfloat x1;
  GLfloat y1;
  GLfloat x2;
  GLfloat y2;
CODE:
  OGLM_GLEWINIT
  OGLM_CHECK_ERR(glRectf, )
  glRectf(x1, y1, x2, y2);
  OGLM_CHECK_ERR(glRectf, )

void
glRectfv_c(v1, v2)
  const GLfloat *v1;
  const GLfloat *v2;
CODE:
  OGLM_GLEWINIT
  OGLM_CHECK_ERR(glRectfv, )
  glRectfv(v1, v2);
  OGLM_CHECK_ERR(glRectfv, )

void
glRectfv_p(v1SV, v2SV)
  SV *v1SV;
  SV *v2SV;
CODE:
  OGLM_GLEWINIT
  OGLM_CHECK_ERR(glRectfv, )
  GLfloat *v1 = OGLM_GET_ARRAY(v1, GLfloat, NV, 2);
  GLfloat *v2 = OGLM_GET_ARRAY(v2, GLfloat, NV, 2);
  glRectfv((const GLfloat *)v1, (const GLfloat *)v2);
  OGLM_CHECK_ERR(glRectfv, free(v1);free(v2);)
  free(v1);free(v2);

void
glRecti(x1, y1, x2, y2)
  GLint x1;
  GLint y1;
  GLint x2;
  GLint y2;
CODE:
  OGLM_GLEWINIT
  OGLM_CHECK_ERR(glRecti, )
  glRecti(x1, y1, x2, y2);
  OGLM_CHECK_ERR(glRecti, )

void
glRectiv_c(v1, v2)
  const GLint *v1;
  const GLint *v2;
CODE:
  OGLM_GLEWINIT
  OGLM_CHECK_ERR(glRectiv, )
  glRectiv(v1, v2);
  OGLM_CHECK_ERR(glRectiv, )

void
glRectiv_p(v1SV, v2SV)
  SV *v1SV;
  SV *v2SV;
CODE:
  OGLM_GLEWINIT
  OGLM_CHECK_ERR(glRectiv, )
  GLint *v1 = OGLM_GET_ARRAY(v1, GLint, IV, 2);
  GLint *v2 = OGLM_GET_ARRAY(v2, GLint, IV, 2);
  glRectiv((const GLint *)v1, (const GLint *)v2);
  OGLM_CHECK_ERR(glRectiv, free(v1);free(v2);)
  free(v1);free(v2);

void
glRects(x1, y1, x2, y2)
  GLshort x1;
  GLshort y1;
  GLshort x2;
  GLshort y2;
CODE:
  OGLM_GLEWINIT
  OGLM_CHECK_ERR(glRects, )
  glRects(x1, y1, x2, y2);
  OGLM_CHECK_ERR(glRects, )

void
glRectsv_c(v1, v2)
  const GLshort *v1;
  const GLshort *v2;
CODE:
  OGLM_GLEWINIT
  OGLM_CHECK_ERR(glRectsv, )
  glRectsv(v1, v2);
  OGLM_CHECK_ERR(glRectsv, )

void
glRectsv_p(v1SV, v2SV)
  SV *v1SV;
  SV *v2SV;
CODE:
  OGLM_GLEWINIT
  OGLM_CHECK_ERR(glRectsv, )
  GLshort *v1 = OGLM_GET_ARRAY(v1, GLshort, IV, 2);
  GLshort *v2 = OGLM_GET_ARRAY(v2, GLshort, IV, 2);
  glRectsv((const GLshort *)v1, (const GLshort *)v2);
  OGLM_CHECK_ERR(glRectsv, free(v1);free(v2);)
  free(v1);free(v2);

void
glReferencePlaneSGIX_c(equation)
  const GLdouble* equation;
CODE:
  OGLM_GLEWINIT
  OGLM_CHECK_ERR(glReferencePlaneSGIX, )
  OGLM_AVAIL_CHECK(__glewReferencePlaneSGIX, glReferencePlaneSGIX)
  glReferencePlaneSGIX(equation);
  OGLM_CHECK_ERR(glReferencePlaneSGIX, )

void
glReferencePlaneSGIX_p(...)
CODE:
  OGLM_GLEWINIT
  OGLM_CHECK_ERR(glReferencePlaneSGIX, )
  OGLM_AVAIL_CHECK(__glewReferencePlaneSGIX, glReferencePlaneSGIX)
  GLdouble* equation = OGLM_GET_VARARGS(equation,0,GLdouble,NV,4);
  glReferencePlaneSGIX((const GLdouble* )equation);
  OGLM_CHECK_ERR(glReferencePlaneSGIX, free(equation);)
  free(equation);

GLboolean
glReleaseKeyedMutexWin32EXT(memory, key)
  GLuint memory;
  GLuint64 key;
CODE:
  OGLM_GLEWINIT
  OGLM_CHECK_ERR(glReleaseKeyedMutexWin32EXT, )
  OGLM_AVAIL_CHECK(__glewReleaseKeyedMutexWin32EXT, glReleaseKeyedMutexWin32EXT)
  RETVAL = glReleaseKeyedMutexWin32EXT(memory, key);
  OGLM_CHECK_ERR(glReleaseKeyedMutexWin32EXT, )
OUTPUT:
  RETVAL

void
glReleaseShaderCompiler()
CODE:
  OGLM_GLEWINIT
  OGLM_CHECK_ERR(glReleaseShaderCompiler, )
  OGLM_AVAIL_CHECK(__glewReleaseShaderCompiler, glReleaseShaderCompiler)
  glReleaseShaderCompiler();
  OGLM_CHECK_ERR(glReleaseShaderCompiler, )

void
glRenderGpuMaskNV(mask)
  GLbitfield mask;
CODE:
  OGLM_GLEWINIT
  OGLM_CHECK_ERR(glRenderGpuMaskNV, )
  OGLM_AVAIL_CHECK(__glewRenderGpuMaskNV, glRenderGpuMaskNV)
  glRenderGpuMaskNV(mask);
  OGLM_CHECK_ERR(glRenderGpuMaskNV, )

GLint
glRenderMode(mode)
  GLenum mode;
CODE:
  OGLM_GLEWINIT
  OGLM_CHECK_ERR(glRenderMode, )
  RETVAL = glRenderMode(mode);
  OGLM_CHECK_ERR(glRenderMode, )
OUTPUT:
  RETVAL

void
glRenderbufferStorage(target, internalformat, width, height)
  GLenum target;
  GLenum internalformat;
  GLsizei width;
  GLsizei height;
ALIAS:
  glRenderbufferStorageEXT = 1
CODE:
  OGLM_GLEWINIT
  OGLM_CHECK_ERR(glRenderbufferStorage, )
  OGLM_AVAIL_CHECK(__glewRenderbufferStorage, glRenderbufferStorage)
  glRenderbufferStorage(target, internalformat, width, height);
  OGLM_CHECK_ERR(glRenderbufferStorage, )

void
glRenderbufferStorageMultisample(target, samples, internalformat, width, height)
  GLenum target;
  GLsizei samples;
  GLenum internalformat;
  GLsizei width;
  GLsizei height;
ALIAS:
  glRenderbufferStorageMultisampleEXT = 1
  glRenderbufferStorageMultisampleNV = 2
CODE:
  OGLM_GLEWINIT
  OGLM_CHECK_ERR(glRenderbufferStorageMultisample, )
  OGLM_AVAIL_CHECK(__glewRenderbufferStorageMultisample, glRenderbufferStorageMultisample)
  glRenderbufferStorageMultisample(target, samples, internalformat, width, height);
  OGLM_CHECK_ERR(glRenderbufferStorageMultisample, )

void
glRenderbufferStorageMultisampleANGLE(target, samples, internalformat, width, height)
  GLenum target;
  GLsizei samples;
  GLenum internalformat;
  GLsizei width;
  GLsizei height;
CODE:
  OGLM_GLEWINIT
  OGLM_CHECK_ERR(glRenderbufferStorageMultisampleANGLE, )
  OGLM_AVAIL_CHECK(__glewRenderbufferStorageMultisampleANGLE, glRenderbufferStorageMultisampleANGLE)
  glRenderbufferStorageMultisampleANGLE(target, samples, internalformat, width, height);
  OGLM_CHECK_ERR(glRenderbufferStorageMultisampleANGLE, )

void
glRenderbufferStorageMultisampleAPPLE(target, samples, internalformat, width, height)
  GLenum target;
  GLsizei samples;
  GLenum internalformat;
  GLsizei width;
  GLsizei height;
CODE:
  OGLM_GLEWINIT
  OGLM_CHECK_ERR(glRenderbufferStorageMultisampleAPPLE, )
  OGLM_AVAIL_CHECK(__glewRenderbufferStorageMultisampleAPPLE, glRenderbufferStorageMultisampleAPPLE)
  glRenderbufferStorageMultisampleAPPLE(target, samples, internalformat, width, height);
  OGLM_CHECK_ERR(glRenderbufferStorageMultisampleAPPLE, )

void
glRenderbufferStorageMultisampleAdvancedAMD(target, samples, storageSamples, internalformat, width, height)
  GLenum target;
  GLsizei samples;
  GLsizei storageSamples;
  GLenum internalformat;
  GLsizei width;
  GLsizei height;
CODE:
  OGLM_GLEWINIT
  OGLM_CHECK_ERR(glRenderbufferStorageMultisampleAdvancedAMD, )
  OGLM_AVAIL_CHECK(__glewRenderbufferStorageMultisampleAdvancedAMD, glRenderbufferStorageMultisampleAdvancedAMD)
  glRenderbufferStorageMultisampleAdvancedAMD(target, samples, storageSamples, internalformat, width, height);
  OGLM_CHECK_ERR(glRenderbufferStorageMultisampleAdvancedAMD, )

void
glRenderbufferStorageMultisampleCoverageNV(target, coverageSamples, colorSamples, internalformat, width, height)
  GLenum target;
  GLsizei coverageSamples;
  GLsizei colorSamples;
  GLenum internalformat;
  GLsizei width;
  GLsizei height;
CODE:
  OGLM_GLEWINIT
  OGLM_CHECK_ERR(glRenderbufferStorageMultisampleCoverageNV, )
  OGLM_AVAIL_CHECK(__glewRenderbufferStorageMultisampleCoverageNV, glRenderbufferStorageMultisampleCoverageNV)
  glRenderbufferStorageMultisampleCoverageNV(target, coverageSamples, colorSamples, internalformat, width, height);
  OGLM_CHECK_ERR(glRenderbufferStorageMultisampleCoverageNV, )

void
glRenderbufferStorageMultisampleIMG(target, samples, internalformat, width, height)
  GLenum target;
  GLsizei samples;
  GLenum internalformat;
  GLsizei width;
  GLsizei height;
CODE:
  OGLM_GLEWINIT
  OGLM_CHECK_ERR(glRenderbufferStorageMultisampleIMG, )
  OGLM_AVAIL_CHECK(__glewRenderbufferStorageMultisampleIMG, glRenderbufferStorageMultisampleIMG)
  glRenderbufferStorageMultisampleIMG(target, samples, internalformat, width, height);
  OGLM_CHECK_ERR(glRenderbufferStorageMultisampleIMG, )

void
glRenderbufferStorageOES(target, internalformat, width, height)
  GLenum target;
  GLenum internalformat;
  GLsizei width;
  GLsizei height;
CODE:
  OGLM_GLEWINIT
  OGLM_CHECK_ERR(glRenderbufferStorageOES, )
  OGLM_AVAIL_CHECK(__glewRenderbufferStorageOES, glRenderbufferStorageOES)
  glRenderbufferStorageOES(target, internalformat, width, height);
  OGLM_CHECK_ERR(glRenderbufferStorageOES, )

void
glReplacementCodePointerSUN_c(type, stride, pointer)
  GLenum type;
  GLsizei stride;
  const void *pointer;
CODE:
  OGLM_GLEWINIT
  OGLM_CHECK_ERR(glReplacementCodePointerSUN, )
  OGLM_AVAIL_CHECK(__glewReplacementCodePointerSUN, glReplacementCodePointerSUN)
  glReplacementCodePointerSUN(type, stride, pointer);
  OGLM_CHECK_ERR(glReplacementCodePointerSUN, )

void
glReplacementCodeubSUN(code)
  GLubyte code;
CODE:
  OGLM_GLEWINIT
  OGLM_CHECK_ERR(glReplacementCodeubSUN, )
  OGLM_AVAIL_CHECK(__glewReplacementCodeubSUN, glReplacementCodeubSUN)
  glReplacementCodeubSUN(code);
  OGLM_CHECK_ERR(glReplacementCodeubSUN, )

void
glReplacementCodeubvSUN_c(code)
  const GLubyte* code;
CODE:
  OGLM_GLEWINIT
  OGLM_CHECK_ERR(glReplacementCodeubvSUN, )
  OGLM_AVAIL_CHECK(__glewReplacementCodeubvSUN, glReplacementCodeubvSUN)
  glReplacementCodeubvSUN(code);
  OGLM_CHECK_ERR(glReplacementCodeubvSUN, )

void
glReplacementCodeuiColor3fVertex3fSUN(rc, r, g, b, x, y, z)
  GLuint rc;
  GLfloat r;
  GLfloat g;
  GLfloat b;
  GLfloat x;
  GLfloat y;
  GLfloat z;
CODE:
  OGLM_GLEWINIT
  OGLM_CHECK_ERR(glReplacementCodeuiColor3fVertex3fSUN, )
  OGLM_AVAIL_CHECK(__glewReplacementCodeuiColor3fVertex3fSUN, glReplacementCodeuiColor3fVertex3fSUN)
  glReplacementCodeuiColor3fVertex3fSUN(rc, r, g, b, x, y, z);
  OGLM_CHECK_ERR(glReplacementCodeuiColor3fVertex3fSUN, )

void
glReplacementCodeuiColor3fVertex3fvSUN_c(rc, c, v)
  const GLuint* rc;
  const GLfloat *c;
  const GLfloat *v;
CODE:
  OGLM_GLEWINIT
  OGLM_CHECK_ERR(glReplacementCodeuiColor3fVertex3fvSUN, )
  OGLM_AVAIL_CHECK(__glewReplacementCodeuiColor3fVertex3fvSUN, glReplacementCodeuiColor3fVertex3fvSUN)
  glReplacementCodeuiColor3fVertex3fvSUN(rc, c, v);
  OGLM_CHECK_ERR(glReplacementCodeuiColor3fVertex3fvSUN, )

void
glReplacementCodeuiColor3fVertex3fvSUN_p(rcSV, cSV, vSV)
  SV *rcSV;
  SV *cSV;
  SV *vSV;
CODE:
  OGLM_GLEWINIT
  OGLM_CHECK_ERR(glReplacementCodeuiColor3fVertex3fvSUN, )
  OGLM_AVAIL_CHECK(__glewReplacementCodeuiColor3fVertex3fvSUN, glReplacementCodeuiColor3fVertex3fvSUN)
  GLfloat *c = OGLM_GET_ARRAY(c, GLfloat, NV, 3);
  GLuint* rc = OGLM_GET_ARRAY(rc, GLuint, UV, 1);
  GLfloat *v = OGLM_GET_ARRAY(v, GLfloat, NV, 3);
  glReplacementCodeuiColor3fVertex3fvSUN((const GLuint* )rc, (const GLfloat *)c, (const GLfloat *)v);
  OGLM_CHECK_ERR(glReplacementCodeuiColor3fVertex3fvSUN, free(c);free(rc);free(v);)
  free(c);free(rc);free(v);

void
glReplacementCodeuiColor4fNormal3fVertex3fSUN(rc, r, g, b, a, nx, ny, nz, x, y, z)
  GLuint rc;
  GLfloat r;
  GLfloat g;
  GLfloat b;
  GLfloat a;
  GLfloat nx;
  GLfloat ny;
  GLfloat nz;
  GLfloat x;
  GLfloat y;
  GLfloat z;
CODE:
  OGLM_GLEWINIT
  OGLM_CHECK_ERR(glReplacementCodeuiColor4fNormal3fVertex3fSUN, )
  OGLM_AVAIL_CHECK(__glewReplacementCodeuiColor4fNormal3fVertex3fSUN, glReplacementCodeuiColor4fNormal3fVertex3fSUN)
  glReplacementCodeuiColor4fNormal3fVertex3fSUN(rc, r, g, b, a, nx, ny, nz, x, y, z);
  OGLM_CHECK_ERR(glReplacementCodeuiColor4fNormal3fVertex3fSUN, )

void
glReplacementCodeuiColor4fNormal3fVertex3fvSUN_c(rc, c, n, v)
  const GLuint* rc;
  const GLfloat *c;
  const GLfloat *n;
  const GLfloat *v;
CODE:
  OGLM_GLEWINIT
  OGLM_CHECK_ERR(glReplacementCodeuiColor4fNormal3fVertex3fvSUN, )
  OGLM_AVAIL_CHECK(__glewReplacementCodeuiColor4fNormal3fVertex3fvSUN, glReplacementCodeuiColor4fNormal3fVertex3fvSUN)
  glReplacementCodeuiColor4fNormal3fVertex3fvSUN(rc, c, n, v);
  OGLM_CHECK_ERR(glReplacementCodeuiColor4fNormal3fVertex3fvSUN, )

void
glReplacementCodeuiColor4fNormal3fVertex3fvSUN_p(rcSV, cSV, nSV, vSV)
  SV *rcSV;
  SV *cSV;
  SV *nSV;
  SV *vSV;
CODE:
  OGLM_GLEWINIT
  OGLM_CHECK_ERR(glReplacementCodeuiColor4fNormal3fVertex3fvSUN, )
  OGLM_AVAIL_CHECK(__glewReplacementCodeuiColor4fNormal3fVertex3fvSUN, glReplacementCodeuiColor4fNormal3fVertex3fvSUN)
  GLfloat *c = OGLM_GET_ARRAY(c, GLfloat, NV, 4);
  GLfloat *n = OGLM_GET_ARRAY(n, GLfloat, NV, 3);
  GLuint* rc = OGLM_GET_ARRAY(rc, GLuint, UV, 1);
  GLfloat *v = OGLM_GET_ARRAY(v, GLfloat, NV, 3);
  glReplacementCodeuiColor4fNormal3fVertex3fvSUN((const GLuint* )rc, (const GLfloat *)c, (const GLfloat *)n, (const GLfloat *)v);
  OGLM_CHECK_ERR(glReplacementCodeuiColor4fNormal3fVertex3fvSUN, free(c);free(n);free(rc);free(v);)
  free(c);free(n);free(rc);free(v);

void
glReplacementCodeuiColor4ubVertex3fSUN(rc, r, g, b, a, x, y, z)
  GLuint rc;
  GLubyte r;
  GLubyte g;
  GLubyte b;
  GLubyte a;
  GLfloat x;
  GLfloat y;
  GLfloat z;
CODE:
  OGLM_GLEWINIT
  OGLM_CHECK_ERR(glReplacementCodeuiColor4ubVertex3fSUN, )
  OGLM_AVAIL_CHECK(__glewReplacementCodeuiColor4ubVertex3fSUN, glReplacementCodeuiColor4ubVertex3fSUN)
  glReplacementCodeuiColor4ubVertex3fSUN(rc, r, g, b, a, x, y, z);
  OGLM_CHECK_ERR(glReplacementCodeuiColor4ubVertex3fSUN, )

void
glReplacementCodeuiColor4ubVertex3fvSUN_c(rc, c, v)
  const GLuint* rc;
  const GLubyte *c;
  const GLfloat *v;
CODE:
  OGLM_GLEWINIT
  OGLM_CHECK_ERR(glReplacementCodeuiColor4ubVertex3fvSUN, )
  OGLM_AVAIL_CHECK(__glewReplacementCodeuiColor4ubVertex3fvSUN, glReplacementCodeuiColor4ubVertex3fvSUN)
  glReplacementCodeuiColor4ubVertex3fvSUN(rc, c, v);
  OGLM_CHECK_ERR(glReplacementCodeuiColor4ubVertex3fvSUN, )

void
glReplacementCodeuiColor4ubVertex3fvSUN_p(rcSV, cSV, vSV)
  SV *rcSV;
  SV *cSV;
  SV *vSV;
CODE:
  OGLM_GLEWINIT
  OGLM_CHECK_ERR(glReplacementCodeuiColor4ubVertex3fvSUN, )
  OGLM_AVAIL_CHECK(__glewReplacementCodeuiColor4ubVertex3fvSUN, glReplacementCodeuiColor4ubVertex3fvSUN)
  GLubyte *c = OGLM_GET_ARRAY(c, GLubyte, UV, 4);
  GLuint* rc = OGLM_GET_ARRAY(rc, GLuint, UV, 1);
  GLfloat *v = OGLM_GET_ARRAY(v, GLfloat, NV, 3);
  glReplacementCodeuiColor4ubVertex3fvSUN((const GLuint* )rc, (const GLubyte *)c, (const GLfloat *)v);
  OGLM_CHECK_ERR(glReplacementCodeuiColor4ubVertex3fvSUN, free(c);free(rc);free(v);)
  free(c);free(rc);free(v);

void
glReplacementCodeuiNormal3fVertex3fSUN(rc, nx, ny, nz, x, y, z)
  GLuint rc;
  GLfloat nx;
  GLfloat ny;
  GLfloat nz;
  GLfloat x;
  GLfloat y;
  GLfloat z;
CODE:
  OGLM_GLEWINIT
  OGLM_CHECK_ERR(glReplacementCodeuiNormal3fVertex3fSUN, )
  OGLM_AVAIL_CHECK(__glewReplacementCodeuiNormal3fVertex3fSUN, glReplacementCodeuiNormal3fVertex3fSUN)
  glReplacementCodeuiNormal3fVertex3fSUN(rc, nx, ny, nz, x, y, z);
  OGLM_CHECK_ERR(glReplacementCodeuiNormal3fVertex3fSUN, )

void
glReplacementCodeuiNormal3fVertex3fvSUN_c(rc, n, v)
  const GLuint* rc;
  const GLfloat *n;
  const GLfloat *v;
CODE:
  OGLM_GLEWINIT
  OGLM_CHECK_ERR(glReplacementCodeuiNormal3fVertex3fvSUN, )
  OGLM_AVAIL_CHECK(__glewReplacementCodeuiNormal3fVertex3fvSUN, glReplacementCodeuiNormal3fVertex3fvSUN)
  glReplacementCodeuiNormal3fVertex3fvSUN(rc, n, v);
  OGLM_CHECK_ERR(glReplacementCodeuiNormal3fVertex3fvSUN, )

void
glReplacementCodeuiNormal3fVertex3fvSUN_p(rcSV, nSV, vSV)
  SV *rcSV;
  SV *nSV;
  SV *vSV;
CODE:
  OGLM_GLEWINIT
  OGLM_CHECK_ERR(glReplacementCodeuiNormal3fVertex3fvSUN, )
  OGLM_AVAIL_CHECK(__glewReplacementCodeuiNormal3fVertex3fvSUN, glReplacementCodeuiNormal3fVertex3fvSUN)
  GLfloat *n = OGLM_GET_ARRAY(n, GLfloat, NV, 3);
  GLuint* rc = OGLM_GET_ARRAY(rc, GLuint, UV, 1);
  GLfloat *v = OGLM_GET_ARRAY(v, GLfloat, NV, 3);
  glReplacementCodeuiNormal3fVertex3fvSUN((const GLuint* )rc, (const GLfloat *)n, (const GLfloat *)v);
  OGLM_CHECK_ERR(glReplacementCodeuiNormal3fVertex3fvSUN, free(n);free(rc);free(v);)
  free(n);free(rc);free(v);

void
glReplacementCodeuiSUN(code)
  GLuint code;
CODE:
  OGLM_GLEWINIT
  OGLM_CHECK_ERR(glReplacementCodeuiSUN, )
  OGLM_AVAIL_CHECK(__glewReplacementCodeuiSUN, glReplacementCodeuiSUN)
  glReplacementCodeuiSUN(code);
  OGLM_CHECK_ERR(glReplacementCodeuiSUN, )

void
glReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fSUN(rc, s, t, r, g, b, a, nx, ny, nz, x, y, z)
  GLuint rc;
  GLfloat s;
  GLfloat t;
  GLfloat r;
  GLfloat g;
  GLfloat b;
  GLfloat a;
  GLfloat nx;
  GLfloat ny;
  GLfloat nz;
  GLfloat x;
  GLfloat y;
  GLfloat z;
CODE:
  OGLM_GLEWINIT
  OGLM_CHECK_ERR(glReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fSUN, )
  OGLM_AVAIL_CHECK(__glewReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fSUN, glReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fSUN)
  glReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fSUN(rc, s, t, r, g, b, a, nx, ny, nz, x, y, z);
  OGLM_CHECK_ERR(glReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fSUN, )

void
glReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN_c(rc, tc, c, n, v)
  const GLuint* rc;
  const GLfloat *tc;
  const GLfloat *c;
  const GLfloat *n;
  const GLfloat *v;
CODE:
  OGLM_GLEWINIT
  OGLM_CHECK_ERR(glReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN, )
  OGLM_AVAIL_CHECK(__glewReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN, glReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN)
  glReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN(rc, tc, c, n, v);
  OGLM_CHECK_ERR(glReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN, )

void
glReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN_p(rcSV, tcSV, cSV, nSV, vSV)
  SV *rcSV;
  SV *tcSV;
  SV *cSV;
  SV *nSV;
  SV *vSV;
CODE:
  OGLM_GLEWINIT
  OGLM_CHECK_ERR(glReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN, )
  OGLM_AVAIL_CHECK(__glewReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN, glReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN)
  GLfloat *c = OGLM_GET_ARRAY(c, GLfloat, NV, 4);
  GLfloat *n = OGLM_GET_ARRAY(n, GLfloat, NV, 3);
  GLuint* rc = OGLM_GET_ARRAY(rc, GLuint, UV, 1);
  GLfloat *tc = OGLM_GET_ARRAY(tc, GLfloat, NV, 2);
  GLfloat *v = OGLM_GET_ARRAY(v, GLfloat, NV, 3);
  glReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN((const GLuint* )rc, (const GLfloat *)tc, (const GLfloat *)c, (const GLfloat *)n, (const GLfloat *)v);
  OGLM_CHECK_ERR(glReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN, free(c);free(n);free(rc);free(tc);free(v);)
  free(c);free(n);free(rc);free(tc);free(v);

void
glReplacementCodeuiTexCoord2fNormal3fVertex3fSUN(rc, s, t, nx, ny, nz, x, y, z)
  GLuint rc;
  GLfloat s;
  GLfloat t;
  GLfloat nx;
  GLfloat ny;
  GLfloat nz;
  GLfloat x;
  GLfloat y;
  GLfloat z;
CODE:
  OGLM_GLEWINIT
  OGLM_CHECK_ERR(glReplacementCodeuiTexCoord2fNormal3fVertex3fSUN, )
  OGLM_AVAIL_CHECK(__glewReplacementCodeuiTexCoord2fNormal3fVertex3fSUN, glReplacementCodeuiTexCoord2fNormal3fVertex3fSUN)
  glReplacementCodeuiTexCoord2fNormal3fVertex3fSUN(rc, s, t, nx, ny, nz, x, y, z);
  OGLM_CHECK_ERR(glReplacementCodeuiTexCoord2fNormal3fVertex3fSUN, )

void
glReplacementCodeuiTexCoord2fNormal3fVertex3fvSUN_c(rc, tc, n, v)
  const GLuint* rc;
  const GLfloat *tc;
  const GLfloat *n;
  const GLfloat *v;
CODE:
  OGLM_GLEWINIT
  OGLM_CHECK_ERR(glReplacementCodeuiTexCoord2fNormal3fVertex3fvSUN, )
  OGLM_AVAIL_CHECK(__glewReplacementCodeuiTexCoord2fNormal3fVertex3fvSUN, glReplacementCodeuiTexCoord2fNormal3fVertex3fvSUN)
  glReplacementCodeuiTexCoord2fNormal3fVertex3fvSUN(rc, tc, n, v);
  OGLM_CHECK_ERR(glReplacementCodeuiTexCoord2fNormal3fVertex3fvSUN, )

void
glReplacementCodeuiTexCoord2fNormal3fVertex3fvSUN_p(rcSV, tcSV, nSV, vSV)
  SV *rcSV;
  SV *tcSV;
  SV *nSV;
  SV *vSV;
CODE:
  OGLM_GLEWINIT
  OGLM_CHECK_ERR(glReplacementCodeuiTexCoord2fNormal3fVertex3fvSUN, )
  OGLM_AVAIL_CHECK(__glewReplacementCodeuiTexCoord2fNormal3fVertex3fvSUN, glReplacementCodeuiTexCoord2fNormal3fVertex3fvSUN)
  GLfloat *n = OGLM_GET_ARRAY(n, GLfloat, NV, 3);
  GLuint* rc = OGLM_GET_ARRAY(rc, GLuint, UV, 1);
  GLfloat *tc = OGLM_GET_ARRAY(tc, GLfloat, NV, 2);
  GLfloat *v = OGLM_GET_ARRAY(v, GLfloat, NV, 3);
  glReplacementCodeuiTexCoord2fNormal3fVertex3fvSUN((const GLuint* )rc, (const GLfloat *)tc, (const GLfloat *)n, (const GLfloat *)v);
  OGLM_CHECK_ERR(glReplacementCodeuiTexCoord2fNormal3fVertex3fvSUN, free(n);free(rc);free(tc);free(v);)
  free(n);free(rc);free(tc);free(v);

void
glReplacementCodeuiTexCoord2fVertex3fSUN(rc, s, t, x, y, z)
  GLuint rc;
  GLfloat s;
  GLfloat t;
  GLfloat x;
  GLfloat y;
  GLfloat z;
CODE:
  OGLM_GLEWINIT
  OGLM_CHECK_ERR(glReplacementCodeuiTexCoord2fVertex3fSUN, )
  OGLM_AVAIL_CHECK(__glewReplacementCodeuiTexCoord2fVertex3fSUN, glReplacementCodeuiTexCoord2fVertex3fSUN)
  glReplacementCodeuiTexCoord2fVertex3fSUN(rc, s, t, x, y, z);
  OGLM_CHECK_ERR(glReplacementCodeuiTexCoord2fVertex3fSUN, )

void
glReplacementCodeuiTexCoord2fVertex3fvSUN_c(rc, tc, v)
  const GLuint* rc;
  const GLfloat *tc;
  const GLfloat *v;
CODE:
  OGLM_GLEWINIT
  OGLM_CHECK_ERR(glReplacementCodeuiTexCoord2fVertex3fvSUN, )
  OGLM_AVAIL_CHECK(__glewReplacementCodeuiTexCoord2fVertex3fvSUN, glReplacementCodeuiTexCoord2fVertex3fvSUN)
  glReplacementCodeuiTexCoord2fVertex3fvSUN(rc, tc, v);
  OGLM_CHECK_ERR(glReplacementCodeuiTexCoord2fVertex3fvSUN, )

void
glReplacementCodeuiTexCoord2fVertex3fvSUN_p(rcSV, tcSV, vSV)
  SV *rcSV;
  SV *tcSV;
  SV *vSV;
CODE:
  OGLM_GLEWINIT
  OGLM_CHECK_ERR(glReplacementCodeuiTexCoord2fVertex3fvSUN, )
  OGLM_AVAIL_CHECK(__glewReplacementCodeuiTexCoord2fVertex3fvSUN, glReplacementCodeuiTexCoord2fVertex3fvSUN)
  GLuint* rc = OGLM_GET_ARRAY(rc, GLuint, UV, 1);
  GLfloat *tc = OGLM_GET_ARRAY(tc, GLfloat, NV, 2);
  GLfloat *v = OGLM_GET_ARRAY(v, GLfloat, NV, 3);
  glReplacementCodeuiTexCoord2fVertex3fvSUN((const GLuint* )rc, (const GLfloat *)tc, (const GLfloat *)v);
  OGLM_CHECK_ERR(glReplacementCodeuiTexCoord2fVertex3fvSUN, free(rc);free(tc);free(v);)
  free(rc);free(tc);free(v);

void
glReplacementCodeuiVertex3fSUN(rc, x, y, z)
  GLuint rc;
  GLfloat x;
  GLfloat y;
  GLfloat z;
CODE:
  OGLM_GLEWINIT
  OGLM_CHECK_ERR(glReplacementCodeuiVertex3fSUN, )
  OGLM_AVAIL_CHECK(__glewReplacementCodeuiVertex3fSUN, glReplacementCodeuiVertex3fSUN)
  glReplacementCodeuiVertex3fSUN(rc, x, y, z);
  OGLM_CHECK_ERR(glReplacementCodeuiVertex3fSUN, )

void
glReplacementCodeuiVertex3fvSUN_c(rc, v)
  const GLuint* rc;
  const GLfloat *v;
CODE:
  OGLM_GLEWINIT
  OGLM_CHECK_ERR(glReplacementCodeuiVertex3fvSUN, )
  OGLM_AVAIL_CHECK(__glewReplacementCodeuiVertex3fvSUN, glReplacementCodeuiVertex3fvSUN)
  glReplacementCodeuiVertex3fvSUN(rc, v);
  OGLM_CHECK_ERR(glReplacementCodeuiVertex3fvSUN, )

void
glReplacementCodeuiVertex3fvSUN_p(rcSV, vSV)
  SV *rcSV;
  SV *vSV;
CODE:
  OGLM_GLEWINIT
  OGLM_CHECK_ERR(glReplacementCodeuiVertex3fvSUN, )
  OGLM_AVAIL_CHECK(__glewReplacementCodeuiVertex3fvSUN, glReplacementCodeuiVertex3fvSUN)
  GLuint* rc = OGLM_GET_ARRAY(rc, GLuint, UV, 1);
  GLfloat *v = OGLM_GET_ARRAY(v, GLfloat, NV, 3);
  glReplacementCodeuiVertex3fvSUN((const GLuint* )rc, (const GLfloat *)v);
  OGLM_CHECK_ERR(glReplacementCodeuiVertex3fvSUN, free(rc);free(v);)
  free(rc);free(v);

void
glReplacementCodeuivSUN_c(code)
  const GLuint* code;
CODE:
  OGLM_GLEWINIT
  OGLM_CHECK_ERR(glReplacementCodeuivSUN, )
  OGLM_AVAIL_CHECK(__glewReplacementCodeuivSUN, glReplacementCodeuivSUN)
  glReplacementCodeuivSUN(code);
  OGLM_CHECK_ERR(glReplacementCodeuivSUN, )

void
glReplacementCodeusSUN(code)
  GLushort code;
CODE:
  OGLM_GLEWINIT
  OGLM_CHECK_ERR(glReplacementCodeusSUN, )
  OGLM_AVAIL_CHECK(__glewReplacementCodeusSUN, glReplacementCodeusSUN)
  glReplacementCodeusSUN(code);
  OGLM_CHECK_ERR(glReplacementCodeusSUN, )

void
glReplacementCodeusvSUN_c(code)
  const GLushort* code;
CODE:
  OGLM_GLEWINIT
  OGLM_CHECK_ERR(glReplacementCodeusvSUN, )
  OGLM_AVAIL_CHECK(__glewReplacementCodeusvSUN, glReplacementCodeusvSUN)
  glReplacementCodeusvSUN(code);
  OGLM_CHECK_ERR(glReplacementCodeusvSUN, )

void
glRequestResidentProgramsNV_c(n, programs)
  GLsizei n;
  GLuint* programs;
CODE:
  OGLM_GLEWINIT
  OGLM_CHECK_ERR(glRequestResidentProgramsNV, )
  OGLM_AVAIL_CHECK(__glewRequestResidentProgramsNV, glRequestResidentProgramsNV)
  glRequestResidentProgramsNV(n, programs);
  OGLM_CHECK_ERR(glRequestResidentProgramsNV, )

void
glRequestResidentProgramsNV_p(n)
  GLsizei n;
PPCODE:
  OGLM_GLEWINIT
  OGLM_CHECK_ERR(glRequestResidentProgramsNV, )
  OGLM_AVAIL_CHECK(__glewRequestResidentProgramsNV, glRequestResidentProgramsNV)
  GLuint* programs = OGLM_ALLOC(n,GLuint,programs);
  glRequestResidentProgramsNV(n, programs);
  OGLM_CHECK_ERR(glRequestResidentProgramsNV, free(programs);)
  OGLM_OUT_FINISH(programs,n,newSVuv)
  free(programs);

void
glResetHistogram(target)
  GLenum target;
ALIAS:
  glResetHistogramEXT = 1
CODE:
  OGLM_GLEWINIT
  OGLM_CHECK_ERR(glResetHistogram, )
  OGLM_AVAIL_CHECK(__glewResetHistogram, glResetHistogram)
  glResetHistogram(target);
  OGLM_CHECK_ERR(glResetHistogram, )

void
glResetMemoryObjectParameterNV(memory, pname)
  GLuint memory;
  GLenum pname;
CODE:
  OGLM_GLEWINIT
  OGLM_CHECK_ERR(glResetMemoryObjectParameterNV, )
  OGLM_AVAIL_CHECK(__glewResetMemoryObjectParameterNV, glResetMemoryObjectParameterNV)
  glResetMemoryObjectParameterNV(memory, pname);
  OGLM_CHECK_ERR(glResetMemoryObjectParameterNV, )

void
glResetMinmax(target)
  GLenum target;
ALIAS:
  glResetMinmaxEXT = 1
CODE:
  OGLM_GLEWINIT
  OGLM_CHECK_ERR(glResetMinmax, )
  OGLM_AVAIL_CHECK(__glewResetMinmax, glResetMinmax)
  glResetMinmax(target);
  OGLM_CHECK_ERR(glResetMinmax, )

void
glResizeBuffersMESA()
CODE:
  OGLM_GLEWINIT
  OGLM_CHECK_ERR(glResizeBuffersMESA, )
  OGLM_AVAIL_CHECK(__glewResizeBuffersMESA, glResizeBuffersMESA)
  glResizeBuffersMESA();
  OGLM_CHECK_ERR(glResizeBuffersMESA, )

void
glResolveDepthValuesNV()
CODE:
  OGLM_GLEWINIT
  OGLM_CHECK_ERR(glResolveDepthValuesNV, )
  OGLM_AVAIL_CHECK(__glewResolveDepthValuesNV, glResolveDepthValuesNV)
  glResolveDepthValuesNV();
  OGLM_CHECK_ERR(glResolveDepthValuesNV, )

void
glResolveMultisampleFramebufferAPPLE()
CODE:
  OGLM_GLEWINIT
  OGLM_CHECK_ERR(glResolveMultisampleFramebufferAPPLE, )
  OGLM_AVAIL_CHECK(__glewResolveMultisampleFramebufferAPPLE, glResolveMultisampleFramebufferAPPLE)
  glResolveMultisampleFramebufferAPPLE();
  OGLM_CHECK_ERR(glResolveMultisampleFramebufferAPPLE, )

void
glResumeTransformFeedback()
ALIAS:
  glResumeTransformFeedbackNV = 1
CODE:
  OGLM_GLEWINIT
  OGLM_CHECK_ERR(glResumeTransformFeedback, )
  OGLM_AVAIL_CHECK(__glewResumeTransformFeedback, glResumeTransformFeedback)
  glResumeTransformFeedback();
  OGLM_CHECK_ERR(glResumeTransformFeedback, )

void
glRotated(angle, x, y, z)
  GLdouble angle;
  GLdouble x;
  GLdouble y;
  GLdouble z;
CODE:
  OGLM_GLEWINIT
  OGLM_CHECK_ERR(glRotated, )
  glRotated(angle, x, y, z);
  OGLM_CHECK_ERR(glRotated, )

void
glRotatef(angle, x, y, z)
  GLfloat angle;
  GLfloat x;
  GLfloat y;
  GLfloat z;
CODE:
  OGLM_GLEWINIT
  OGLM_CHECK_ERR(glRotatef, )
  glRotatef(angle, x, y, z);
  OGLM_CHECK_ERR(glRotatef, )

void
glRotatex(angle, x, y, z)
  GLfixed angle;
  GLfixed x;
  GLfixed y;
  GLfixed z;
CODE:
  OGLM_GLEWINIT
  OGLM_CHECK_ERR(glRotatex, )
  OGLM_AVAIL_CHECK(__glewRotatex, glRotatex)
  glRotatex(angle, x, y, z);
  OGLM_CHECK_ERR(glRotatex, )

void
glSampleCoverage(value, invert)
  GLclampf value;
  GLboolean invert;
ALIAS:
  glSampleCoverageARB = 1
CODE:
  OGLM_GLEWINIT
  OGLM_CHECK_ERR(glSampleCoverage, )
  OGLM_AVAIL_CHECK(__glewSampleCoverage, glSampleCoverage)
  glSampleCoverage(value, invert);
  OGLM_CHECK_ERR(glSampleCoverage, )

void
glSampleCoveragex(value, invert)
  GLclampx value;
  GLboolean invert;
CODE:
  OGLM_GLEWINIT
  OGLM_CHECK_ERR(glSampleCoveragex, )
  OGLM_AVAIL_CHECK(__glewSampleCoveragex, glSampleCoveragex)
  glSampleCoveragex(value, invert);
  OGLM_CHECK_ERR(glSampleCoveragex, )

void
glSampleMapATI(dst, interp, swizzle)
  GLuint dst;
  GLuint interp;
  GLenum swizzle;
CODE:
  OGLM_GLEWINIT
  OGLM_CHECK_ERR(glSampleMapATI, )
  OGLM_AVAIL_CHECK(__glewSampleMapATI, glSampleMapATI)
  glSampleMapATI(dst, interp, swizzle);
  OGLM_CHECK_ERR(glSampleMapATI, )

void
glSampleMaskEXT(value, invert)
  GLclampf value;
  GLboolean invert;
ALIAS:
  glSampleMaskSGIS = 1
CODE:
  OGLM_GLEWINIT
  OGLM_CHECK_ERR(glSampleMaskEXT, )
  OGLM_AVAIL_CHECK(__glewSampleMaskEXT, glSampleMaskEXT)
  glSampleMaskEXT(value, invert);
  OGLM_CHECK_ERR(glSampleMaskEXT, )

void
glSampleMaskIndexedNV(index, mask)
  GLuint index;
  GLbitfield mask;
CODE:
  OGLM_GLEWINIT
  OGLM_CHECK_ERR(glSampleMaskIndexedNV, )
  OGLM_AVAIL_CHECK(__glewSampleMaskIndexedNV, glSampleMaskIndexedNV)
  glSampleMaskIndexedNV(index, mask);
  OGLM_CHECK_ERR(glSampleMaskIndexedNV, )

void
glSampleMaski(index, mask)
  GLuint index;
  GLbitfield mask;
CODE:
  OGLM_GLEWINIT
  OGLM_CHECK_ERR(glSampleMaski, )
  OGLM_AVAIL_CHECK(__glewSampleMaski, glSampleMaski)
  glSampleMaski(index, mask);
  OGLM_CHECK_ERR(glSampleMaski, )

void
glSamplePatternEXT(pattern)
  GLenum pattern;
ALIAS:
  glSamplePatternSGIS = 1
CODE:
  OGLM_GLEWINIT
  OGLM_CHECK_ERR(glSamplePatternEXT, )
  OGLM_AVAIL_CHECK(__glewSamplePatternEXT, glSamplePatternEXT)
  glSamplePatternEXT(pattern);
  OGLM_CHECK_ERR(glSamplePatternEXT, )

void
glSamplerParameterIiv_c(sampler, pname, param)
  GLuint sampler;
  GLenum pname;
  const GLint* param;
ALIAS:
  glSamplerParameterIivEXT_c = 1
CODE:
  OGLM_GLEWINIT
  OGLM_CHECK_ERR(glSamplerParameterIiv, )
  OGLM_AVAIL_CHECK(__glewSamplerParameterIiv, glSamplerParameterIiv)
  glSamplerParameterIiv(sampler, pname, param);
  OGLM_CHECK_ERR(glSamplerParameterIiv, )

void
glSamplerParameterIiv_p(sampler, pname, ...)
  GLuint sampler;
  GLenum pname;
ALIAS:
  glSamplerParameterIivEXT_p = 1
CODE:
  OGLM_GLEWINIT
  OGLM_CHECK_ERR(glSamplerParameterIiv, )
  OGLM_AVAIL_CHECK(__glewSamplerParameterIiv, glSamplerParameterIiv)
  OGLM_SIZE_ENUM(SamplerParameterI,pname,1)
  GLint* param = OGLM_GET_VARARGS(param,2,GLint,IV,pname_count);
  glSamplerParameterIiv((GLuint )sampler, (GLenum )pname, (const GLint* )param);
  OGLM_CHECK_ERR(glSamplerParameterIiv, free(param);)
  free(param);

void
glSamplerParameterIivOES_c(sampler, pname, params)
  GLuint sampler;
  GLenum pname;
  const GLint* params;
CODE:
  OGLM_GLEWINIT
  OGLM_CHECK_ERR(glSamplerParameterIivOES, )
  OGLM_AVAIL_CHECK(__glewSamplerParameterIivOES, glSamplerParameterIivOES)
  glSamplerParameterIivOES(sampler, pname, params);
  OGLM_CHECK_ERR(glSamplerParameterIivOES, )

void
glSamplerParameterIuiv_c(sampler, pname, param)
  GLuint sampler;
  GLenum pname;
  const GLuint* param;
ALIAS:
  glSamplerParameterIuivEXT_c = 1
CODE:
  OGLM_GLEWINIT
  OGLM_CHECK_ERR(glSamplerParameterIuiv, )
  OGLM_AVAIL_CHECK(__glewSamplerParameterIuiv, glSamplerParameterIuiv)
  glSamplerParameterIuiv(sampler, pname, param);
  OGLM_CHECK_ERR(glSamplerParameterIuiv, )

void
glSamplerParameterIuiv_p(sampler, pname, ...)
  GLuint sampler;
  GLenum pname;
ALIAS:
  glSamplerParameterIuivEXT_p = 1
CODE:
  OGLM_GLEWINIT
  OGLM_CHECK_ERR(glSamplerParameterIuiv, )
  OGLM_AVAIL_CHECK(__glewSamplerParameterIuiv, glSamplerParameterIuiv)
  OGLM_SIZE_ENUM(SamplerParameterI,pname,1)
  GLuint* param = OGLM_GET_VARARGS(param,2,GLuint,UV,pname_count);
  glSamplerParameterIuiv((GLuint )sampler, (GLenum )pname, (const GLuint* )param);
  OGLM_CHECK_ERR(glSamplerParameterIuiv, free(param);)
  free(param);

void
glSamplerParameterIuivOES_c(sampler, pname, params)
  GLuint sampler;
  GLenum pname;
  const GLuint* params;
CODE:
  OGLM_GLEWINIT
  OGLM_CHECK_ERR(glSamplerParameterIuivOES, )
  OGLM_AVAIL_CHECK(__glewSamplerParameterIuivOES, glSamplerParameterIuivOES)
  glSamplerParameterIuivOES(sampler, pname, params);
  OGLM_CHECK_ERR(glSamplerParameterIuivOES, )

void
glSamplerParameterf(sampler, pname, param)
  GLuint sampler;
  GLenum pname;
  GLfloat param;
CODE:
  OGLM_GLEWINIT
  OGLM_CHECK_ERR(glSamplerParameterf, )
  OGLM_AVAIL_CHECK(__glewSamplerParameterf, glSamplerParameterf)
  glSamplerParameterf(sampler, pname, param);
  OGLM_CHECK_ERR(glSamplerParameterf, )

void
glSamplerParameterfv_c(sampler, pname, param)
  GLuint sampler;
  GLenum pname;
  const GLfloat* param;
CODE:
  OGLM_GLEWINIT
  OGLM_CHECK_ERR(glSamplerParameterfv, )
  OGLM_AVAIL_CHECK(__glewSamplerParameterfv, glSamplerParameterfv)
  glSamplerParameterfv(sampler, pname, param);
  OGLM_CHECK_ERR(glSamplerParameterfv, )

void
glSamplerParameterfv_p(sampler, pname, ...)
  GLuint sampler;
  GLenum pname;
CODE:
  OGLM_GLEWINIT
  OGLM_CHECK_ERR(glSamplerParameterfv, )
  OGLM_AVAIL_CHECK(__glewSamplerParameterfv, glSamplerParameterfv)
  OGLM_SIZE_ENUM(SamplerParameterF,pname,1)
  GLfloat* param = OGLM_GET_VARARGS(param,2,GLfloat,NV,pname_count);
  glSamplerParameterfv((GLuint )sampler, (GLenum )pname, (const GLfloat* )param);
  OGLM_CHECK_ERR(glSamplerParameterfv, free(param);)
  free(param);

void
glSamplerParameteri(sampler, pname, param)
  GLuint sampler;
  GLenum pname;
  GLint param;
CODE:
  OGLM_GLEWINIT
  OGLM_CHECK_ERR(glSamplerParameteri, )
  OGLM_AVAIL_CHECK(__glewSamplerParameteri, glSamplerParameteri)
  glSamplerParameteri(sampler, pname, param);
  OGLM_CHECK_ERR(glSamplerParameteri, )

void
glSamplerParameteriv_c(sampler, pname, param)
  GLuint sampler;
  GLenum pname;
  const GLint* param;
CODE:
  OGLM_GLEWINIT
  OGLM_CHECK_ERR(glSamplerParameteriv, )
  OGLM_AVAIL_CHECK(__glewSamplerParameteriv, glSamplerParameteriv)
  glSamplerParameteriv(sampler, pname, param);
  OGLM_CHECK_ERR(glSamplerParameteriv, )

void
glSamplerParameteriv_p(sampler, pname, ...)
  GLuint sampler;
  GLenum pname;
CODE:
  OGLM_GLEWINIT
  OGLM_CHECK_ERR(glSamplerParameteriv, )
  OGLM_AVAIL_CHECK(__glewSamplerParameteriv, glSamplerParameteriv)
  OGLM_SIZE_ENUM(SamplerParameterI,pname,1)
  GLint* param = OGLM_GET_VARARGS(param,2,GLint,IV,pname_count);
  glSamplerParameteriv((GLuint )sampler, (GLenum )pname, (const GLint* )param);
  OGLM_CHECK_ERR(glSamplerParameteriv, free(param);)
  free(param);

void
glScaled(x, y, z)
  GLdouble x;
  GLdouble y;
  GLdouble z;
CODE:
  OGLM_GLEWINIT
  OGLM_CHECK_ERR(glScaled, )
  glScaled(x, y, z);
  OGLM_CHECK_ERR(glScaled, )

void
glScalef(x, y, z)
  GLfloat x;
  GLfloat y;
  GLfloat z;
CODE:
  OGLM_GLEWINIT
  OGLM_CHECK_ERR(glScalef, )
  glScalef(x, y, z);
  OGLM_CHECK_ERR(glScalef, )

void
glScalex(x, y, z)
  GLfixed x;
  GLfixed y;
  GLfixed z;
CODE:
  OGLM_GLEWINIT
  OGLM_CHECK_ERR(glScalex, )
  OGLM_AVAIL_CHECK(__glewScalex, glScalex)
  glScalex(x, y, z);
  OGLM_CHECK_ERR(glScalex, )

void
glScissor(x, y, width, height)
  GLint x;
  GLint y;
  GLsizei width;
  GLsizei height;
CODE:
  OGLM_GLEWINIT
  OGLM_CHECK_ERR(glScissor, )
  glScissor(x, y, width, height);
  OGLM_CHECK_ERR(glScissor, )

void
glScissorArrayv_c(first, count, v)
  GLuint first;
  GLsizei count;
  const GLint * v;
ALIAS:
  glScissorArrayvNV_c = 1
CODE:
  OGLM_GLEWINIT
  OGLM_CHECK_ERR(glScissorArrayv, )
  OGLM_AVAIL_CHECK(__glewScissorArrayv, glScissorArrayv)
  glScissorArrayv(first, count, v);
  OGLM_CHECK_ERR(glScissorArrayv, )

void
glScissorArrayv_p(first, ...)
  GLuint first;
ALIAS:
  glScissorArrayvNV_p = 1
CODE:
  OGLM_GLEWINIT
  OGLM_CHECK_ERR(glScissorArrayv, )
  OGLM_AVAIL_CHECK(__glewScissorArrayv, glScissorArrayv)
  GLsizei count = items-1;
  GLint * v = OGLM_GET_VARARGS(v,1,GLint,IV,count);
  glScissorArrayv((GLuint )first, (GLsizei )count, (const GLint * )v);
  OGLM_CHECK_ERR(glScissorArrayv, free(v);)
  free(v);

void
glScissorExclusiveArrayvNV_c(first, count, v)
  GLuint first;
  GLsizei count;
  const GLint* v;
CODE:
  OGLM_GLEWINIT
  OGLM_CHECK_ERR(glScissorExclusiveArrayvNV, )
  OGLM_AVAIL_CHECK(__glewScissorExclusiveArrayvNV, glScissorExclusiveArrayvNV)
  glScissorExclusiveArrayvNV(first, count, v);
  OGLM_CHECK_ERR(glScissorExclusiveArrayvNV, )

void
glScissorExclusiveArrayvNV_p(first, ...)
  GLuint first;
CODE:
  OGLM_GLEWINIT
  OGLM_CHECK_ERR(glScissorExclusiveArrayvNV, )
  OGLM_AVAIL_CHECK(__glewScissorExclusiveArrayvNV, glScissorExclusiveArrayvNV)
  GLsizei count = items-1;
  GLint* v = OGLM_GET_VARARGS(v,1,GLint,IV,count);
  glScissorExclusiveArrayvNV((GLuint )first, (GLsizei )count, (const GLint* )v);
  OGLM_CHECK_ERR(glScissorExclusiveArrayvNV, free(v);)
  free(v);

void
glScissorExclusiveNV(x, y, width, height)
  GLint x;
  GLint y;
  GLsizei width;
  GLsizei height;
CODE:
  OGLM_GLEWINIT
  OGLM_CHECK_ERR(glScissorExclusiveNV, )
  OGLM_AVAIL_CHECK(__glewScissorExclusiveNV, glScissorExclusiveNV)
  glScissorExclusiveNV(x, y, width, height);
  OGLM_CHECK_ERR(glScissorExclusiveNV, )

void
glScissorIndexed(index, left, bottom, width, height)
  GLuint index;
  GLint left;
  GLint bottom;
  GLsizei width;
  GLsizei height;
ALIAS:
  glScissorIndexedNV = 1
CODE:
  OGLM_GLEWINIT
  OGLM_CHECK_ERR(glScissorIndexed, )
  OGLM_AVAIL_CHECK(__glewScissorIndexed, glScissorIndexed)
  glScissorIndexed(index, left, bottom, width, height);
  OGLM_CHECK_ERR(glScissorIndexed, )

void
glScissorIndexedv_c(index, v)
  GLuint index;
  const GLint * v;
ALIAS:
  glScissorIndexedvNV_c = 1
CODE:
  OGLM_GLEWINIT
  OGLM_CHECK_ERR(glScissorIndexedv, )
  OGLM_AVAIL_CHECK(__glewScissorIndexedv, glScissorIndexedv)
  glScissorIndexedv(index, v);
  OGLM_CHECK_ERR(glScissorIndexedv, )

void
glScissorIndexedv_p(index, ...)
  GLuint index;
ALIAS:
  glScissorIndexedvNV_p = 1
CODE:
  OGLM_GLEWINIT
  OGLM_CHECK_ERR(glScissorIndexedv, )
  OGLM_AVAIL_CHECK(__glewScissorIndexedv, glScissorIndexedv)
  GLint * v = OGLM_GET_VARARGS(v,1,GLint,IV,4);
  glScissorIndexedv((GLuint )index, (const GLint * )v);
  OGLM_CHECK_ERR(glScissorIndexedv, free(v);)
  free(v);

void
glSecondaryColor3b(red, green, blue)
  GLbyte red;
  GLbyte green;
  GLbyte blue;
ALIAS:
  glSecondaryColor3bEXT = 1
CODE:
  OGLM_GLEWINIT
  OGLM_CHECK_ERR(glSecondaryColor3b, )
  OGLM_AVAIL_CHECK(__glewSecondaryColor3b, glSecondaryColor3b)
  glSecondaryColor3b(red, green, blue);
  OGLM_CHECK_ERR(glSecondaryColor3b, )

void
glSecondaryColor3bv_c(v)
  const GLbyte *v;
ALIAS:
  glSecondaryColor3bvEXT_c = 1
CODE:
  OGLM_GLEWINIT
  OGLM_CHECK_ERR(glSecondaryColor3bv, )
  OGLM_AVAIL_CHECK(__glewSecondaryColor3bv, glSecondaryColor3bv)
  glSecondaryColor3bv(v);
  OGLM_CHECK_ERR(glSecondaryColor3bv, )

void
glSecondaryColor3bv_p(...)
ALIAS:
  glSecondaryColor3bvEXT_p = 1
CODE:
  OGLM_GLEWINIT
  OGLM_CHECK_ERR(glSecondaryColor3bv, )
  OGLM_AVAIL_CHECK(__glewSecondaryColor3bv, glSecondaryColor3bv)
  GLbyte *v = OGLM_GET_VARARGS(v,0,GLbyte,IV,3);
  glSecondaryColor3bv((const GLbyte *)v);
  OGLM_CHECK_ERR(glSecondaryColor3bv, free(v);)
  free(v);

void
glSecondaryColor3d(red, green, blue)
  GLdouble red;
  GLdouble green;
  GLdouble blue;
ALIAS:
  glSecondaryColor3dEXT = 1
CODE:
  OGLM_GLEWINIT
  OGLM_CHECK_ERR(glSecondaryColor3d, )
  OGLM_AVAIL_CHECK(__glewSecondaryColor3d, glSecondaryColor3d)
  glSecondaryColor3d(red, green, blue);
  OGLM_CHECK_ERR(glSecondaryColor3d, )

void
glSecondaryColor3dv_c(v)
  const GLdouble *v;
ALIAS:
  glSecondaryColor3dvEXT_c = 1
CODE:
  OGLM_GLEWINIT
  OGLM_CHECK_ERR(glSecondaryColor3dv, )
  OGLM_AVAIL_CHECK(__glewSecondaryColor3dv, glSecondaryColor3dv)
  glSecondaryColor3dv(v);
  OGLM_CHECK_ERR(glSecondaryColor3dv, )

void
glSecondaryColor3dv_p(...)
ALIAS:
  glSecondaryColor3dvEXT_p = 1
CODE:
  OGLM_GLEWINIT
  OGLM_CHECK_ERR(glSecondaryColor3dv, )
  OGLM_AVAIL_CHECK(__glewSecondaryColor3dv, glSecondaryColor3dv)
  GLdouble *v = OGLM_GET_VARARGS(v,0,GLdouble,NV,3);
  glSecondaryColor3dv((const GLdouble *)v);
  OGLM_CHECK_ERR(glSecondaryColor3dv, free(v);)
  free(v);

void
glSecondaryColor3f(red, green, blue)
  GLfloat red;
  GLfloat green;
  GLfloat blue;
ALIAS:
  glSecondaryColor3fEXT = 1
CODE:
  OGLM_GLEWINIT
  OGLM_CHECK_ERR(glSecondaryColor3f, )
  OGLM_AVAIL_CHECK(__glewSecondaryColor3f, glSecondaryColor3f)
  glSecondaryColor3f(red, green, blue);
  OGLM_CHECK_ERR(glSecondaryColor3f, )

void
glSecondaryColor3fv_c(v)
  const GLfloat *v;
ALIAS:
  glSecondaryColor3fvEXT_c = 1
CODE:
  OGLM_GLEWINIT
  OGLM_CHECK_ERR(glSecondaryColor3fv, )
  OGLM_AVAIL_CHECK(__glewSecondaryColor3fv, glSecondaryColor3fv)
  glSecondaryColor3fv(v);
  OGLM_CHECK_ERR(glSecondaryColor3fv, )

void
glSecondaryColor3fv_p(...)
ALIAS:
  glSecondaryColor3fvEXT_p = 1
CODE:
  OGLM_GLEWINIT
  OGLM_CHECK_ERR(glSecondaryColor3fv, )
  OGLM_AVAIL_CHECK(__glewSecondaryColor3fv, glSecondaryColor3fv)
  GLfloat *v = OGLM_GET_VARARGS(v,0,GLfloat,NV,3);
  glSecondaryColor3fv((const GLfloat *)v);
  OGLM_CHECK_ERR(glSecondaryColor3fv, free(v);)
  free(v);

void
glSecondaryColor3hNV(red, green, blue)
  GLhalf red;
  GLhalf green;
  GLhalf blue;
CODE:
  OGLM_GLEWINIT
  OGLM_CHECK_ERR(glSecondaryColor3hNV, )
  OGLM_AVAIL_CHECK(__glewSecondaryColor3hNV, glSecondaryColor3hNV)
  glSecondaryColor3hNV(red, green, blue);
  OGLM_CHECK_ERR(glSecondaryColor3hNV, )

void
glSecondaryColor3hvNV_c(v)
  const GLhalf* v;
CODE:
  OGLM_GLEWINIT
  OGLM_CHECK_ERR(glSecondaryColor3hvNV, )
  OGLM_AVAIL_CHECK(__glewSecondaryColor3hvNV, glSecondaryColor3hvNV)
  glSecondaryColor3hvNV(v);
  OGLM_CHECK_ERR(glSecondaryColor3hvNV, )

void
glSecondaryColor3hvNV_p(...)
CODE:
  OGLM_GLEWINIT
  OGLM_CHECK_ERR(glSecondaryColor3hvNV, )
  OGLM_AVAIL_CHECK(__glewSecondaryColor3hvNV, glSecondaryColor3hvNV)
  GLhalf* v = OGLM_GET_VARARGS(v,0,GLhalf,NV,3);
  glSecondaryColor3hvNV((const GLhalf* )v);
  OGLM_CHECK_ERR(glSecondaryColor3hvNV, free(v);)
  free(v);

void
glSecondaryColor3i(red, green, blue)
  GLint red;
  GLint green;
  GLint blue;
ALIAS:
  glSecondaryColor3iEXT = 1
CODE:
  OGLM_GLEWINIT
  OGLM_CHECK_ERR(glSecondaryColor3i, )
  OGLM_AVAIL_CHECK(__glewSecondaryColor3i, glSecondaryColor3i)
  glSecondaryColor3i(red, green, blue);
  OGLM_CHECK_ERR(glSecondaryColor3i, )

void
glSecondaryColor3iv_c(v)
  const GLint *v;
ALIAS:
  glSecondaryColor3ivEXT_c = 1
CODE:
  OGLM_GLEWINIT
  OGLM_CHECK_ERR(glSecondaryColor3iv, )
  OGLM_AVAIL_CHECK(__glewSecondaryColor3iv, glSecondaryColor3iv)
  glSecondaryColor3iv(v);
  OGLM_CHECK_ERR(glSecondaryColor3iv, )

void
glSecondaryColor3iv_p(...)
ALIAS:
  glSecondaryColor3ivEXT_p = 1
CODE:
  OGLM_GLEWINIT
  OGLM_CHECK_ERR(glSecondaryColor3iv, )
  OGLM_AVAIL_CHECK(__glewSecondaryColor3iv, glSecondaryColor3iv)
  GLint *v = OGLM_GET_VARARGS(v,0,GLint,IV,3);
  glSecondaryColor3iv((const GLint *)v);
  OGLM_CHECK_ERR(glSecondaryColor3iv, free(v);)
  free(v);

void
glSecondaryColor3s(red, green, blue)
  GLshort red;
  GLshort green;
  GLshort blue;
ALIAS:
  glSecondaryColor3sEXT = 1
CODE:
  OGLM_GLEWINIT
  OGLM_CHECK_ERR(glSecondaryColor3s, )
  OGLM_AVAIL_CHECK(__glewSecondaryColor3s, glSecondaryColor3s)
  glSecondaryColor3s(red, green, blue);
  OGLM_CHECK_ERR(glSecondaryColor3s, )

void
glSecondaryColor3sv_c(v)
  const GLshort *v;
ALIAS:
  glSecondaryColor3svEXT_c = 1
CODE:
  OGLM_GLEWINIT
  OGLM_CHECK_ERR(glSecondaryColor3sv, )
  OGLM_AVAIL_CHECK(__glewSecondaryColor3sv, glSecondaryColor3sv)
  glSecondaryColor3sv(v);
  OGLM_CHECK_ERR(glSecondaryColor3sv, )

void
glSecondaryColor3sv_p(...)
ALIAS:
  glSecondaryColor3svEXT_p = 1
CODE:
  OGLM_GLEWINIT
  OGLM_CHECK_ERR(glSecondaryColor3sv, )
  OGLM_AVAIL_CHECK(__glewSecondaryColor3sv, glSecondaryColor3sv)
  GLshort *v = OGLM_GET_VARARGS(v,0,GLshort,IV,3);
  glSecondaryColor3sv((const GLshort *)v);
  OGLM_CHECK_ERR(glSecondaryColor3sv, free(v);)
  free(v);

void
glSecondaryColor3ub(red, green, blue)
  GLubyte red;
  GLubyte green;
  GLubyte blue;
ALIAS:
  glSecondaryColor3ubEXT = 1
CODE:
  OGLM_GLEWINIT
  OGLM_CHECK_ERR(glSecondaryColor3ub, )
  OGLM_AVAIL_CHECK(__glewSecondaryColor3ub, glSecondaryColor3ub)
  glSecondaryColor3ub(red, green, blue);
  OGLM_CHECK_ERR(glSecondaryColor3ub, )

void
glSecondaryColor3ubv_c(v)
  const GLubyte *v;
ALIAS:
  glSecondaryColor3ubvEXT_c = 1
CODE:
  OGLM_GLEWINIT
  OGLM_CHECK_ERR(glSecondaryColor3ubv, )
  OGLM_AVAIL_CHECK(__glewSecondaryColor3ubv, glSecondaryColor3ubv)
  glSecondaryColor3ubv(v);
  OGLM_CHECK_ERR(glSecondaryColor3ubv, )

void
glSecondaryColor3ubv_p(...)
ALIAS:
  glSecondaryColor3ubvEXT_p = 1
CODE:
  OGLM_GLEWINIT
  OGLM_CHECK_ERR(glSecondaryColor3ubv, )
  OGLM_AVAIL_CHECK(__glewSecondaryColor3ubv, glSecondaryColor3ubv)
  GLubyte *v = OGLM_GET_VARARGS(v,0,GLubyte,UV,3);
  glSecondaryColor3ubv((const GLubyte *)v);
  OGLM_CHECK_ERR(glSecondaryColor3ubv, free(v);)
  free(v);

void
glSecondaryColor3ui(red, green, blue)
  GLuint red;
  GLuint green;
  GLuint blue;
ALIAS:
  glSecondaryColor3uiEXT = 1
CODE:
  OGLM_GLEWINIT
  OGLM_CHECK_ERR(glSecondaryColor3ui, )
  OGLM_AVAIL_CHECK(__glewSecondaryColor3ui, glSecondaryColor3ui)
  glSecondaryColor3ui(red, green, blue);
  OGLM_CHECK_ERR(glSecondaryColor3ui, )

void
glSecondaryColor3uiv_c(v)
  const GLuint *v;
ALIAS:
  glSecondaryColor3uivEXT_c = 1
CODE:
  OGLM_GLEWINIT
  OGLM_CHECK_ERR(glSecondaryColor3uiv, )
  OGLM_AVAIL_CHECK(__glewSecondaryColor3uiv, glSecondaryColor3uiv)
  glSecondaryColor3uiv(v);
  OGLM_CHECK_ERR(glSecondaryColor3uiv, )

void
glSecondaryColor3uiv_p(...)
ALIAS:
  glSecondaryColor3uivEXT_p = 1
CODE:
  OGLM_GLEWINIT
  OGLM_CHECK_ERR(glSecondaryColor3uiv, )
  OGLM_AVAIL_CHECK(__glewSecondaryColor3uiv, glSecondaryColor3uiv)
  GLuint *v = OGLM_GET_VARARGS(v,0,GLuint,UV,3);
  glSecondaryColor3uiv((const GLuint *)v);
  OGLM_CHECK_ERR(glSecondaryColor3uiv, free(v);)
  free(v);

void
glSecondaryColor3us(red, green, blue)
  GLushort red;
  GLushort green;
  GLushort blue;
ALIAS:
  glSecondaryColor3usEXT = 1
CODE:
  OGLM_GLEWINIT
  OGLM_CHECK_ERR(glSecondaryColor3us, )
  OGLM_AVAIL_CHECK(__glewSecondaryColor3us, glSecondaryColor3us)
  glSecondaryColor3us(red, green, blue);
  OGLM_CHECK_ERR(glSecondaryColor3us, )

void
glSecondaryColor3usv_c(v)
  const GLushort *v;
ALIAS:
  glSecondaryColor3usvEXT_c = 1
CODE:
  OGLM_GLEWINIT
  OGLM_CHECK_ERR(glSecondaryColor3usv, )
  OGLM_AVAIL_CHECK(__glewSecondaryColor3usv, glSecondaryColor3usv)
  glSecondaryColor3usv(v);
  OGLM_CHECK_ERR(glSecondaryColor3usv, )

void
glSecondaryColor3usv_p(...)
ALIAS:
  glSecondaryColor3usvEXT_p = 1
CODE:
  OGLM_GLEWINIT
  OGLM_CHECK_ERR(glSecondaryColor3usv, )
  OGLM_AVAIL_CHECK(__glewSecondaryColor3usv, glSecondaryColor3usv)
  GLushort *v = OGLM_GET_VARARGS(v,0,GLushort,UV,3);
  glSecondaryColor3usv((const GLushort *)v);
  OGLM_CHECK_ERR(glSecondaryColor3usv, free(v);)
  free(v);

void
glSecondaryColorFormatNV(size, type, stride)
  GLint size;
  GLenum type;
  GLsizei stride;
CODE:
  OGLM_GLEWINIT
  OGLM_CHECK_ERR(glSecondaryColorFormatNV, )
  OGLM_AVAIL_CHECK(__glewSecondaryColorFormatNV, glSecondaryColorFormatNV)
  glSecondaryColorFormatNV(size, type, stride);
  OGLM_CHECK_ERR(glSecondaryColorFormatNV, )

void
glSecondaryColorP3ui(type, color)
  GLenum type;
  GLuint color;
CODE:
  OGLM_GLEWINIT
  OGLM_CHECK_ERR(glSecondaryColorP3ui, )
  OGLM_AVAIL_CHECK(__glewSecondaryColorP3ui, glSecondaryColorP3ui)
  glSecondaryColorP3ui(type, color);
  OGLM_CHECK_ERR(glSecondaryColorP3ui, )

void
glSecondaryColorP3uiv_c(type, color)
  GLenum type;
  const GLuint* color;
CODE:
  OGLM_GLEWINIT
  OGLM_CHECK_ERR(glSecondaryColorP3uiv, )
  OGLM_AVAIL_CHECK(__glewSecondaryColorP3uiv, glSecondaryColorP3uiv)
  glSecondaryColorP3uiv(type, color);
  OGLM_CHECK_ERR(glSecondaryColorP3uiv, )

void
glSecondaryColorP3uiv_p(type, ...)
  GLenum type;
CODE:
  OGLM_GLEWINIT
  OGLM_CHECK_ERR(glSecondaryColorP3uiv, )
  OGLM_AVAIL_CHECK(__glewSecondaryColorP3uiv, glSecondaryColorP3uiv)
  GLuint* color = OGLM_GET_VARARGS(color,1,GLuint,UV,1);
  glSecondaryColorP3uiv((GLenum )type, (const GLuint* )color);
  OGLM_CHECK_ERR(glSecondaryColorP3uiv, free(color);)
  free(color);

void
glSecondaryColorPointer_c(size, type, stride, pointer)
  GLint size;
  GLenum type;
  GLsizei stride;
  const void *pointer;
ALIAS:
  glSecondaryColorPointerEXT_c = 1
CODE:
  OGLM_GLEWINIT
  OGLM_CHECK_ERR(glSecondaryColorPointer, )
  OGLM_AVAIL_CHECK(__glewSecondaryColorPointer, glSecondaryColorPointer)
  glSecondaryColorPointer(size, type, stride, pointer);
  OGLM_CHECK_ERR(glSecondaryColorPointer, )

void
glSecondaryColorPointerListIBM_c(size, type, stride, pointer, ptrstride)
  GLint size;
  GLenum type;
  GLint stride;
  const void** pointer;
  GLint ptrstride;
CODE:
  OGLM_GLEWINIT
  OGLM_CHECK_ERR(glSecondaryColorPointerListIBM, )
  OGLM_AVAIL_CHECK(__glewSecondaryColorPointerListIBM, glSecondaryColorPointerListIBM)
  glSecondaryColorPointerListIBM(size, type, stride, pointer, ptrstride);
  OGLM_CHECK_ERR(glSecondaryColorPointerListIBM, )

void
glSelectBuffer_c(size, buffer)
  GLsizei size;
  GLuint *buffer;
CODE:
  OGLM_GLEWINIT
  OGLM_CHECK_ERR(glSelectBuffer, )
  glSelectBuffer(size, buffer);
  OGLM_CHECK_ERR(glSelectBuffer, )

void
glSelectBuffer_p(size)
  GLsizei size;
PPCODE:
  OGLM_GLEWINIT
  OGLM_CHECK_ERR(glSelectBuffer, )
  GLuint *buffer = OGLM_ALLOC(size,GLuint,buffer);
  glSelectBuffer(size, buffer);
  OGLM_CHECK_ERR(glSelectBuffer, free(buffer);)
  OGLM_OUT_FINISH(buffer,size,newSVuv)
  free(buffer);

void
glSelectPerfMonitorCountersAMD_c(monitor, enable, group, numCounters, counterList)
  GLuint monitor;
  GLboolean enable;
  GLuint group;
  GLint numCounters;
  GLuint* counterList;
CODE:
  OGLM_GLEWINIT
  OGLM_CHECK_ERR(glSelectPerfMonitorCountersAMD, )
  OGLM_AVAIL_CHECK(__glewSelectPerfMonitorCountersAMD, glSelectPerfMonitorCountersAMD)
  glSelectPerfMonitorCountersAMD(monitor, enable, group, numCounters, counterList);
  OGLM_CHECK_ERR(glSelectPerfMonitorCountersAMD, )

void
glSelectPerfMonitorCountersAMD_p(monitor, enable, group, numCounters)
  GLuint monitor;
  GLboolean enable;
  GLuint group;
  GLint numCounters;
PPCODE:
  OGLM_GLEWINIT
  OGLM_CHECK_ERR(glSelectPerfMonitorCountersAMD, )
  OGLM_AVAIL_CHECK(__glewSelectPerfMonitorCountersAMD, glSelectPerfMonitorCountersAMD)
  GLuint* counterList = OGLM_ALLOC(numCounters,GLuint,counterList);
  glSelectPerfMonitorCountersAMD(monitor, enable, group, numCounters, counterList);
  OGLM_CHECK_ERR(glSelectPerfMonitorCountersAMD, free(counterList);)
  OGLM_OUT_FINISH(counterList,numCounters,newSVuv)
  free(counterList);

void
glSelectTextureCoordSetSGIS(target)
  GLenum target;
CODE:
  OGLM_GLEWINIT
  OGLM_CHECK_ERR(glSelectTextureCoordSetSGIS, )
  OGLM_AVAIL_CHECK(__glewSelectTextureCoordSetSGIS, glSelectTextureCoordSetSGIS)
  glSelectTextureCoordSetSGIS(target);
  OGLM_CHECK_ERR(glSelectTextureCoordSetSGIS, )

void
glSelectTextureSGIS(target)
  GLenum target;
CODE:
  OGLM_GLEWINIT
  OGLM_CHECK_ERR(glSelectTextureSGIS, )
  OGLM_AVAIL_CHECK(__glewSelectTextureSGIS, glSelectTextureSGIS)
  glSelectTextureSGIS(target);
  OGLM_CHECK_ERR(glSelectTextureSGIS, )

void
glSelectTextureTransformSGIS(target)
  GLenum target;
CODE:
  OGLM_GLEWINIT
  OGLM_CHECK_ERR(glSelectTextureTransformSGIS, )
  OGLM_AVAIL_CHECK(__glewSelectTextureTransformSGIS, glSelectTextureTransformSGIS)
  glSelectTextureTransformSGIS(target);
  OGLM_CHECK_ERR(glSelectTextureTransformSGIS, )

void
glSemaphoreParameterivNV_c(semaphore, pname, params)
  GLuint semaphore;
  GLenum pname;
  const GLint* params;
CODE:
  OGLM_GLEWINIT
  OGLM_CHECK_ERR(glSemaphoreParameterivNV, )
  OGLM_AVAIL_CHECK(__glewSemaphoreParameterivNV, glSemaphoreParameterivNV)
  glSemaphoreParameterivNV(semaphore, pname, params);
  OGLM_CHECK_ERR(glSemaphoreParameterivNV, )

void
glSemaphoreParameterui64vEXT_c(semaphore, pname, params)
  GLuint semaphore;
  GLenum pname;
  const GLuint64* params;
CODE:
  OGLM_GLEWINIT
  OGLM_CHECK_ERR(glSemaphoreParameterui64vEXT, )
  OGLM_AVAIL_CHECK(__glewSemaphoreParameterui64vEXT, glSemaphoreParameterui64vEXT)
  glSemaphoreParameterui64vEXT(semaphore, pname, params);
  OGLM_CHECK_ERR(glSemaphoreParameterui64vEXT, )

void
glSeparableFilter2D_c(target, internalformat, width, height, format, type, row, column)
  GLenum target;
  GLenum internalformat;
  GLsizei width;
  GLsizei height;
  GLenum format;
  GLenum type;
  const void *row;
  const void *column;
ALIAS:
  glSeparableFilter2DEXT_c = 1
CODE:
  OGLM_GLEWINIT
  OGLM_CHECK_ERR(glSeparableFilter2D, )
  OGLM_AVAIL_CHECK(__glewSeparableFilter2D, glSeparableFilter2D)
  glSeparableFilter2D(target, internalformat, width, height, format, type, row, column);
  OGLM_CHECK_ERR(glSeparableFilter2D, )

void
glSetFenceAPPLE(fence)
  GLuint fence;
CODE:
  OGLM_GLEWINIT
  OGLM_CHECK_ERR(glSetFenceAPPLE, )
  OGLM_AVAIL_CHECK(__glewSetFenceAPPLE, glSetFenceAPPLE)
  glSetFenceAPPLE(fence);
  OGLM_CHECK_ERR(glSetFenceAPPLE, )

void
glSetFenceNV(fence, condition)
  GLuint fence;
  GLenum condition;
CODE:
  OGLM_GLEWINIT
  OGLM_CHECK_ERR(glSetFenceNV, )
  OGLM_AVAIL_CHECK(__glewSetFenceNV, glSetFenceNV)
  glSetFenceNV(fence, condition);
  OGLM_CHECK_ERR(glSetFenceNV, )

void
glSetFragmentShaderConstantATI_c(dst, value)
  GLuint dst;
  const GLfloat* value;
CODE:
  OGLM_GLEWINIT
  OGLM_CHECK_ERR(glSetFragmentShaderConstantATI, )
  OGLM_AVAIL_CHECK(__glewSetFragmentShaderConstantATI, glSetFragmentShaderConstantATI)
  glSetFragmentShaderConstantATI(dst, value);
  OGLM_CHECK_ERR(glSetFragmentShaderConstantATI, )

void
glSetFragmentShaderConstantATI_p(dst, ...)
  GLuint dst;
CODE:
  OGLM_GLEWINIT
  OGLM_CHECK_ERR(glSetFragmentShaderConstantATI, )
  OGLM_AVAIL_CHECK(__glewSetFragmentShaderConstantATI, glSetFragmentShaderConstantATI)
  GLfloat* value = OGLM_GET_VARARGS(value,1,GLfloat,NV,4);
  glSetFragmentShaderConstantATI((GLuint )dst, (const GLfloat* )value);
  OGLM_CHECK_ERR(glSetFragmentShaderConstantATI, free(value);)
  free(value);

void
glSetInvariantEXT_c(id, type, addr)
  GLuint id;
  GLenum type;
  void *addr;
CODE:
  OGLM_GLEWINIT
  OGLM_CHECK_ERR(glSetInvariantEXT, )
  OGLM_AVAIL_CHECK(__glewSetInvariantEXT, glSetInvariantEXT)
  glSetInvariantEXT(id, type, addr);
  OGLM_CHECK_ERR(glSetInvariantEXT, )

void
glSetLocalConstantEXT_c(id, type, addr)
  GLuint id;
  GLenum type;
  void *addr;
CODE:
  OGLM_GLEWINIT
  OGLM_CHECK_ERR(glSetLocalConstantEXT, )
  OGLM_AVAIL_CHECK(__glewSetLocalConstantEXT, glSetLocalConstantEXT)
  glSetLocalConstantEXT(id, type, addr);
  OGLM_CHECK_ERR(glSetLocalConstantEXT, )

void
glSetMultisamplefvAMD_c(pname, index, val)
  GLenum pname;
  GLuint index;
  const GLfloat* val;
CODE:
  OGLM_GLEWINIT
  OGLM_CHECK_ERR(glSetMultisamplefvAMD, )
  OGLM_AVAIL_CHECK(__glewSetMultisamplefvAMD, glSetMultisamplefvAMD)
  glSetMultisamplefvAMD(pname, index, val);
  OGLM_CHECK_ERR(glSetMultisamplefvAMD, )

void
glSetMultisamplefvAMD_p(pname, index, ...)
  GLenum pname;
  GLuint index;
CODE:
  OGLM_GLEWINIT
  OGLM_CHECK_ERR(glSetMultisamplefvAMD, )
  OGLM_AVAIL_CHECK(__glewSetMultisamplefvAMD, glSetMultisamplefvAMD)
  GLfloat* val = OGLM_GET_VARARGS(val,2,GLfloat,NV,2);
  glSetMultisamplefvAMD((GLenum )pname, (GLuint )index, (const GLfloat* )val);
  OGLM_CHECK_ERR(glSetMultisamplefvAMD, free(val);)
  free(val);

void
glShadeModel(mode)
  GLenum mode;
CODE:
  OGLM_GLEWINIT
  OGLM_CHECK_ERR(glShadeModel, )
  glShadeModel(mode);
  OGLM_CHECK_ERR(glShadeModel, )

void
glShaderBinary_c(count, shaders, binaryFormat, binary, length)
  GLsizei count;
  const GLuint* shaders;
  GLenum binaryFormat;
  const void*binary;
  GLsizei length;
CODE:
  OGLM_GLEWINIT
  OGLM_CHECK_ERR(glShaderBinary, )
  OGLM_AVAIL_CHECK(__glewShaderBinary, glShaderBinary)
  glShaderBinary(count, shaders, binaryFormat, binary, length);
  OGLM_CHECK_ERR(glShaderBinary, )

void
glShaderOp1EXT(op, res, arg1)
  GLenum op;
  GLuint res;
  GLuint arg1;
CODE:
  OGLM_GLEWINIT
  OGLM_CHECK_ERR(glShaderOp1EXT, )
  OGLM_AVAIL_CHECK(__glewShaderOp1EXT, glShaderOp1EXT)
  glShaderOp1EXT(op, res, arg1);
  OGLM_CHECK_ERR(glShaderOp1EXT, )

void
glShaderOp2EXT(op, res, arg1, arg2)
  GLenum op;
  GLuint res;
  GLuint arg1;
  GLuint arg2;
CODE:
  OGLM_GLEWINIT
  OGLM_CHECK_ERR(glShaderOp2EXT, )
  OGLM_AVAIL_CHECK(__glewShaderOp2EXT, glShaderOp2EXT)
  glShaderOp2EXT(op, res, arg1, arg2);
  OGLM_CHECK_ERR(glShaderOp2EXT, )

void
glShaderOp3EXT(op, res, arg1, arg2, arg3)
  GLenum op;
  GLuint res;
  GLuint arg1;
  GLuint arg2;
  GLuint arg3;
CODE:
  OGLM_GLEWINIT
  OGLM_CHECK_ERR(glShaderOp3EXT, )
  OGLM_AVAIL_CHECK(__glewShaderOp3EXT, glShaderOp3EXT)
  glShaderOp3EXT(op, res, arg1, arg2, arg3);
  OGLM_CHECK_ERR(glShaderOp3EXT, )

void
glShaderSource_c(shader, count, string, length)
  GLuint shader;
  GLsizei count;
  const GLchar *const* string;
  const GLint* length;
CODE:
  OGLM_GLEWINIT
  OGLM_CHECK_ERR(glShaderSource, )
  OGLM_AVAIL_CHECK(__glewShaderSource, glShaderSource)
  glShaderSource(shader, count, string, length);
  OGLM_CHECK_ERR(glShaderSource, )

void
glShaderSource_p(shader, ...)
  GLuint shader;
CODE:
  OGLM_GLEWINIT
  OGLM_CHECK_ERR(glShaderSource, )
  OGLM_AVAIL_CHECK(__glewShaderSource, glShaderSource)
  GLsizei count = items-1;
  GLint* length = NULL;
  GLchar ** string = OGLM_GET_VARARGS(string,1,GLchar*,PV_nolen,count);
  glShaderSource((GLuint )shader, (GLsizei )count, (const GLchar *const* )string, (const GLint* )length);
  OGLM_CHECK_ERR(glShaderSource, free(string);)
  free(string);

void
glShaderSourceARB_c(shader, count, string, length)
  GLhandleARB shader;
  GLsizei count;
  const GLcharARB ** string;
  const GLint *length;
CODE:
  OGLM_GLEWINIT
  OGLM_CHECK_ERR(glShaderSourceARB, )
  OGLM_AVAIL_CHECK(__glewShaderSourceARB, glShaderSourceARB)
  glShaderSourceARB(shader, count, string, length);
  OGLM_CHECK_ERR(glShaderSourceARB, )

void
glShaderSourceARB_p(shader, ...)
  GLhandleARB shader;
CODE:
  OGLM_GLEWINIT
  OGLM_CHECK_ERR(glShaderSourceARB, )
  OGLM_AVAIL_CHECK(__glewShaderSourceARB, glShaderSourceARB)
  GLsizei count = items-1;
  GLint *length = NULL;
  GLcharARB ** string = OGLM_GET_VARARGS(string,1,GLcharARB*,PV_nolen,count);
  glShaderSourceARB((GLhandleARB )shader, (GLsizei )count, (const GLcharARB ** )string, (const GLint *)length);
  OGLM_CHECK_ERR(glShaderSourceARB, free(string);)
  free(string);

void
glShaderStorageBlockBinding(program, storageBlockIndex, storageBlockBinding)
  GLuint program;
  GLuint storageBlockIndex;
  GLuint storageBlockBinding;
CODE:
  OGLM_GLEWINIT
  OGLM_CHECK_ERR(glShaderStorageBlockBinding, )
  OGLM_AVAIL_CHECK(__glewShaderStorageBlockBinding, glShaderStorageBlockBinding)
  glShaderStorageBlockBinding(program, storageBlockIndex, storageBlockBinding);
  OGLM_CHECK_ERR(glShaderStorageBlockBinding, )

void
glShadingRateCombinerOpsEXT(combinerOp0, combinerOp1)
  GLenum combinerOp0;
  GLenum combinerOp1;
CODE:
  OGLM_GLEWINIT
  OGLM_CHECK_ERR(glShadingRateCombinerOpsEXT, )
  OGLM_AVAIL_CHECK(__glewShadingRateCombinerOpsEXT, glShadingRateCombinerOpsEXT)
  glShadingRateCombinerOpsEXT(combinerOp0, combinerOp1);
  OGLM_CHECK_ERR(glShadingRateCombinerOpsEXT, )

void
glShadingRateEXT(rate)
  GLenum rate;
CODE:
  OGLM_GLEWINIT
  OGLM_CHECK_ERR(glShadingRateEXT, )
  OGLM_AVAIL_CHECK(__glewShadingRateEXT, glShadingRateEXT)
  glShadingRateEXT(rate);
  OGLM_CHECK_ERR(glShadingRateEXT, )

void
glShadingRateImageBarrierNV(synchronize)
  GLboolean synchronize;
CODE:
  OGLM_GLEWINIT
  OGLM_CHECK_ERR(glShadingRateImageBarrierNV, )
  OGLM_AVAIL_CHECK(__glewShadingRateImageBarrierNV, glShadingRateImageBarrierNV)
  glShadingRateImageBarrierNV(synchronize);
  OGLM_CHECK_ERR(glShadingRateImageBarrierNV, )

void
glShadingRateImagePaletteNV_c(viewport, first, count, rates)
  GLuint viewport;
  GLuint first;
  GLsizei count;
  const GLenum* rates;
CODE:
  OGLM_GLEWINIT
  OGLM_CHECK_ERR(glShadingRateImagePaletteNV, )
  OGLM_AVAIL_CHECK(__glewShadingRateImagePaletteNV, glShadingRateImagePaletteNV)
  glShadingRateImagePaletteNV(viewport, first, count, rates);
  OGLM_CHECK_ERR(glShadingRateImagePaletteNV, )

void
glShadingRateImagePaletteNV_p(viewport, first, ...)
  GLuint viewport;
  GLuint first;
CODE:
  OGLM_GLEWINIT
  OGLM_CHECK_ERR(glShadingRateImagePaletteNV, )
  OGLM_AVAIL_CHECK(__glewShadingRateImagePaletteNV, glShadingRateImagePaletteNV)
  GLsizei count = items-2;
  GLenum* rates = OGLM_GET_VARARGS(rates,2,GLenum,IV,count);
  glShadingRateImagePaletteNV((GLuint )viewport, (GLuint )first, (GLsizei )count, (const GLenum* )rates);
  OGLM_CHECK_ERR(glShadingRateImagePaletteNV, free(rates);)
  free(rates);

void
glShadingRateQCOM(rate)
  GLenum rate;
CODE:
  OGLM_GLEWINIT
  OGLM_CHECK_ERR(glShadingRateQCOM, )
  OGLM_AVAIL_CHECK(__glewShadingRateQCOM, glShadingRateQCOM)
  glShadingRateQCOM(rate);
  OGLM_CHECK_ERR(glShadingRateQCOM, )

void
glShadingRateSampleOrderCustomNV_c(rate, samples, locations)
  GLenum rate;
  GLuint samples;
  const GLint* locations;
CODE:
  OGLM_GLEWINIT
  OGLM_CHECK_ERR(glShadingRateSampleOrderCustomNV, )
  OGLM_AVAIL_CHECK(__glewShadingRateSampleOrderCustomNV, glShadingRateSampleOrderCustomNV)
  glShadingRateSampleOrderCustomNV(rate, samples, locations);
  OGLM_CHECK_ERR(glShadingRateSampleOrderCustomNV, )

void
glShadingRateSampleOrderNV(order)
  GLenum order;
CODE:
  OGLM_GLEWINIT
  OGLM_CHECK_ERR(glShadingRateSampleOrderNV, )
  OGLM_AVAIL_CHECK(__glewShadingRateSampleOrderNV, glShadingRateSampleOrderNV)
  glShadingRateSampleOrderNV(order);
  OGLM_CHECK_ERR(glShadingRateSampleOrderNV, )

void
glSharpenTexFuncSGIS_c(target, n, points)
  GLenum target;
  GLsizei n;
  const GLfloat* points;
CODE:
  OGLM_GLEWINIT
  OGLM_CHECK_ERR(glSharpenTexFuncSGIS, )
  OGLM_AVAIL_CHECK(__glewSharpenTexFuncSGIS, glSharpenTexFuncSGIS)
  glSharpenTexFuncSGIS(target, n, points);
  OGLM_CHECK_ERR(glSharpenTexFuncSGIS, )

void
glSharpenTexFuncSGIS_p(target, n, ...)
  GLenum target;
  GLsizei n;
CODE:
  OGLM_GLEWINIT
  OGLM_CHECK_ERR(glSharpenTexFuncSGIS, )
  OGLM_AVAIL_CHECK(__glewSharpenTexFuncSGIS, glSharpenTexFuncSGIS)
  GLfloat* points = OGLM_GET_VARARGS(points,2,GLfloat,NV,n*2);
  glSharpenTexFuncSGIS((GLenum )target, (GLsizei )n, (const GLfloat* )points);
  OGLM_CHECK_ERR(glSharpenTexFuncSGIS, free(points);)
  free(points);

void
glSignalSemaphoreEXT_c(semaphore, numBufferBarriers, buffers, numTextureBarriers, textures, dstLayouts)
  GLuint semaphore;
  GLuint numBufferBarriers;
  const GLuint* buffers;
  GLuint numTextureBarriers;
  const GLuint *textures;
  const GLenum *dstLayouts;
CODE:
  OGLM_GLEWINIT
  OGLM_CHECK_ERR(glSignalSemaphoreEXT, )
  OGLM_AVAIL_CHECK(__glewSignalSemaphoreEXT, glSignalSemaphoreEXT)
  glSignalSemaphoreEXT(semaphore, numBufferBarriers, buffers, numTextureBarriers, textures, dstLayouts);
  OGLM_CHECK_ERR(glSignalSemaphoreEXT, )

void
glSignalSemaphoreui64NVX_c(signalGpu, fenceObjectCount, semaphoreArray, fenceValueArray)
  GLuint signalGpu;
  GLsizei fenceObjectCount;
  const GLuint* semaphoreArray;
  const GLuint64 *fenceValueArray;
CODE:
  OGLM_GLEWINIT
  OGLM_CHECK_ERR(glSignalSemaphoreui64NVX, )
  OGLM_AVAIL_CHECK(__glewSignalSemaphoreui64NVX, glSignalSemaphoreui64NVX)
  glSignalSemaphoreui64NVX(signalGpu, fenceObjectCount, semaphoreArray, fenceValueArray);
  OGLM_CHECK_ERR(glSignalSemaphoreui64NVX, )

void
glSignalSemaphoreui64NVX_p(signalGpu, semaphoreArraySV, fenceValueArraySV)
  GLuint signalGpu;
  SV *semaphoreArraySV;
  SV *fenceValueArraySV;
CODE:
  OGLM_GLEWINIT
  OGLM_CHECK_ERR(glSignalSemaphoreui64NVX, )
  OGLM_AVAIL_CHECK(__glewSignalSemaphoreui64NVX, glSignalSemaphoreui64NVX)
  GLsizei fenceObjectCount = OGLM_LEN_ARRAY(fenceObjectCount, semaphoreArray);
  GLuint64 *fenceValueArray = OGLM_GET_ARRAY(fenceValueArray, GLuint64, UV, fenceObjectCount);
  GLuint* semaphoreArray = OGLM_GET_ARRAY(semaphoreArray, GLuint, UV, fenceObjectCount);
  glSignalSemaphoreui64NVX((GLuint )signalGpu, (GLsizei )fenceObjectCount, (const GLuint* )semaphoreArray, (const GLuint64 *)fenceValueArray);
  OGLM_CHECK_ERR(glSignalSemaphoreui64NVX, free(fenceValueArray);free(semaphoreArray);)
  free(fenceValueArray);free(semaphoreArray);

void
glSignalVkFenceNV(vkFence)
  GLuint64 vkFence;
CODE:
  OGLM_GLEWINIT
  OGLM_CHECK_ERR(glSignalVkFenceNV, )
  OGLM_AVAIL_CHECK(__glewSignalVkFenceNV, glSignalVkFenceNV)
  glSignalVkFenceNV(vkFence);
  OGLM_CHECK_ERR(glSignalVkFenceNV, )

void
glSignalVkSemaphoreNV(vkSemaphore)
  GLuint64 vkSemaphore;
CODE:
  OGLM_GLEWINIT
  OGLM_CHECK_ERR(glSignalVkSemaphoreNV, )
  OGLM_AVAIL_CHECK(__glewSignalVkSemaphoreNV, glSignalVkSemaphoreNV)
  glSignalVkSemaphoreNV(vkSemaphore);
  OGLM_CHECK_ERR(glSignalVkSemaphoreNV, )

void
glSpecializeShader_c(shader, pEntryPoint, numSpecializationConstants, pConstantIndex, pConstantValue)
  GLuint shader;
  const GLchar *pEntryPoint;
  GLuint numSpecializationConstants;
  const GLuint *pConstantIndex;
  const GLuint *pConstantValue;
ALIAS:
  glSpecializeShaderARB_c = 1
CODE:
  OGLM_GLEWINIT
  OGLM_CHECK_ERR(glSpecializeShader, )
  OGLM_AVAIL_CHECK(__glewSpecializeShader, glSpecializeShader)
  glSpecializeShader(shader, pEntryPoint, numSpecializationConstants, pConstantIndex, pConstantValue);
  OGLM_CHECK_ERR(glSpecializeShader, )

void
glSpecializeShader_p(shader, pEntryPoint, pConstantIndexSV, pConstantValueSV)
  GLuint shader;
  const GLchar *pEntryPoint;
  SV *pConstantIndexSV;
  SV *pConstantValueSV;
ALIAS:
  glSpecializeShaderARB_p = 1
CODE:
  OGLM_GLEWINIT
  OGLM_CHECK_ERR(glSpecializeShader, )
  OGLM_AVAIL_CHECK(__glewSpecializeShader, glSpecializeShader)
  GLuint numSpecializationConstants = OGLM_LEN_ARRAY(numSpecializationConstants, pConstantIndex);
  GLuint *pConstantIndex = OGLM_GET_ARRAY(pConstantIndex, GLuint, UV, numSpecializationConstants);
  GLuint *pConstantValue = OGLM_GET_ARRAY(pConstantValue, GLuint, UV, numSpecializationConstants);
  glSpecializeShader((GLuint )shader, (const GLchar *)pEntryPoint, (GLuint )numSpecializationConstants, (const GLuint *)pConstantIndex, (const GLuint *)pConstantValue);
  OGLM_CHECK_ERR(glSpecializeShader, free(pConstantIndex);free(pConstantValue);)
  free(pConstantIndex);free(pConstantValue);

void
glSpriteParameterfSGIX(pname, param)
  GLenum pname;
  GLfloat param;
CODE:
  OGLM_GLEWINIT
  OGLM_CHECK_ERR(glSpriteParameterfSGIX, )
  OGLM_AVAIL_CHECK(__glewSpriteParameterfSGIX, glSpriteParameterfSGIX)
  glSpriteParameterfSGIX(pname, param);
  OGLM_CHECK_ERR(glSpriteParameterfSGIX, )

void
glSpriteParameterfvSGIX_c(pname, params)
  GLenum pname;
  GLfloat* params;
CODE:
  OGLM_GLEWINIT
  OGLM_CHECK_ERR(glSpriteParameterfvSGIX, )
  OGLM_AVAIL_CHECK(__glewSpriteParameterfvSGIX, glSpriteParameterfvSGIX)
  glSpriteParameterfvSGIX(pname, params);
  OGLM_CHECK_ERR(glSpriteParameterfvSGIX, )

void
glSpriteParameteriSGIX(pname, param)
  GLenum pname;
  GLint param;
CODE:
  OGLM_GLEWINIT
  OGLM_CHECK_ERR(glSpriteParameteriSGIX, )
  OGLM_AVAIL_CHECK(__glewSpriteParameteriSGIX, glSpriteParameteriSGIX)
  glSpriteParameteriSGIX(pname, param);
  OGLM_CHECK_ERR(glSpriteParameteriSGIX, )

void
glSpriteParameterivSGIX_c(pname, params)
  GLenum pname;
  GLint* params;
CODE:
  OGLM_GLEWINIT
  OGLM_CHECK_ERR(glSpriteParameterivSGIX, )
  OGLM_AVAIL_CHECK(__glewSpriteParameterivSGIX, glSpriteParameterivSGIX)
  glSpriteParameterivSGIX(pname, params);
  OGLM_CHECK_ERR(glSpriteParameterivSGIX, )

void
glStartTilingQCOM(x, y, width, height, preserveMask)
  GLuint x;
  GLuint y;
  GLuint width;
  GLuint height;
  GLbitfield preserveMask;
CODE:
  OGLM_GLEWINIT
  OGLM_CHECK_ERR(glStartTilingQCOM, )
  OGLM_AVAIL_CHECK(__glewStartTilingQCOM, glStartTilingQCOM)
  glStartTilingQCOM(x, y, width, height, preserveMask);
  OGLM_CHECK_ERR(glStartTilingQCOM, )

void
glStateCaptureNV(state, mode)
  GLuint state;
  GLenum mode;
CODE:
  OGLM_GLEWINIT
  OGLM_CHECK_ERR(glStateCaptureNV, )
  OGLM_AVAIL_CHECK(__glewStateCaptureNV, glStateCaptureNV)
  glStateCaptureNV(state, mode);
  OGLM_CHECK_ERR(glStateCaptureNV, )

void
glStencilFillPathInstancedNV_c(numPaths, pathNameType, paths, pathBase, fillMode, mask, transformType, transformValues)
  GLsizei numPaths;
  GLenum pathNameType;
  const void *paths;
  GLuint pathBase;
  GLenum fillMode;
  GLuint mask;
  GLenum transformType;
  const GLfloat *transformValues;
CODE:
  OGLM_GLEWINIT
  OGLM_CHECK_ERR(glStencilFillPathInstancedNV, )
  OGLM_AVAIL_CHECK(__glewStencilFillPathInstancedNV, glStencilFillPathInstancedNV)
  glStencilFillPathInstancedNV(numPaths, pathNameType, paths, pathBase, fillMode, mask, transformType, transformValues);
  OGLM_CHECK_ERR(glStencilFillPathInstancedNV, )

void
glStencilFillPathNV(path, fillMode, mask)
  GLuint path;
  GLenum fillMode;
  GLuint mask;
CODE:
  OGLM_GLEWINIT
  OGLM_CHECK_ERR(glStencilFillPathNV, )
  OGLM_AVAIL_CHECK(__glewStencilFillPathNV, glStencilFillPathNV)
  glStencilFillPathNV(path, fillMode, mask);
  OGLM_CHECK_ERR(glStencilFillPathNV, )

void
glStencilFunc(func, ref, mask)
  GLenum func;
  GLint ref;
  GLuint mask;
CODE:
  OGLM_GLEWINIT
  OGLM_CHECK_ERR(glStencilFunc, )
  glStencilFunc(func, ref, mask);
  OGLM_CHECK_ERR(glStencilFunc, )

void
glStencilFuncSeparate(face, func, ref, mask)
  GLenum face;
  GLenum func;
  GLint ref;
  GLuint mask;
CODE:
  OGLM_GLEWINIT
  OGLM_CHECK_ERR(glStencilFuncSeparate, )
  OGLM_AVAIL_CHECK(__glewStencilFuncSeparate, glStencilFuncSeparate)
  glStencilFuncSeparate(face, func, ref, mask);
  OGLM_CHECK_ERR(glStencilFuncSeparate, )

void
glStencilFuncSeparateATI(frontfunc, backfunc, ref, mask)
  GLenum frontfunc;
  GLenum backfunc;
  GLint ref;
  GLuint mask;
CODE:
  OGLM_GLEWINIT
  OGLM_CHECK_ERR(glStencilFuncSeparateATI, )
  OGLM_AVAIL_CHECK(__glewStencilFuncSeparateATI, glStencilFuncSeparateATI)
  glStencilFuncSeparateATI(frontfunc, backfunc, ref, mask);
  OGLM_CHECK_ERR(glStencilFuncSeparateATI, )

void
glStencilMask(mask)
  GLuint mask;
CODE:
  OGLM_GLEWINIT
  OGLM_CHECK_ERR(glStencilMask, )
  glStencilMask(mask);
  OGLM_CHECK_ERR(glStencilMask, )

void
glStencilMaskSeparate(face, mask)
  GLenum face;
  GLuint mask;
CODE:
  OGLM_GLEWINIT
  OGLM_CHECK_ERR(glStencilMaskSeparate, )
  OGLM_AVAIL_CHECK(__glewStencilMaskSeparate, glStencilMaskSeparate)
  glStencilMaskSeparate(face, mask);
  OGLM_CHECK_ERR(glStencilMaskSeparate, )

void
glStencilOp(fail, zfail, zpass)
  GLenum fail;
  GLenum zfail;
  GLenum zpass;
CODE:
  OGLM_GLEWINIT
  OGLM_CHECK_ERR(glStencilOp, )
  glStencilOp(fail, zfail, zpass);
  OGLM_CHECK_ERR(glStencilOp, )

void
glStencilOpSeparate(face, sfail, dpfail, dppass)
  GLenum face;
  GLenum sfail;
  GLenum dpfail;
  GLenum dppass;
ALIAS:
  glStencilOpSeparateATI = 1
CODE:
  OGLM_GLEWINIT
  OGLM_CHECK_ERR(glStencilOpSeparate, )
  OGLM_AVAIL_CHECK(__glewStencilOpSeparate, glStencilOpSeparate)
  glStencilOpSeparate(face, sfail, dpfail, dppass);
  OGLM_CHECK_ERR(glStencilOpSeparate, )

void
glStencilOpValueAMD(face, value)
  GLenum face;
  GLuint value;
CODE:
  OGLM_GLEWINIT
  OGLM_CHECK_ERR(glStencilOpValueAMD, )
  OGLM_AVAIL_CHECK(__glewStencilOpValueAMD, glStencilOpValueAMD)
  glStencilOpValueAMD(face, value);
  OGLM_CHECK_ERR(glStencilOpValueAMD, )

void
glStencilStrokePathInstancedNV_c(numPaths, pathNameType, paths, pathBase, reference, mask, transformType, transformValues)
  GLsizei numPaths;
  GLenum pathNameType;
  const void *paths;
  GLuint pathBase;
  GLint reference;
  GLuint mask;
  GLenum transformType;
  const GLfloat *transformValues;
CODE:
  OGLM_GLEWINIT
  OGLM_CHECK_ERR(glStencilStrokePathInstancedNV, )
  OGLM_AVAIL_CHECK(__glewStencilStrokePathInstancedNV, glStencilStrokePathInstancedNV)
  glStencilStrokePathInstancedNV(numPaths, pathNameType, paths, pathBase, reference, mask, transformType, transformValues);
  OGLM_CHECK_ERR(glStencilStrokePathInstancedNV, )

void
glStencilStrokePathNV(path, reference, mask)
  GLuint path;
  GLint reference;
  GLuint mask;
CODE:
  OGLM_GLEWINIT
  OGLM_CHECK_ERR(glStencilStrokePathNV, )
  OGLM_AVAIL_CHECK(__glewStencilStrokePathNV, glStencilStrokePathNV)
  glStencilStrokePathNV(path, reference, mask);
  OGLM_CHECK_ERR(glStencilStrokePathNV, )

void
glStencilThenCoverFillPathInstancedNV_c(numPaths, pathNameType, paths, pathBase, fillMode, mask, coverMode, transformType, transformValues)
  GLsizei numPaths;
  GLenum pathNameType;
  const void *paths;
  GLuint pathBase;
  GLenum fillMode;
  GLuint mask;
  GLenum coverMode;
  GLenum transformType;
  const GLfloat *transformValues;
CODE:
  OGLM_GLEWINIT
  OGLM_CHECK_ERR(glStencilThenCoverFillPathInstancedNV, )
  OGLM_AVAIL_CHECK(__glewStencilThenCoverFillPathInstancedNV, glStencilThenCoverFillPathInstancedNV)
  glStencilThenCoverFillPathInstancedNV(numPaths, pathNameType, paths, pathBase, fillMode, mask, coverMode, transformType, transformValues);
  OGLM_CHECK_ERR(glStencilThenCoverFillPathInstancedNV, )

void
glStencilThenCoverFillPathNV(path, fillMode, mask, coverMode)
  GLuint path;
  GLenum fillMode;
  GLuint mask;
  GLenum coverMode;
CODE:
  OGLM_GLEWINIT
  OGLM_CHECK_ERR(glStencilThenCoverFillPathNV, )
  OGLM_AVAIL_CHECK(__glewStencilThenCoverFillPathNV, glStencilThenCoverFillPathNV)
  glStencilThenCoverFillPathNV(path, fillMode, mask, coverMode);
  OGLM_CHECK_ERR(glStencilThenCoverFillPathNV, )

void
glStencilThenCoverStrokePathInstancedNV_c(numPaths, pathNameType, paths, pathBase, reference, mask, coverMode, transformType, transformValues)
  GLsizei numPaths;
  GLenum pathNameType;
  const void *paths;
  GLuint pathBase;
  GLint reference;
  GLuint mask;
  GLenum coverMode;
  GLenum transformType;
  const GLfloat *transformValues;
CODE:
  OGLM_GLEWINIT
  OGLM_CHECK_ERR(glStencilThenCoverStrokePathInstancedNV, )
  OGLM_AVAIL_CHECK(__glewStencilThenCoverStrokePathInstancedNV, glStencilThenCoverStrokePathInstancedNV)
  glStencilThenCoverStrokePathInstancedNV(numPaths, pathNameType, paths, pathBase, reference, mask, coverMode, transformType, transformValues);
  OGLM_CHECK_ERR(glStencilThenCoverStrokePathInstancedNV, )

void
glStencilThenCoverStrokePathNV(path, reference, mask, coverMode)
  GLuint path;
  GLint reference;
  GLuint mask;
  GLenum coverMode;
CODE:
  OGLM_GLEWINIT
  OGLM_CHECK_ERR(glStencilThenCoverStrokePathNV, )
  OGLM_AVAIL_CHECK(__glewStencilThenCoverStrokePathNV, glStencilThenCoverStrokePathNV)
  glStencilThenCoverStrokePathNV(path, reference, mask, coverMode);
  OGLM_CHECK_ERR(glStencilThenCoverStrokePathNV, )

void
glStereoParameterfNV(pname, param)
  GLenum pname;
  GLfloat param;
CODE:
  OGLM_GLEWINIT
  OGLM_CHECK_ERR(glStereoParameterfNV, )
  OGLM_AVAIL_CHECK(__glewStereoParameterfNV, glStereoParameterfNV)
  glStereoParameterfNV(pname, param);
  OGLM_CHECK_ERR(glStereoParameterfNV, )

void
glStereoParameteriNV(pname, param)
  GLenum pname;
  GLint param;
CODE:
  OGLM_GLEWINIT
  OGLM_CHECK_ERR(glStereoParameteriNV, )
  OGLM_AVAIL_CHECK(__glewStereoParameteriNV, glStereoParameteriNV)
  glStereoParameteriNV(pname, param);
  OGLM_CHECK_ERR(glStereoParameteriNV, )

void
glStringMarkerGREMEDY_c(len, string)
  GLsizei len;
  const void *string;
CODE:
  OGLM_GLEWINIT
  OGLM_CHECK_ERR(glStringMarkerGREMEDY, )
  OGLM_AVAIL_CHECK(__glewStringMarkerGREMEDY, glStringMarkerGREMEDY)
  glStringMarkerGREMEDY(len, string);
  OGLM_CHECK_ERR(glStringMarkerGREMEDY, )

void
glSubpixelPrecisionBiasNV(xbits, ybits)
  GLuint xbits;
  GLuint ybits;
CODE:
  OGLM_GLEWINIT
  OGLM_CHECK_ERR(glSubpixelPrecisionBiasNV, )
  OGLM_AVAIL_CHECK(__glewSubpixelPrecisionBiasNV, glSubpixelPrecisionBiasNV)
  glSubpixelPrecisionBiasNV(xbits, ybits);
  OGLM_CHECK_ERR(glSubpixelPrecisionBiasNV, )

void
glSwapMPEGPredictorsSGIX(target0, target1)
  GLenum target0;
  GLenum target1;
CODE:
  OGLM_GLEWINIT
  OGLM_CHECK_ERR(glSwapMPEGPredictorsSGIX, )
  OGLM_AVAIL_CHECK(__glewSwapMPEGPredictorsSGIX, glSwapMPEGPredictorsSGIX)
  glSwapMPEGPredictorsSGIX(target0, target1);
  OGLM_CHECK_ERR(glSwapMPEGPredictorsSGIX, )

void
glSwizzleEXT(res, in, outX, outY, outZ, outW)
  GLuint res;
  GLuint in;
  GLenum outX;
  GLenum outY;
  GLenum outZ;
  GLenum outW;
CODE:
  OGLM_GLEWINIT
  OGLM_CHECK_ERR(glSwizzleEXT, )
  OGLM_AVAIL_CHECK(__glewSwizzleEXT, glSwizzleEXT)
  glSwizzleEXT(res, in, outX, outY, outZ, outW);
  OGLM_CHECK_ERR(glSwizzleEXT, )

void
glSyncTextureINTEL(texture)
  GLuint texture;
CODE:
  OGLM_GLEWINIT
  OGLM_CHECK_ERR(glSyncTextureINTEL, )
  OGLM_AVAIL_CHECK(__glewSyncTextureINTEL, glSyncTextureINTEL)
  glSyncTextureINTEL(texture);
  OGLM_CHECK_ERR(glSyncTextureINTEL, )

void
glTagSampleBufferSGIX()
CODE:
  OGLM_GLEWINIT
  OGLM_CHECK_ERR(glTagSampleBufferSGIX, )
  OGLM_AVAIL_CHECK(__glewTagSampleBufferSGIX, glTagSampleBufferSGIX)
  glTagSampleBufferSGIX();
  OGLM_CHECK_ERR(glTagSampleBufferSGIX, )

void
glTangentPointerEXT_c(type, stride, pointer)
  GLenum type;
  GLsizei stride;
  void *pointer;
CODE:
  OGLM_GLEWINIT
  OGLM_CHECK_ERR(glTangentPointerEXT, )
  OGLM_AVAIL_CHECK(__glewTangentPointerEXT, glTangentPointerEXT)
  glTangentPointerEXT(type, stride, pointer);
  OGLM_CHECK_ERR(glTangentPointerEXT, )

void
glTbufferMask3DFX(mask)
  GLuint mask;
CODE:
  OGLM_GLEWINIT
  OGLM_CHECK_ERR(glTbufferMask3DFX, )
  OGLM_AVAIL_CHECK(__glewTbufferMask3DFX, glTbufferMask3DFX)
  glTbufferMask3DFX(mask);
  OGLM_CHECK_ERR(glTbufferMask3DFX, )

void
glTessellationFactorAMD(factor)
  GLfloat factor;
CODE:
  OGLM_GLEWINIT
  OGLM_CHECK_ERR(glTessellationFactorAMD, )
  OGLM_AVAIL_CHECK(__glewTessellationFactorAMD, glTessellationFactorAMD)
  glTessellationFactorAMD(factor);
  OGLM_CHECK_ERR(glTessellationFactorAMD, )

void
glTessellationModeAMD(mode)
  GLenum mode;
CODE:
  OGLM_GLEWINIT
  OGLM_CHECK_ERR(glTessellationModeAMD, )
  OGLM_AVAIL_CHECK(__glewTessellationModeAMD, glTessellationModeAMD)
  glTessellationModeAMD(mode);
  OGLM_CHECK_ERR(glTessellationModeAMD, )

GLboolean
glTestFenceAPPLE(fence)
  GLuint fence;
CODE:
  OGLM_GLEWINIT
  OGLM_CHECK_ERR(glTestFenceAPPLE, )
  OGLM_AVAIL_CHECK(__glewTestFenceAPPLE, glTestFenceAPPLE)
  RETVAL = glTestFenceAPPLE(fence);
  OGLM_CHECK_ERR(glTestFenceAPPLE, )
OUTPUT:
  RETVAL

GLboolean
glTestFenceNV(fence)
  GLuint fence;
CODE:
  OGLM_GLEWINIT
  OGLM_CHECK_ERR(glTestFenceNV, )
  OGLM_AVAIL_CHECK(__glewTestFenceNV, glTestFenceNV)
  RETVAL = glTestFenceNV(fence);
  OGLM_CHECK_ERR(glTestFenceNV, )
OUTPUT:
  RETVAL

GLboolean
glTestObjectAPPLE(object, name)
  GLenum object;
  GLuint name;
CODE:
  OGLM_GLEWINIT
  OGLM_CHECK_ERR(glTestObjectAPPLE, )
  OGLM_AVAIL_CHECK(__glewTestObjectAPPLE, glTestObjectAPPLE)
  RETVAL = glTestObjectAPPLE(object, name);
  OGLM_CHECK_ERR(glTestObjectAPPLE, )
OUTPUT:
  RETVAL

void
glTexAttachMemoryNV(target, memory, offset)
  GLenum target;
  GLuint memory;
  GLuint64 offset;
CODE:
  OGLM_GLEWINIT
  OGLM_CHECK_ERR(glTexAttachMemoryNV, )
  OGLM_AVAIL_CHECK(__glewTexAttachMemoryNV, glTexAttachMemoryNV)
  glTexAttachMemoryNV(target, memory, offset);
  OGLM_CHECK_ERR(glTexAttachMemoryNV, )

void
glTexBuffer(target, internalformat, buffer)
  GLenum target;
  GLenum internalformat;
  GLuint buffer;
ALIAS:
  glTexBufferARB = 1
  glTexBufferEXT = 2
CODE:
  OGLM_GLEWINIT
  OGLM_CHECK_ERR(glTexBuffer, )
  OGLM_AVAIL_CHECK(__glewTexBuffer, glTexBuffer)
  glTexBuffer(target, internalformat, buffer);
  OGLM_CHECK_ERR(glTexBuffer, )

void
glTexBufferOES(target, internalformat, buffer)
  GLenum target;
  GLenum internalformat;
  GLuint buffer;
CODE:
  OGLM_GLEWINIT
  OGLM_CHECK_ERR(glTexBufferOES, )
  OGLM_AVAIL_CHECK(__glewTexBufferOES, glTexBufferOES)
  glTexBufferOES(target, internalformat, buffer);
  OGLM_CHECK_ERR(glTexBufferOES, )

void
glTexBufferRange(target, internalformat, buffer, offset, size)
  GLenum target;
  GLenum internalformat;
  GLuint buffer;
  GLintptr offset;
  GLsizeiptr size;
ALIAS:
  glTexBufferRangeEXT = 1
CODE:
  OGLM_GLEWINIT
  OGLM_CHECK_ERR(glTexBufferRange, )
  OGLM_AVAIL_CHECK(__glewTexBufferRange, glTexBufferRange)
  glTexBufferRange(target, internalformat, buffer, offset, size);
  OGLM_CHECK_ERR(glTexBufferRange, )

void
glTexBufferRangeOES(target, internalformat, buffer, offset, size)
  GLenum target;
  GLenum internalformat;
  GLuint buffer;
  GLintptr offset;
  GLsizeiptr size;
CODE:
  OGLM_GLEWINIT
  OGLM_CHECK_ERR(glTexBufferRangeOES, )
  OGLM_AVAIL_CHECK(__glewTexBufferRangeOES, glTexBufferRangeOES)
  glTexBufferRangeOES(target, internalformat, buffer, offset, size);
  OGLM_CHECK_ERR(glTexBufferRangeOES, )

void
glTexBumpParameterfvATI_c(pname, param)
  GLenum pname;
  GLfloat *param;
CODE:
  OGLM_GLEWINIT
  OGLM_CHECK_ERR(glTexBumpParameterfvATI, )
  OGLM_AVAIL_CHECK(__glewTexBumpParameterfvATI, glTexBumpParameterfvATI)
  glTexBumpParameterfvATI(pname, param);
  OGLM_CHECK_ERR(glTexBumpParameterfvATI, )

void
glTexBumpParameterivATI_c(pname, param)
  GLenum pname;
  GLint *param;
CODE:
  OGLM_GLEWINIT
  OGLM_CHECK_ERR(glTexBumpParameterivATI, )
  OGLM_AVAIL_CHECK(__glewTexBumpParameterivATI, glTexBumpParameterivATI)
  glTexBumpParameterivATI(pname, param);
  OGLM_CHECK_ERR(glTexBumpParameterivATI, )

void
glTexCoord1d(s)
  GLdouble s;
CODE:
  OGLM_GLEWINIT
  OGLM_CHECK_ERR(glTexCoord1d, )
  glTexCoord1d(s);
  OGLM_CHECK_ERR(glTexCoord1d, )

void
glTexCoord1dv_c(v)
  const GLdouble *v;
CODE:
  OGLM_GLEWINIT
  OGLM_CHECK_ERR(glTexCoord1dv, )
  glTexCoord1dv(v);
  OGLM_CHECK_ERR(glTexCoord1dv, )

void
glTexCoord1dv_p(...)
CODE:
  OGLM_GLEWINIT
  OGLM_CHECK_ERR(glTexCoord1dv, )
  GLdouble *v = OGLM_GET_VARARGS(v,0,GLdouble,NV,1);
  glTexCoord1dv((const GLdouble *)v);
  OGLM_CHECK_ERR(glTexCoord1dv, free(v);)
  free(v);

void
glTexCoord1f(s)
  GLfloat s;
CODE:
  OGLM_GLEWINIT
  OGLM_CHECK_ERR(glTexCoord1f, )
  glTexCoord1f(s);
  OGLM_CHECK_ERR(glTexCoord1f, )

void
glTexCoord1fv_c(v)
  const GLfloat *v;
CODE:
  OGLM_GLEWINIT
  OGLM_CHECK_ERR(glTexCoord1fv, )
  glTexCoord1fv(v);
  OGLM_CHECK_ERR(glTexCoord1fv, )

void
glTexCoord1fv_p(...)
CODE:
  OGLM_GLEWINIT
  OGLM_CHECK_ERR(glTexCoord1fv, )
  GLfloat *v = OGLM_GET_VARARGS(v,0,GLfloat,NV,1);
  glTexCoord1fv((const GLfloat *)v);
  OGLM_CHECK_ERR(glTexCoord1fv, free(v);)
  free(v);

void
glTexCoord1hNV(s)
  GLhalf s;
CODE:
  OGLM_GLEWINIT
  OGLM_CHECK_ERR(glTexCoord1hNV, )
  OGLM_AVAIL_CHECK(__glewTexCoord1hNV, glTexCoord1hNV)
  glTexCoord1hNV(s);
  OGLM_CHECK_ERR(glTexCoord1hNV, )

void
glTexCoord1hvNV_c(v)
  const GLhalf* v;
CODE:
  OGLM_GLEWINIT
  OGLM_CHECK_ERR(glTexCoord1hvNV, )
  OGLM_AVAIL_CHECK(__glewTexCoord1hvNV, glTexCoord1hvNV)
  glTexCoord1hvNV(v);
  OGLM_CHECK_ERR(glTexCoord1hvNV, )

void
glTexCoord1hvNV_p(...)
CODE:
  OGLM_GLEWINIT
  OGLM_CHECK_ERR(glTexCoord1hvNV, )
  OGLM_AVAIL_CHECK(__glewTexCoord1hvNV, glTexCoord1hvNV)
  GLhalf* v = OGLM_GET_VARARGS(v,0,GLhalf,NV,1);
  glTexCoord1hvNV((const GLhalf* )v);
  OGLM_CHECK_ERR(glTexCoord1hvNV, free(v);)
  free(v);

void
glTexCoord1i(s)
  GLint s;
CODE:
  OGLM_GLEWINIT
  OGLM_CHECK_ERR(glTexCoord1i, )
  glTexCoord1i(s);
  OGLM_CHECK_ERR(glTexCoord1i, )

void
glTexCoord1iv_c(v)
  const GLint *v;
CODE:
  OGLM_GLEWINIT
  OGLM_CHECK_ERR(glTexCoord1iv, )
  glTexCoord1iv(v);
  OGLM_CHECK_ERR(glTexCoord1iv, )

void
glTexCoord1iv_p(...)
CODE:
  OGLM_GLEWINIT
  OGLM_CHECK_ERR(glTexCoord1iv, )
  GLint *v = OGLM_GET_VARARGS(v,0,GLint,IV,1);
  glTexCoord1iv((const GLint *)v);
  OGLM_CHECK_ERR(glTexCoord1iv, free(v);)
  free(v);

void
glTexCoord1s(s)
  GLshort s;
CODE:
  OGLM_GLEWINIT
  OGLM_CHECK_ERR(glTexCoord1s, )
  glTexCoord1s(s);
  OGLM_CHECK_ERR(glTexCoord1s, )

void
glTexCoord1sv_c(v)
  const GLshort *v;
CODE:
  OGLM_GLEWINIT
  OGLM_CHECK_ERR(glTexCoord1sv, )
  glTexCoord1sv(v);
  OGLM_CHECK_ERR(glTexCoord1sv, )

void
glTexCoord1sv_p(...)
CODE:
  OGLM_GLEWINIT
  OGLM_CHECK_ERR(glTexCoord1sv, )
  GLshort *v = OGLM_GET_VARARGS(v,0,GLshort,IV,1);
  glTexCoord1sv((const GLshort *)v);
  OGLM_CHECK_ERR(glTexCoord1sv, free(v);)
  free(v);

void
glTexCoord2d(s, t)
  GLdouble s;
  GLdouble t;
CODE:
  OGLM_GLEWINIT
  OGLM_CHECK_ERR(glTexCoord2d, )
  glTexCoord2d(s, t);
  OGLM_CHECK_ERR(glTexCoord2d, )

void
glTexCoord2dv_c(v)
  const GLdouble *v;
CODE:
  OGLM_GLEWINIT
  OGLM_CHECK_ERR(glTexCoord2dv, )
  glTexCoord2dv(v);
  OGLM_CHECK_ERR(glTexCoord2dv, )

void
glTexCoord2dv_p(...)
CODE:
  OGLM_GLEWINIT
  OGLM_CHECK_ERR(glTexCoord2dv, )
  GLdouble *v = OGLM_GET_VARARGS(v,0,GLdouble,NV,2);
  glTexCoord2dv((const GLdouble *)v);
  OGLM_CHECK_ERR(glTexCoord2dv, free(v);)
  free(v);

void
glTexCoord2f(s, t)
  GLfloat s;
  GLfloat t;
CODE:
  OGLM_GLEWINIT
  OGLM_CHECK_ERR(glTexCoord2f, )
  glTexCoord2f(s, t);
  OGLM_CHECK_ERR(glTexCoord2f, )

void
glTexCoord2fColor3fVertex3fSUN(s, t, r, g, b, x, y, z)
  GLfloat s;
  GLfloat t;
  GLfloat r;
  GLfloat g;
  GLfloat b;
  GLfloat x;
  GLfloat y;
  GLfloat z;
CODE:
  OGLM_GLEWINIT
  OGLM_CHECK_ERR(glTexCoord2fColor3fVertex3fSUN, )
  OGLM_AVAIL_CHECK(__glewTexCoord2fColor3fVertex3fSUN, glTexCoord2fColor3fVertex3fSUN)
  glTexCoord2fColor3fVertex3fSUN(s, t, r, g, b, x, y, z);
  OGLM_CHECK_ERR(glTexCoord2fColor3fVertex3fSUN, )

void
glTexCoord2fColor3fVertex3fvSUN_c(tc, c, v)
  const GLfloat* tc;
  const GLfloat *c;
  const GLfloat *v;
CODE:
  OGLM_GLEWINIT
  OGLM_CHECK_ERR(glTexCoord2fColor3fVertex3fvSUN, )
  OGLM_AVAIL_CHECK(__glewTexCoord2fColor3fVertex3fvSUN, glTexCoord2fColor3fVertex3fvSUN)
  glTexCoord2fColor3fVertex3fvSUN(tc, c, v);
  OGLM_CHECK_ERR(glTexCoord2fColor3fVertex3fvSUN, )

void
glTexCoord2fColor3fVertex3fvSUN_p(tcSV, cSV, vSV)
  SV *tcSV;
  SV *cSV;
  SV *vSV;
CODE:
  OGLM_GLEWINIT
  OGLM_CHECK_ERR(glTexCoord2fColor3fVertex3fvSUN, )
  OGLM_AVAIL_CHECK(__glewTexCoord2fColor3fVertex3fvSUN, glTexCoord2fColor3fVertex3fvSUN)
  GLfloat *c = OGLM_GET_ARRAY(c, GLfloat, NV, 3);
  GLfloat* tc = OGLM_GET_ARRAY(tc, GLfloat, NV, 2);
  GLfloat *v = OGLM_GET_ARRAY(v, GLfloat, NV, 3);
  glTexCoord2fColor3fVertex3fvSUN((const GLfloat* )tc, (const GLfloat *)c, (const GLfloat *)v);
  OGLM_CHECK_ERR(glTexCoord2fColor3fVertex3fvSUN, free(c);free(tc);free(v);)
  free(c);free(tc);free(v);

void
glTexCoord2fColor4fNormal3fVertex3fSUN(s, t, r, g, b, a, nx, ny, nz, x, y, z)
  GLfloat s;
  GLfloat t;
  GLfloat r;
  GLfloat g;
  GLfloat b;
  GLfloat a;
  GLfloat nx;
  GLfloat ny;
  GLfloat nz;
  GLfloat x;
  GLfloat y;
  GLfloat z;
CODE:
  OGLM_GLEWINIT
  OGLM_CHECK_ERR(glTexCoord2fColor4fNormal3fVertex3fSUN, )
  OGLM_AVAIL_CHECK(__glewTexCoord2fColor4fNormal3fVertex3fSUN, glTexCoord2fColor4fNormal3fVertex3fSUN)
  glTexCoord2fColor4fNormal3fVertex3fSUN(s, t, r, g, b, a, nx, ny, nz, x, y, z);
  OGLM_CHECK_ERR(glTexCoord2fColor4fNormal3fVertex3fSUN, )

void
glTexCoord2fColor4fNormal3fVertex3fvSUN_c(tc, c, n, v)
  const GLfloat* tc;
  const GLfloat *c;
  const GLfloat *n;
  const GLfloat *v;
CODE:
  OGLM_GLEWINIT
  OGLM_CHECK_ERR(glTexCoord2fColor4fNormal3fVertex3fvSUN, )
  OGLM_AVAIL_CHECK(__glewTexCoord2fColor4fNormal3fVertex3fvSUN, glTexCoord2fColor4fNormal3fVertex3fvSUN)
  glTexCoord2fColor4fNormal3fVertex3fvSUN(tc, c, n, v);
  OGLM_CHECK_ERR(glTexCoord2fColor4fNormal3fVertex3fvSUN, )

void
glTexCoord2fColor4fNormal3fVertex3fvSUN_p(tcSV, cSV, nSV, vSV)
  SV *tcSV;
  SV *cSV;
  SV *nSV;
  SV *vSV;
CODE:
  OGLM_GLEWINIT
  OGLM_CHECK_ERR(glTexCoord2fColor4fNormal3fVertex3fvSUN, )
  OGLM_AVAIL_CHECK(__glewTexCoord2fColor4fNormal3fVertex3fvSUN, glTexCoord2fColor4fNormal3fVertex3fvSUN)
  GLfloat *c = OGLM_GET_ARRAY(c, GLfloat, NV, 4);
  GLfloat *n = OGLM_GET_ARRAY(n, GLfloat, NV, 3);
  GLfloat* tc = OGLM_GET_ARRAY(tc, GLfloat, NV, 2);
  GLfloat *v = OGLM_GET_ARRAY(v, GLfloat, NV, 3);
  glTexCoord2fColor4fNormal3fVertex3fvSUN((const GLfloat* )tc, (const GLfloat *)c, (const GLfloat *)n, (const GLfloat *)v);
  OGLM_CHECK_ERR(glTexCoord2fColor4fNormal3fVertex3fvSUN, free(c);free(n);free(tc);free(v);)
  free(c);free(n);free(tc);free(v);

void
glTexCoord2fColor4ubVertex3fSUN(s, t, r, g, b, a, x, y, z)
  GLfloat s;
  GLfloat t;
  GLubyte r;
  GLubyte g;
  GLubyte b;
  GLubyte a;
  GLfloat x;
  GLfloat y;
  GLfloat z;
CODE:
  OGLM_GLEWINIT
  OGLM_CHECK_ERR(glTexCoord2fColor4ubVertex3fSUN, )
  OGLM_AVAIL_CHECK(__glewTexCoord2fColor4ubVertex3fSUN, glTexCoord2fColor4ubVertex3fSUN)
  glTexCoord2fColor4ubVertex3fSUN(s, t, r, g, b, a, x, y, z);
  OGLM_CHECK_ERR(glTexCoord2fColor4ubVertex3fSUN, )

void
glTexCoord2fColor4ubVertex3fvSUN_c(tc, c, v)
  const GLfloat* tc;
  const GLubyte *c;
  const GLfloat *v;
CODE:
  OGLM_GLEWINIT
  OGLM_CHECK_ERR(glTexCoord2fColor4ubVertex3fvSUN, )
  OGLM_AVAIL_CHECK(__glewTexCoord2fColor4ubVertex3fvSUN, glTexCoord2fColor4ubVertex3fvSUN)
  glTexCoord2fColor4ubVertex3fvSUN(tc, c, v);
  OGLM_CHECK_ERR(glTexCoord2fColor4ubVertex3fvSUN, )

void
glTexCoord2fColor4ubVertex3fvSUN_p(tcSV, cSV, vSV)
  SV *tcSV;
  SV *cSV;
  SV *vSV;
CODE:
  OGLM_GLEWINIT
  OGLM_CHECK_ERR(glTexCoord2fColor4ubVertex3fvSUN, )
  OGLM_AVAIL_CHECK(__glewTexCoord2fColor4ubVertex3fvSUN, glTexCoord2fColor4ubVertex3fvSUN)
  GLubyte *c = OGLM_GET_ARRAY(c, GLubyte, UV, 4);
  GLfloat* tc = OGLM_GET_ARRAY(tc, GLfloat, NV, 2);
  GLfloat *v = OGLM_GET_ARRAY(v, GLfloat, NV, 3);
  glTexCoord2fColor4ubVertex3fvSUN((const GLfloat* )tc, (const GLubyte *)c, (const GLfloat *)v);
  OGLM_CHECK_ERR(glTexCoord2fColor4ubVertex3fvSUN, free(c);free(tc);free(v);)
  free(c);free(tc);free(v);

void
glTexCoord2fNormal3fVertex3fSUN(s, t, nx, ny, nz, x, y, z)
  GLfloat s;
  GLfloat t;
  GLfloat nx;
  GLfloat ny;
  GLfloat nz;
  GLfloat x;
  GLfloat y;
  GLfloat z;
CODE:
  OGLM_GLEWINIT
  OGLM_CHECK_ERR(glTexCoord2fNormal3fVertex3fSUN, )
  OGLM_AVAIL_CHECK(__glewTexCoord2fNormal3fVertex3fSUN, glTexCoord2fNormal3fVertex3fSUN)
  glTexCoord2fNormal3fVertex3fSUN(s, t, nx, ny, nz, x, y, z);
  OGLM_CHECK_ERR(glTexCoord2fNormal3fVertex3fSUN, )

void
glTexCoord2fNormal3fVertex3fvSUN_c(tc, n, v)
  const GLfloat* tc;
  const GLfloat *n;
  const GLfloat *v;
CODE:
  OGLM_GLEWINIT
  OGLM_CHECK_ERR(glTexCoord2fNormal3fVertex3fvSUN, )
  OGLM_AVAIL_CHECK(__glewTexCoord2fNormal3fVertex3fvSUN, glTexCoord2fNormal3fVertex3fvSUN)
  glTexCoord2fNormal3fVertex3fvSUN(tc, n, v);
  OGLM_CHECK_ERR(glTexCoord2fNormal3fVertex3fvSUN, )

void
glTexCoord2fNormal3fVertex3fvSUN_p(tcSV, nSV, vSV)
  SV *tcSV;
  SV *nSV;
  SV *vSV;
CODE:
  OGLM_GLEWINIT
  OGLM_CHECK_ERR(glTexCoord2fNormal3fVertex3fvSUN, )
  OGLM_AVAIL_CHECK(__glewTexCoord2fNormal3fVertex3fvSUN, glTexCoord2fNormal3fVertex3fvSUN)
  GLfloat *n = OGLM_GET_ARRAY(n, GLfloat, NV, 3);
  GLfloat* tc = OGLM_GET_ARRAY(tc, GLfloat, NV, 2);
  GLfloat *v = OGLM_GET_ARRAY(v, GLfloat, NV, 3);
  glTexCoord2fNormal3fVertex3fvSUN((const GLfloat* )tc, (const GLfloat *)n, (const GLfloat *)v);
  OGLM_CHECK_ERR(glTexCoord2fNormal3fVertex3fvSUN, free(n);free(tc);free(v);)
  free(n);free(tc);free(v);

void
glTexCoord2fVertex3fSUN(s, t, x, y, z)
  GLfloat s;
  GLfloat t;
  GLfloat x;
  GLfloat y;
  GLfloat z;
CODE:
  OGLM_GLEWINIT
  OGLM_CHECK_ERR(glTexCoord2fVertex3fSUN, )
  OGLM_AVAIL_CHECK(__glewTexCoord2fVertex3fSUN, glTexCoord2fVertex3fSUN)
  glTexCoord2fVertex3fSUN(s, t, x, y, z);
  OGLM_CHECK_ERR(glTexCoord2fVertex3fSUN, )

void
glTexCoord2fVertex3fvSUN_c(tc, v)
  const GLfloat* tc;
  const GLfloat *v;
CODE:
  OGLM_GLEWINIT
  OGLM_CHECK_ERR(glTexCoord2fVertex3fvSUN, )
  OGLM_AVAIL_CHECK(__glewTexCoord2fVertex3fvSUN, glTexCoord2fVertex3fvSUN)
  glTexCoord2fVertex3fvSUN(tc, v);
  OGLM_CHECK_ERR(glTexCoord2fVertex3fvSUN, )

void
glTexCoord2fVertex3fvSUN_p(tcSV, vSV)
  SV *tcSV;
  SV *vSV;
CODE:
  OGLM_GLEWINIT
  OGLM_CHECK_ERR(glTexCoord2fVertex3fvSUN, )
  OGLM_AVAIL_CHECK(__glewTexCoord2fVertex3fvSUN, glTexCoord2fVertex3fvSUN)
  GLfloat* tc = OGLM_GET_ARRAY(tc, GLfloat, NV, 2);
  GLfloat *v = OGLM_GET_ARRAY(v, GLfloat, NV, 3);
  glTexCoord2fVertex3fvSUN((const GLfloat* )tc, (const GLfloat *)v);
  OGLM_CHECK_ERR(glTexCoord2fVertex3fvSUN, free(tc);free(v);)
  free(tc);free(v);

void
glTexCoord2fv_c(v)
  const GLfloat *v;
CODE:
  OGLM_GLEWINIT
  OGLM_CHECK_ERR(glTexCoord2fv, )
  glTexCoord2fv(v);
  OGLM_CHECK_ERR(glTexCoord2fv, )

void
glTexCoord2fv_p(...)
CODE:
  OGLM_GLEWINIT
  OGLM_CHECK_ERR(glTexCoord2fv, )
  GLfloat *v = OGLM_GET_VARARGS(v,0,GLfloat,NV,2);
  glTexCoord2fv((const GLfloat *)v);
  OGLM_CHECK_ERR(glTexCoord2fv, free(v);)
  free(v);

void
glTexCoord2hNV(s, t)
  GLhalf s;
  GLhalf t;
CODE:
  OGLM_GLEWINIT
  OGLM_CHECK_ERR(glTexCoord2hNV, )
  OGLM_AVAIL_CHECK(__glewTexCoord2hNV, glTexCoord2hNV)
  glTexCoord2hNV(s, t);
  OGLM_CHECK_ERR(glTexCoord2hNV, )

void
glTexCoord2hvNV_c(v)
  const GLhalf* v;
CODE:
  OGLM_GLEWINIT
  OGLM_CHECK_ERR(glTexCoord2hvNV, )
  OGLM_AVAIL_CHECK(__glewTexCoord2hvNV, glTexCoord2hvNV)
  glTexCoord2hvNV(v);
  OGLM_CHECK_ERR(glTexCoord2hvNV, )

void
glTexCoord2hvNV_p(...)
CODE:
  OGLM_GLEWINIT
  OGLM_CHECK_ERR(glTexCoord2hvNV, )
  OGLM_AVAIL_CHECK(__glewTexCoord2hvNV, glTexCoord2hvNV)
  GLhalf* v = OGLM_GET_VARARGS(v,0,GLhalf,NV,2);
  glTexCoord2hvNV((const GLhalf* )v);
  OGLM_CHECK_ERR(glTexCoord2hvNV, free(v);)
  free(v);

void
glTexCoord2i(s, t)
  GLint s;
  GLint t;
CODE:
  OGLM_GLEWINIT
  OGLM_CHECK_ERR(glTexCoord2i, )
  glTexCoord2i(s, t);
  OGLM_CHECK_ERR(glTexCoord2i, )

void
glTexCoord2iv_c(v)
  const GLint *v;
CODE:
  OGLM_GLEWINIT
  OGLM_CHECK_ERR(glTexCoord2iv, )
  glTexCoord2iv(v);
  OGLM_CHECK_ERR(glTexCoord2iv, )

void
glTexCoord2iv_p(...)
CODE:
  OGLM_GLEWINIT
  OGLM_CHECK_ERR(glTexCoord2iv, )
  GLint *v = OGLM_GET_VARARGS(v,0,GLint,IV,2);
  glTexCoord2iv((const GLint *)v);
  OGLM_CHECK_ERR(glTexCoord2iv, free(v);)
  free(v);

void
glTexCoord2s(s, t)
  GLshort s;
  GLshort t;
CODE:
  OGLM_GLEWINIT
  OGLM_CHECK_ERR(glTexCoord2s, )
  glTexCoord2s(s, t);
  OGLM_CHECK_ERR(glTexCoord2s, )

void
glTexCoord2sv_c(v)
  const GLshort *v;
CODE:
  OGLM_GLEWINIT
  OGLM_CHECK_ERR(glTexCoord2sv, )
  glTexCoord2sv(v);
  OGLM_CHECK_ERR(glTexCoord2sv, )

void
glTexCoord2sv_p(...)
CODE:
  OGLM_GLEWINIT
  OGLM_CHECK_ERR(glTexCoord2sv, )
  GLshort *v = OGLM_GET_VARARGS(v,0,GLshort,IV,2);
  glTexCoord2sv((const GLshort *)v);
  OGLM_CHECK_ERR(glTexCoord2sv, free(v);)
  free(v);

void
glTexCoord3d(s, t, r)
  GLdouble s;
  GLdouble t;
  GLdouble r;
CODE:
  OGLM_GLEWINIT
  OGLM_CHECK_ERR(glTexCoord3d, )
  glTexCoord3d(s, t, r);
  OGLM_CHECK_ERR(glTexCoord3d, )

void
glTexCoord3dv_c(v)
  const GLdouble *v;
CODE:
  OGLM_GLEWINIT
  OGLM_CHECK_ERR(glTexCoord3dv, )
  glTexCoord3dv(v);
  OGLM_CHECK_ERR(glTexCoord3dv, )

void
glTexCoord3dv_p(...)
CODE:
  OGLM_GLEWINIT
  OGLM_CHECK_ERR(glTexCoord3dv, )
  GLdouble *v = OGLM_GET_VARARGS(v,0,GLdouble,NV,3);
  glTexCoord3dv((const GLdouble *)v);
  OGLM_CHECK_ERR(glTexCoord3dv, free(v);)
  free(v);

void
glTexCoord3f(s, t, r)
  GLfloat s;
  GLfloat t;
  GLfloat r;
CODE:
  OGLM_GLEWINIT
  OGLM_CHECK_ERR(glTexCoord3f, )
  glTexCoord3f(s, t, r);
  OGLM_CHECK_ERR(glTexCoord3f, )

void
glTexCoord3fv_c(v)
  const GLfloat *v;
CODE:
  OGLM_GLEWINIT
  OGLM_CHECK_ERR(glTexCoord3fv, )
  glTexCoord3fv(v);
  OGLM_CHECK_ERR(glTexCoord3fv, )

void
glTexCoord3fv_p(...)
CODE:
  OGLM_GLEWINIT
  OGLM_CHECK_ERR(glTexCoord3fv, )
  GLfloat *v = OGLM_GET_VARARGS(v,0,GLfloat,NV,3);
  glTexCoord3fv((const GLfloat *)v);
  OGLM_CHECK_ERR(glTexCoord3fv, free(v);)
  free(v);

void
glTexCoord3hNV(s, t, r)
  GLhalf s;
  GLhalf t;
  GLhalf r;
CODE:
  OGLM_GLEWINIT
  OGLM_CHECK_ERR(glTexCoord3hNV, )
  OGLM_AVAIL_CHECK(__glewTexCoord3hNV, glTexCoord3hNV)
  glTexCoord3hNV(s, t, r);
  OGLM_CHECK_ERR(glTexCoord3hNV, )

void
glTexCoord3hvNV_c(v)
  const GLhalf* v;
CODE:
  OGLM_GLEWINIT
  OGLM_CHECK_ERR(glTexCoord3hvNV, )
  OGLM_AVAIL_CHECK(__glewTexCoord3hvNV, glTexCoord3hvNV)
  glTexCoord3hvNV(v);
  OGLM_CHECK_ERR(glTexCoord3hvNV, )

void
glTexCoord3hvNV_p(...)
CODE:
  OGLM_GLEWINIT
  OGLM_CHECK_ERR(glTexCoord3hvNV, )
  OGLM_AVAIL_CHECK(__glewTexCoord3hvNV, glTexCoord3hvNV)
  GLhalf* v = OGLM_GET_VARARGS(v,0,GLhalf,NV,3);
  glTexCoord3hvNV((const GLhalf* )v);
  OGLM_CHECK_ERR(glTexCoord3hvNV, free(v);)
  free(v);

void
glTexCoord3i(s, t, r)
  GLint s;
  GLint t;
  GLint r;
CODE:
  OGLM_GLEWINIT
  OGLM_CHECK_ERR(glTexCoord3i, )
  glTexCoord3i(s, t, r);
  OGLM_CHECK_ERR(glTexCoord3i, )

void
glTexCoord3iv_c(v)
  const GLint *v;
CODE:
  OGLM_GLEWINIT
  OGLM_CHECK_ERR(glTexCoord3iv, )
  glTexCoord3iv(v);
  OGLM_CHECK_ERR(glTexCoord3iv, )

void
glTexCoord3iv_p(...)
CODE:
  OGLM_GLEWINIT
  OGLM_CHECK_ERR(glTexCoord3iv, )
  GLint *v = OGLM_GET_VARARGS(v,0,GLint,IV,3);
  glTexCoord3iv((const GLint *)v);
  OGLM_CHECK_ERR(glTexCoord3iv, free(v);)
  free(v);

void
glTexCoord3s(s, t, r)
  GLshort s;
  GLshort t;
  GLshort r;
CODE:
  OGLM_GLEWINIT
  OGLM_CHECK_ERR(glTexCoord3s, )
  glTexCoord3s(s, t, r);
  OGLM_CHECK_ERR(glTexCoord3s, )

void
glTexCoord3sv_c(v)
  const GLshort *v;
CODE:
  OGLM_GLEWINIT
  OGLM_CHECK_ERR(glTexCoord3sv, )
  glTexCoord3sv(v);
  OGLM_CHECK_ERR(glTexCoord3sv, )

void
glTexCoord3sv_p(...)
CODE:
  OGLM_GLEWINIT
  OGLM_CHECK_ERR(glTexCoord3sv, )
  GLshort *v = OGLM_GET_VARARGS(v,0,GLshort,IV,3);
  glTexCoord3sv((const GLshort *)v);
  OGLM_CHECK_ERR(glTexCoord3sv, free(v);)
  free(v);

void
glTexCoord4d(s, t, r, q)
  GLdouble s;
  GLdouble t;
  GLdouble r;
  GLdouble q;
CODE:
  OGLM_GLEWINIT
  OGLM_CHECK_ERR(glTexCoord4d, )
  glTexCoord4d(s, t, r, q);
  OGLM_CHECK_ERR(glTexCoord4d, )

void
glTexCoord4dv_c(v)
  const GLdouble *v;
CODE:
  OGLM_GLEWINIT
  OGLM_CHECK_ERR(glTexCoord4dv, )
  glTexCoord4dv(v);
  OGLM_CHECK_ERR(glTexCoord4dv, )

void
glTexCoord4dv_p(...)
CODE:
  OGLM_GLEWINIT
  OGLM_CHECK_ERR(glTexCoord4dv, )
  GLdouble *v = OGLM_GET_VARARGS(v,0,GLdouble,NV,4);
  glTexCoord4dv((const GLdouble *)v);
  OGLM_CHECK_ERR(glTexCoord4dv, free(v);)
  free(v);

void
glTexCoord4f(s, t, r, q)
  GLfloat s;
  GLfloat t;
  GLfloat r;
  GLfloat q;
CODE:
  OGLM_GLEWINIT
  OGLM_CHECK_ERR(glTexCoord4f, )
  glTexCoord4f(s, t, r, q);
  OGLM_CHECK_ERR(glTexCoord4f, )

void
glTexCoord4fColor4fNormal3fVertex4fSUN(s, t, p, q, r, g, b, a, nx, ny, nz, x, y, z, w)
  GLfloat s;
  GLfloat t;
  GLfloat p;
  GLfloat q;
  GLfloat r;
  GLfloat g;
  GLfloat b;
  GLfloat a;
  GLfloat nx;
  GLfloat ny;
  GLfloat nz;
  GLfloat x;
  GLfloat y;
  GLfloat z;
  GLfloat w;
CODE:
  OGLM_GLEWINIT
  OGLM_CHECK_ERR(glTexCoord4fColor4fNormal3fVertex4fSUN, )
  OGLM_AVAIL_CHECK(__glewTexCoord4fColor4fNormal3fVertex4fSUN, glTexCoord4fColor4fNormal3fVertex4fSUN)
  glTexCoord4fColor4fNormal3fVertex4fSUN(s, t, p, q, r, g, b, a, nx, ny, nz, x, y, z, w);
  OGLM_CHECK_ERR(glTexCoord4fColor4fNormal3fVertex4fSUN, )

void
glTexCoord4fColor4fNormal3fVertex4fvSUN_c(tc, c, n, v)
  const GLfloat* tc;
  const GLfloat *c;
  const GLfloat *n;
  const GLfloat *v;
CODE:
  OGLM_GLEWINIT
  OGLM_CHECK_ERR(glTexCoord4fColor4fNormal3fVertex4fvSUN, )
  OGLM_AVAIL_CHECK(__glewTexCoord4fColor4fNormal3fVertex4fvSUN, glTexCoord4fColor4fNormal3fVertex4fvSUN)
  glTexCoord4fColor4fNormal3fVertex4fvSUN(tc, c, n, v);
  OGLM_CHECK_ERR(glTexCoord4fColor4fNormal3fVertex4fvSUN, )

void
glTexCoord4fColor4fNormal3fVertex4fvSUN_p(tcSV, cSV, nSV, vSV)
  SV *tcSV;
  SV *cSV;
  SV *nSV;
  SV *vSV;
CODE:
  OGLM_GLEWINIT
  OGLM_CHECK_ERR(glTexCoord4fColor4fNormal3fVertex4fvSUN, )
  OGLM_AVAIL_CHECK(__glewTexCoord4fColor4fNormal3fVertex4fvSUN, glTexCoord4fColor4fNormal3fVertex4fvSUN)
  GLfloat *c = OGLM_GET_ARRAY(c, GLfloat, NV, 4);
  GLfloat *n = OGLM_GET_ARRAY(n, GLfloat, NV, 3);
  GLfloat* tc = OGLM_GET_ARRAY(tc, GLfloat, NV, 4);
  GLfloat *v = OGLM_GET_ARRAY(v, GLfloat, NV, 4);
  glTexCoord4fColor4fNormal3fVertex4fvSUN((const GLfloat* )tc, (const GLfloat *)c, (const GLfloat *)n, (const GLfloat *)v);
  OGLM_CHECK_ERR(glTexCoord4fColor4fNormal3fVertex4fvSUN, free(c);free(n);free(tc);free(v);)
  free(c);free(n);free(tc);free(v);

void
glTexCoord4fVertex4fSUN(s, t, p, q, x, y, z, w)
  GLfloat s;
  GLfloat t;
  GLfloat p;
  GLfloat q;
  GLfloat x;
  GLfloat y;
  GLfloat z;
  GLfloat w;
CODE:
  OGLM_GLEWINIT
  OGLM_CHECK_ERR(glTexCoord4fVertex4fSUN, )
  OGLM_AVAIL_CHECK(__glewTexCoord4fVertex4fSUN, glTexCoord4fVertex4fSUN)
  glTexCoord4fVertex4fSUN(s, t, p, q, x, y, z, w);
  OGLM_CHECK_ERR(glTexCoord4fVertex4fSUN, )

void
glTexCoord4fVertex4fvSUN_c(tc, v)
  const GLfloat* tc;
  const GLfloat *v;
CODE:
  OGLM_GLEWINIT
  OGLM_CHECK_ERR(glTexCoord4fVertex4fvSUN, )
  OGLM_AVAIL_CHECK(__glewTexCoord4fVertex4fvSUN, glTexCoord4fVertex4fvSUN)
  glTexCoord4fVertex4fvSUN(tc, v);
  OGLM_CHECK_ERR(glTexCoord4fVertex4fvSUN, )

void
glTexCoord4fVertex4fvSUN_p(tcSV, vSV)
  SV *tcSV;
  SV *vSV;
CODE:
  OGLM_GLEWINIT
  OGLM_CHECK_ERR(glTexCoord4fVertex4fvSUN, )
  OGLM_AVAIL_CHECK(__glewTexCoord4fVertex4fvSUN, glTexCoord4fVertex4fvSUN)
  GLfloat* tc = OGLM_GET_ARRAY(tc, GLfloat, NV, 4);
  GLfloat *v = OGLM_GET_ARRAY(v, GLfloat, NV, 4);
  glTexCoord4fVertex4fvSUN((const GLfloat* )tc, (const GLfloat *)v);
  OGLM_CHECK_ERR(glTexCoord4fVertex4fvSUN, free(tc);free(v);)
  free(tc);free(v);

void
glTexCoord4fv_c(v)
  const GLfloat *v;
CODE:
  OGLM_GLEWINIT
  OGLM_CHECK_ERR(glTexCoord4fv, )
  glTexCoord4fv(v);
  OGLM_CHECK_ERR(glTexCoord4fv, )

void
glTexCoord4fv_p(...)
CODE:
  OGLM_GLEWINIT
  OGLM_CHECK_ERR(glTexCoord4fv, )
  GLfloat *v = OGLM_GET_VARARGS(v,0,GLfloat,NV,4);
  glTexCoord4fv((const GLfloat *)v);
  OGLM_CHECK_ERR(glTexCoord4fv, free(v);)
  free(v);

void
glTexCoord4hNV(s, t, r, q)
  GLhalf s;
  GLhalf t;
  GLhalf r;
  GLhalf q;
CODE:
  OGLM_GLEWINIT
  OGLM_CHECK_ERR(glTexCoord4hNV, )
  OGLM_AVAIL_CHECK(__glewTexCoord4hNV, glTexCoord4hNV)
  glTexCoord4hNV(s, t, r, q);
  OGLM_CHECK_ERR(glTexCoord4hNV, )

void
glTexCoord4hvNV_c(v)
  const GLhalf* v;
CODE:
  OGLM_GLEWINIT
  OGLM_CHECK_ERR(glTexCoord4hvNV, )
  OGLM_AVAIL_CHECK(__glewTexCoord4hvNV, glTexCoord4hvNV)
  glTexCoord4hvNV(v);
  OGLM_CHECK_ERR(glTexCoord4hvNV, )

void
glTexCoord4hvNV_p(...)
CODE:
  OGLM_GLEWINIT
  OGLM_CHECK_ERR(glTexCoord4hvNV, )
  OGLM_AVAIL_CHECK(__glewTexCoord4hvNV, glTexCoord4hvNV)
  GLhalf* v = OGLM_GET_VARARGS(v,0,GLhalf,NV,4);
  glTexCoord4hvNV((const GLhalf* )v);
  OGLM_CHECK_ERR(glTexCoord4hvNV, free(v);)
  free(v);

void
glTexCoord4i(s, t, r, q)
  GLint s;
  GLint t;
  GLint r;
  GLint q;
CODE:
  OGLM_GLEWINIT
  OGLM_CHECK_ERR(glTexCoord4i, )
  glTexCoord4i(s, t, r, q);
  OGLM_CHECK_ERR(glTexCoord4i, )

void
glTexCoord4iv_c(v)
  const GLint *v;
CODE:
  OGLM_GLEWINIT
  OGLM_CHECK_ERR(glTexCoord4iv, )
  glTexCoord4iv(v);
  OGLM_CHECK_ERR(glTexCoord4iv, )

void
glTexCoord4iv_p(...)
CODE:
  OGLM_GLEWINIT
  OGLM_CHECK_ERR(glTexCoord4iv, )
  GLint *v = OGLM_GET_VARARGS(v,0,GLint,IV,4);
  glTexCoord4iv((const GLint *)v);
  OGLM_CHECK_ERR(glTexCoord4iv, free(v);)
  free(v);

void
glTexCoord4s(s, t, r, q)
  GLshort s;
  GLshort t;
  GLshort r;
  GLshort q;
CODE:
  OGLM_GLEWINIT
  OGLM_CHECK_ERR(glTexCoord4s, )
  glTexCoord4s(s, t, r, q);
  OGLM_CHECK_ERR(glTexCoord4s, )

void
glTexCoord4sv_c(v)
  const GLshort *v;
CODE:
  OGLM_GLEWINIT
  OGLM_CHECK_ERR(glTexCoord4sv, )
  glTexCoord4sv(v);
  OGLM_CHECK_ERR(glTexCoord4sv, )

void
glTexCoord4sv_p(...)
CODE:
  OGLM_GLEWINIT
  OGLM_CHECK_ERR(glTexCoord4sv, )
  GLshort *v = OGLM_GET_VARARGS(v,0,GLshort,IV,4);
  glTexCoord4sv((const GLshort *)v);
  OGLM_CHECK_ERR(glTexCoord4sv, free(v);)
  free(v);

void
glTexCoordFormatNV(size, type, stride)
  GLint size;
  GLenum type;
  GLsizei stride;
CODE:
  OGLM_GLEWINIT
  OGLM_CHECK_ERR(glTexCoordFormatNV, )
  OGLM_AVAIL_CHECK(__glewTexCoordFormatNV, glTexCoordFormatNV)
  glTexCoordFormatNV(size, type, stride);
  OGLM_CHECK_ERR(glTexCoordFormatNV, )

void
glTexCoordP1ui(type, coords)
  GLenum type;
  GLuint coords;
CODE:
  OGLM_GLEWINIT
  OGLM_CHECK_ERR(glTexCoordP1ui, )
  OGLM_AVAIL_CHECK(__glewTexCoordP1ui, glTexCoordP1ui)
  glTexCoordP1ui(type, coords);
  OGLM_CHECK_ERR(glTexCoordP1ui, )

void
glTexCoordP1uiv_c(type, coords)
  GLenum type;
  const GLuint* coords;
CODE:
  OGLM_GLEWINIT
  OGLM_CHECK_ERR(glTexCoordP1uiv, )
  OGLM_AVAIL_CHECK(__glewTexCoordP1uiv, glTexCoordP1uiv)
  glTexCoordP1uiv(type, coords);
  OGLM_CHECK_ERR(glTexCoordP1uiv, )

void
glTexCoordP1uiv_p(type, ...)
  GLenum type;
CODE:
  OGLM_GLEWINIT
  OGLM_CHECK_ERR(glTexCoordP1uiv, )
  OGLM_AVAIL_CHECK(__glewTexCoordP1uiv, glTexCoordP1uiv)
  GLuint* coords = OGLM_GET_VARARGS(coords,1,GLuint,UV,1);
  glTexCoordP1uiv((GLenum )type, (const GLuint* )coords);
  OGLM_CHECK_ERR(glTexCoordP1uiv, free(coords);)
  free(coords);

void
glTexCoordP2ui(type, coords)
  GLenum type;
  GLuint coords;
CODE:
  OGLM_GLEWINIT
  OGLM_CHECK_ERR(glTexCoordP2ui, )
  OGLM_AVAIL_CHECK(__glewTexCoordP2ui, glTexCoordP2ui)
  glTexCoordP2ui(type, coords);
  OGLM_CHECK_ERR(glTexCoordP2ui, )

void
glTexCoordP2uiv_c(type, coords)
  GLenum type;
  const GLuint* coords;
CODE:
  OGLM_GLEWINIT
  OGLM_CHECK_ERR(glTexCoordP2uiv, )
  OGLM_AVAIL_CHECK(__glewTexCoordP2uiv, glTexCoordP2uiv)
  glTexCoordP2uiv(type, coords);
  OGLM_CHECK_ERR(glTexCoordP2uiv, )

void
glTexCoordP2uiv_p(type, ...)
  GLenum type;
CODE:
  OGLM_GLEWINIT
  OGLM_CHECK_ERR(glTexCoordP2uiv, )
  OGLM_AVAIL_CHECK(__glewTexCoordP2uiv, glTexCoordP2uiv)
  GLuint* coords = OGLM_GET_VARARGS(coords,1,GLuint,UV,1);
  glTexCoordP2uiv((GLenum )type, (const GLuint* )coords);
  OGLM_CHECK_ERR(glTexCoordP2uiv, free(coords);)
  free(coords);

void
glTexCoordP3ui(type, coords)
  GLenum type;
  GLuint coords;
CODE:
  OGLM_GLEWINIT
  OGLM_CHECK_ERR(glTexCoordP3ui, )
  OGLM_AVAIL_CHECK(__glewTexCoordP3ui, glTexCoordP3ui)
  glTexCoordP3ui(type, coords);
  OGLM_CHECK_ERR(glTexCoordP3ui, )

void
glTexCoordP3uiv_c(type, coords)
  GLenum type;
  const GLuint* coords;
CODE:
  OGLM_GLEWINIT
  OGLM_CHECK_ERR(glTexCoordP3uiv, )
  OGLM_AVAIL_CHECK(__glewTexCoordP3uiv, glTexCoordP3uiv)
  glTexCoordP3uiv(type, coords);
  OGLM_CHECK_ERR(glTexCoordP3uiv, )

void
glTexCoordP3uiv_p(type, ...)
  GLenum type;
CODE:
  OGLM_GLEWINIT
  OGLM_CHECK_ERR(glTexCoordP3uiv, )
  OGLM_AVAIL_CHECK(__glewTexCoordP3uiv, glTexCoordP3uiv)
  GLuint* coords = OGLM_GET_VARARGS(coords,1,GLuint,UV,1);
  glTexCoordP3uiv((GLenum )type, (const GLuint* )coords);
  OGLM_CHECK_ERR(glTexCoordP3uiv, free(coords);)
  free(coords);

void
glTexCoordP4ui(type, coords)
  GLenum type;
  GLuint coords;
CODE:
  OGLM_GLEWINIT
  OGLM_CHECK_ERR(glTexCoordP4ui, )
  OGLM_AVAIL_CHECK(__glewTexCoordP4ui, glTexCoordP4ui)
  glTexCoordP4ui(type, coords);
  OGLM_CHECK_ERR(glTexCoordP4ui, )

void
glTexCoordP4uiv_c(type, coords)
  GLenum type;
  const GLuint* coords;
CODE:
  OGLM_GLEWINIT
  OGLM_CHECK_ERR(glTexCoordP4uiv, )
  OGLM_AVAIL_CHECK(__glewTexCoordP4uiv, glTexCoordP4uiv)
  glTexCoordP4uiv(type, coords);
  OGLM_CHECK_ERR(glTexCoordP4uiv, )

void
glTexCoordP4uiv_p(type, ...)
  GLenum type;
CODE:
  OGLM_GLEWINIT
  OGLM_CHECK_ERR(glTexCoordP4uiv, )
  OGLM_AVAIL_CHECK(__glewTexCoordP4uiv, glTexCoordP4uiv)
  GLuint* coords = OGLM_GET_VARARGS(coords,1,GLuint,UV,1);
  glTexCoordP4uiv((GLenum )type, (const GLuint* )coords);
  OGLM_CHECK_ERR(glTexCoordP4uiv, free(coords);)
  free(coords);

void
glTexCoordPointer_c(size, type, stride, pointer)
  GLint size;
  GLenum type;
  GLsizei stride;
  const void *pointer;
CODE:
  OGLM_GLEWINIT
  OGLM_CHECK_ERR(glTexCoordPointer, )
  glTexCoordPointer(size, type, stride, pointer);
  OGLM_CHECK_ERR(glTexCoordPointer, )

void
glTexCoordPointerEXT_c(size, type, stride, count, pointer)
  GLint size;
  GLenum type;
  GLsizei stride;
  GLsizei count;
  const void *pointer;
CODE:
  OGLM_GLEWINIT
  OGLM_CHECK_ERR(glTexCoordPointerEXT, )
  OGLM_AVAIL_CHECK(__glewTexCoordPointerEXT, glTexCoordPointerEXT)
  glTexCoordPointerEXT(size, type, stride, count, pointer);
  OGLM_CHECK_ERR(glTexCoordPointerEXT, )

void
glTexCoordPointerListIBM_c(size, type, stride, pointer, ptrstride)
  GLint size;
  GLenum type;
  GLint stride;
  const void** pointer;
  GLint ptrstride;
CODE:
  OGLM_GLEWINIT
  OGLM_CHECK_ERR(glTexCoordPointerListIBM, )
  OGLM_AVAIL_CHECK(__glewTexCoordPointerListIBM, glTexCoordPointerListIBM)
  glTexCoordPointerListIBM(size, type, stride, pointer, ptrstride);
  OGLM_CHECK_ERR(glTexCoordPointerListIBM, )

void
glTexCoordPointervINTEL_c(size, type, pointer)
  GLint size;
  GLenum type;
  const void** pointer;
CODE:
  OGLM_GLEWINIT
  OGLM_CHECK_ERR(glTexCoordPointervINTEL, )
  OGLM_AVAIL_CHECK(__glewTexCoordPointervINTEL, glTexCoordPointervINTEL)
  glTexCoordPointervINTEL(size, type, pointer);
  OGLM_CHECK_ERR(glTexCoordPointervINTEL, )

void
glTexEnvf(target, pname, param)
  GLenum target;
  GLenum pname;
  GLfloat param;
CODE:
  OGLM_GLEWINIT
  OGLM_CHECK_ERR(glTexEnvf, )
  glTexEnvf(target, pname, param);
  OGLM_CHECK_ERR(glTexEnvf, )

void
glTexEnvfv_c(target, pname, params)
  GLenum target;
  GLenum pname;
  const GLfloat *params;
CODE:
  OGLM_GLEWINIT
  OGLM_CHECK_ERR(glTexEnvfv, )
  glTexEnvfv(target, pname, params);
  OGLM_CHECK_ERR(glTexEnvfv, )

void
glTexEnvfv_p(target, pname, ...)
  GLenum target;
  GLenum pname;
CODE:
  OGLM_GLEWINIT
  OGLM_CHECK_ERR(glTexEnvfv, )
  OGLM_SIZE_ENUM(TextureEnvParameter,pname,1)
  GLfloat *params = OGLM_GET_VARARGS(params,2,GLfloat,NV,pname_count);
  glTexEnvfv((GLenum )target, (GLenum )pname, (const GLfloat *)params);
  OGLM_CHECK_ERR(glTexEnvfv, free(params);)
  free(params);

void
glTexEnvi(target, pname, param)
  GLenum target;
  GLenum pname;
  GLint param;
CODE:
  OGLM_GLEWINIT
  OGLM_CHECK_ERR(glTexEnvi, )
  glTexEnvi(target, pname, param);
  OGLM_CHECK_ERR(glTexEnvi, )

void
glTexEnviv_c(target, pname, params)
  GLenum target;
  GLenum pname;
  const GLint *params;
CODE:
  OGLM_GLEWINIT
  OGLM_CHECK_ERR(glTexEnviv, )
  glTexEnviv(target, pname, params);
  OGLM_CHECK_ERR(glTexEnviv, )

void
glTexEnviv_p(target, pname, ...)
  GLenum target;
  GLenum pname;
CODE:
  OGLM_GLEWINIT
  OGLM_CHECK_ERR(glTexEnviv, )
  OGLM_SIZE_ENUM(TextureEnvParameter,pname,1)
  GLint *params = OGLM_GET_VARARGS(params,2,GLint,IV,pname_count);
  glTexEnviv((GLenum )target, (GLenum )pname, (const GLint *)params);
  OGLM_CHECK_ERR(glTexEnviv, free(params);)
  free(params);

void
glTexEnvx(target, pname, param)
  GLenum target;
  GLenum pname;
  GLfixed param;
CODE:
  OGLM_GLEWINIT
  OGLM_CHECK_ERR(glTexEnvx, )
  OGLM_AVAIL_CHECK(__glewTexEnvx, glTexEnvx)
  glTexEnvx(target, pname, param);
  OGLM_CHECK_ERR(glTexEnvx, )

void
glTexEnvxv_c(target, pname, params)
  GLenum target;
  GLenum pname;
  const GLfixed* params;
CODE:
  OGLM_GLEWINIT
  OGLM_CHECK_ERR(glTexEnvxv, )
  OGLM_AVAIL_CHECK(__glewTexEnvxv, glTexEnvxv)
  glTexEnvxv(target, pname, params);
  OGLM_CHECK_ERR(glTexEnvxv, )

void
glTexEnvxv_p(target, pname, ...)
  GLenum target;
  GLenum pname;
CODE:
  OGLM_GLEWINIT
  OGLM_CHECK_ERR(glTexEnvxv, )
  OGLM_AVAIL_CHECK(__glewTexEnvxv, glTexEnvxv)
  OGLM_SIZE_ENUM(TextureEnvParameter,pname,1)
  GLfixed* params = OGLM_GET_VARARGS(params,2,GLfixed,IV,pname_count);
  glTexEnvxv((GLenum )target, (GLenum )pname, (const GLfixed* )params);
  OGLM_CHECK_ERR(glTexEnvxv, free(params);)
  free(params);

void
glTexEstimateMotionQCOM(ref, target, output)
  GLuint ref;
  GLuint target;
  GLuint output;
CODE:
  OGLM_GLEWINIT
  OGLM_CHECK_ERR(glTexEstimateMotionQCOM, )
  OGLM_AVAIL_CHECK(__glewTexEstimateMotionQCOM, glTexEstimateMotionQCOM)
  glTexEstimateMotionQCOM(ref, target, output);
  OGLM_CHECK_ERR(glTexEstimateMotionQCOM, )

void
glTexEstimateMotionRegionsQCOM(ref, target, output, mask)
  GLuint ref;
  GLuint target;
  GLuint output;
  GLuint mask;
CODE:
  OGLM_GLEWINIT
  OGLM_CHECK_ERR(glTexEstimateMotionRegionsQCOM, )
  OGLM_AVAIL_CHECK(__glewTexEstimateMotionRegionsQCOM, glTexEstimateMotionRegionsQCOM)
  glTexEstimateMotionRegionsQCOM(ref, target, output, mask);
  OGLM_CHECK_ERR(glTexEstimateMotionRegionsQCOM, )

void
glTexFilterFuncSGIS_c(target, filter, n, weights)
  GLenum target;
  GLenum filter;
  GLsizei n;
  const GLfloat* weights;
CODE:
  OGLM_GLEWINIT
  OGLM_CHECK_ERR(glTexFilterFuncSGIS, )
  OGLM_AVAIL_CHECK(__glewTexFilterFuncSGIS, glTexFilterFuncSGIS)
  glTexFilterFuncSGIS(target, filter, n, weights);
  OGLM_CHECK_ERR(glTexFilterFuncSGIS, )

void
glTexFilterFuncSGIS_p(target, filter, ...)
  GLenum target;
  GLenum filter;
CODE:
  OGLM_GLEWINIT
  OGLM_CHECK_ERR(glTexFilterFuncSGIS, )
  OGLM_AVAIL_CHECK(__glewTexFilterFuncSGIS, glTexFilterFuncSGIS)
  GLsizei n = items-2;
  GLfloat* weights = OGLM_GET_VARARGS(weights,2,GLfloat,NV,n);
  glTexFilterFuncSGIS((GLenum )target, (GLenum )filter, (GLsizei )n, (const GLfloat* )weights);
  OGLM_CHECK_ERR(glTexFilterFuncSGIS, free(weights);)
  free(weights);

void
glTexGend(coord, pname, param)
  GLenum coord;
  GLenum pname;
  GLdouble param;
CODE:
  OGLM_GLEWINIT
  OGLM_CHECK_ERR(glTexGend, )
  glTexGend(coord, pname, param);
  OGLM_CHECK_ERR(glTexGend, )

void
glTexGendv_c(coord, pname, params)
  GLenum coord;
  GLenum pname;
  const GLdouble *params;
CODE:
  OGLM_GLEWINIT
  OGLM_CHECK_ERR(glTexGendv, )
  glTexGendv(coord, pname, params);
  OGLM_CHECK_ERR(glTexGendv, )

void
glTexGendv_p(coord, pname, ...)
  GLenum coord;
  GLenum pname;
CODE:
  OGLM_GLEWINIT
  OGLM_CHECK_ERR(glTexGendv, )
  OGLM_SIZE_ENUM(TextureGenParameter,pname,1)
  GLdouble *params = OGLM_GET_VARARGS(params,2,GLdouble,NV,pname_count);
  glTexGendv((GLenum )coord, (GLenum )pname, (const GLdouble *)params);
  OGLM_CHECK_ERR(glTexGendv, free(params);)
  free(params);

void
glTexGenf(coord, pname, param)
  GLenum coord;
  GLenum pname;
  GLfloat param;
CODE:
  OGLM_GLEWINIT
  OGLM_CHECK_ERR(glTexGenf, )
  glTexGenf(coord, pname, param);
  OGLM_CHECK_ERR(glTexGenf, )

void
glTexGenfOES(coord, pname, param)
  GLenum coord;
  GLenum pname;
  GLfloat param;
CODE:
  OGLM_GLEWINIT
  OGLM_CHECK_ERR(glTexGenfOES, )
  OGLM_AVAIL_CHECK(__glewTexGenfOES, glTexGenfOES)
  glTexGenfOES(coord, pname, param);
  OGLM_CHECK_ERR(glTexGenfOES, )

void
glTexGenfv_c(coord, pname, params)
  GLenum coord;
  GLenum pname;
  const GLfloat *params;
CODE:
  OGLM_GLEWINIT
  OGLM_CHECK_ERR(glTexGenfv, )
  glTexGenfv(coord, pname, params);
  OGLM_CHECK_ERR(glTexGenfv, )

void
glTexGenfv_p(coord, pname, ...)
  GLenum coord;
  GLenum pname;
CODE:
  OGLM_GLEWINIT
  OGLM_CHECK_ERR(glTexGenfv, )
  OGLM_SIZE_ENUM(TextureGenParameter,pname,1)
  GLfloat *params = OGLM_GET_VARARGS(params,2,GLfloat,NV,pname_count);
  glTexGenfv((GLenum )coord, (GLenum )pname, (const GLfloat *)params);
  OGLM_CHECK_ERR(glTexGenfv, free(params);)
  free(params);

void
glTexGenfvOES_c(coord, pname, params)
  GLenum coord;
  GLenum pname;
  const GLfloat* params;
CODE:
  OGLM_GLEWINIT
  OGLM_CHECK_ERR(glTexGenfvOES, )
  OGLM_AVAIL_CHECK(__glewTexGenfvOES, glTexGenfvOES)
  glTexGenfvOES(coord, pname, params);
  OGLM_CHECK_ERR(glTexGenfvOES, )

void
glTexGeni(coord, pname, param)
  GLenum coord;
  GLenum pname;
  GLint param;
CODE:
  OGLM_GLEWINIT
  OGLM_CHECK_ERR(glTexGeni, )
  glTexGeni(coord, pname, param);
  OGLM_CHECK_ERR(glTexGeni, )

void
glTexGeniOES(coord, pname, param)
  GLenum coord;
  GLenum pname;
  GLint param;
CODE:
  OGLM_GLEWINIT
  OGLM_CHECK_ERR(glTexGeniOES, )
  OGLM_AVAIL_CHECK(__glewTexGeniOES, glTexGeniOES)
  glTexGeniOES(coord, pname, param);
  OGLM_CHECK_ERR(glTexGeniOES, )

void
glTexGeniv_c(coord, pname, params)
  GLenum coord;
  GLenum pname;
  const GLint *params;
CODE:
  OGLM_GLEWINIT
  OGLM_CHECK_ERR(glTexGeniv, )
  glTexGeniv(coord, pname, params);
  OGLM_CHECK_ERR(glTexGeniv, )

void
glTexGeniv_p(coord, pname, ...)
  GLenum coord;
  GLenum pname;
CODE:
  OGLM_GLEWINIT
  OGLM_CHECK_ERR(glTexGeniv, )
  OGLM_SIZE_ENUM(TextureGenParameter,pname,1)
  GLint *params = OGLM_GET_VARARGS(params,2,GLint,IV,pname_count);
  glTexGeniv((GLenum )coord, (GLenum )pname, (const GLint *)params);
  OGLM_CHECK_ERR(glTexGeniv, free(params);)
  free(params);

void
glTexGenivOES_c(coord, pname, params)
  GLenum coord;
  GLenum pname;
  const GLint* params;
CODE:
  OGLM_GLEWINIT
  OGLM_CHECK_ERR(glTexGenivOES, )
  OGLM_AVAIL_CHECK(__glewTexGenivOES, glTexGenivOES)
  glTexGenivOES(coord, pname, params);
  OGLM_CHECK_ERR(glTexGenivOES, )

void
glTexGenxOES(coord, pname, param)
  GLenum coord;
  GLenum pname;
  GLfixed param;
CODE:
  OGLM_GLEWINIT
  OGLM_CHECK_ERR(glTexGenxOES, )
  OGLM_AVAIL_CHECK(__glewTexGenxOES, glTexGenxOES)
  glTexGenxOES(coord, pname, param);
  OGLM_CHECK_ERR(glTexGenxOES, )

void
glTexGenxvOES_c(coord, pname, params)
  GLenum coord;
  GLenum pname;
  const GLfixed* params;
CODE:
  OGLM_GLEWINIT
  OGLM_CHECK_ERR(glTexGenxvOES, )
  OGLM_AVAIL_CHECK(__glewTexGenxvOES, glTexGenxvOES)
  glTexGenxvOES(coord, pname, params);
  OGLM_CHECK_ERR(glTexGenxvOES, )

void
glTexImage1D_c(target, level, internalformat, width, border, format, type, pixels)
  GLenum target;
  GLint level;
  GLint internalformat;
  GLsizei width;
  GLint border;
  GLenum format;
  GLenum type;
  const void *pixels;
CODE:
  OGLM_GLEWINIT
  OGLM_CHECK_ERR(glTexImage1D, )
  glTexImage1D(target, level, internalformat, width, border, format, type, pixels);
  OGLM_CHECK_ERR(glTexImage1D, )

void
glTexImage2D_c(target, level, internalformat, width, height, border, format, type, pixels)
  GLenum target;
  GLint level;
  GLint internalformat;
  GLsizei width;
  GLsizei height;
  GLint border;
  GLenum format;
  GLenum type;
  const void *pixels;
CODE:
  OGLM_GLEWINIT
  OGLM_CHECK_ERR(glTexImage2D, )
  glTexImage2D(target, level, internalformat, width, height, border, format, type, pixels);
  OGLM_CHECK_ERR(glTexImage2D, )

void
glTexImage2DMultisample(target, samples, internalformat, width, height, fixedsamplelocations)
  GLenum target;
  GLsizei samples;
  GLenum internalformat;
  GLsizei width;
  GLsizei height;
  GLboolean fixedsamplelocations;
CODE:
  OGLM_GLEWINIT
  OGLM_CHECK_ERR(glTexImage2DMultisample, )
  OGLM_AVAIL_CHECK(__glewTexImage2DMultisample, glTexImage2DMultisample)
  glTexImage2DMultisample(target, samples, internalformat, width, height, fixedsamplelocations);
  OGLM_CHECK_ERR(glTexImage2DMultisample, )

void
glTexImage2DMultisampleCoverageNV(target, coverageSamples, colorSamples, internalFormat, width, height, fixedSampleLocations)
  GLenum target;
  GLsizei coverageSamples;
  GLsizei colorSamples;
  GLint internalFormat;
  GLsizei width;
  GLsizei height;
  GLboolean fixedSampleLocations;
CODE:
  OGLM_GLEWINIT
  OGLM_CHECK_ERR(glTexImage2DMultisampleCoverageNV, )
  OGLM_AVAIL_CHECK(__glewTexImage2DMultisampleCoverageNV, glTexImage2DMultisampleCoverageNV)
  glTexImage2DMultisampleCoverageNV(target, coverageSamples, colorSamples, internalFormat, width, height, fixedSampleLocations);
  OGLM_CHECK_ERR(glTexImage2DMultisampleCoverageNV, )

void
glTexImage3D_c(target, level, internalformat, width, height, depth, border, format, type, pixels)
  GLenum target;
  GLint level;
  GLint internalformat;
  GLsizei width;
  GLsizei height;
  GLsizei depth;
  GLint border;
  GLenum format;
  GLenum type;
  const void *pixels;
ALIAS:
  glTexImage3DEXT_c = 1
CODE:
  OGLM_GLEWINIT
  OGLM_CHECK_ERR(glTexImage3D, )
  OGLM_AVAIL_CHECK(__glewTexImage3D, glTexImage3D)
  glTexImage3D(target, level, internalformat, width, height, depth, border, format, type, pixels);
  OGLM_CHECK_ERR(glTexImage3D, )

void
glTexImage3DMultisample(target, samples, internalformat, width, height, depth, fixedsamplelocations)
  GLenum target;
  GLsizei samples;
  GLenum internalformat;
  GLsizei width;
  GLsizei height;
  GLsizei depth;
  GLboolean fixedsamplelocations;
CODE:
  OGLM_GLEWINIT
  OGLM_CHECK_ERR(glTexImage3DMultisample, )
  OGLM_AVAIL_CHECK(__glewTexImage3DMultisample, glTexImage3DMultisample)
  glTexImage3DMultisample(target, samples, internalformat, width, height, depth, fixedsamplelocations);
  OGLM_CHECK_ERR(glTexImage3DMultisample, )

void
glTexImage3DMultisampleCoverageNV(target, coverageSamples, colorSamples, internalFormat, width, height, depth, fixedSampleLocations)
  GLenum target;
  GLsizei coverageSamples;
  GLsizei colorSamples;
  GLint internalFormat;
  GLsizei width;
  GLsizei height;
  GLsizei depth;
  GLboolean fixedSampleLocations;
CODE:
  OGLM_GLEWINIT
  OGLM_CHECK_ERR(glTexImage3DMultisampleCoverageNV, )
  OGLM_AVAIL_CHECK(__glewTexImage3DMultisampleCoverageNV, glTexImage3DMultisampleCoverageNV)
  glTexImage3DMultisampleCoverageNV(target, coverageSamples, colorSamples, internalFormat, width, height, depth, fixedSampleLocations);
  OGLM_CHECK_ERR(glTexImage3DMultisampleCoverageNV, )

void
glTexImage3DNV_c(target, level, internalFormat, width, height, depth, border, format, type, pixels)
  GLenum target;
  GLint level;
  GLenum internalFormat;
  GLsizei width;
  GLsizei height;
  GLsizei depth;
  GLint border;
  GLenum format;
  GLenum type;
  const void *pixels;
CODE:
  OGLM_GLEWINIT
  OGLM_CHECK_ERR(glTexImage3DNV, )
  OGLM_AVAIL_CHECK(__glewTexImage3DNV, glTexImage3DNV)
  glTexImage3DNV(target, level, internalFormat, width, height, depth, border, format, type, pixels);
  OGLM_CHECK_ERR(glTexImage3DNV, )

void
glTexImage3DOES_c(target, level, internalFormat, width, height, depth, border, format, type, pixels)
  GLenum target;
  GLint level;
  GLenum internalFormat;
  GLsizei width;
  GLsizei height;
  GLsizei depth;
  GLint border;
  GLenum format;
  GLenum type;
  const void *pixels;
CODE:
  OGLM_GLEWINIT
  OGLM_CHECK_ERR(glTexImage3DOES, )
  OGLM_AVAIL_CHECK(__glewTexImage3DOES, glTexImage3DOES)
  glTexImage3DOES(target, level, internalFormat, width, height, depth, border, format, type, pixels);
  OGLM_CHECK_ERR(glTexImage3DOES, )

void
glTexImage4DSGIS_c(target, level, internalformat, width, height, depth, size4d, border, format, type, pixels)
  GLenum target;
  GLint level;
  GLenum internalformat;
  GLsizei width;
  GLsizei height;
  GLsizei depth;
  GLsizei size4d;
  GLint border;
  GLenum format;
  GLenum type;
  const void *pixels;
CODE:
  OGLM_GLEWINIT
  OGLM_CHECK_ERR(glTexImage4DSGIS, )
  OGLM_AVAIL_CHECK(__glewTexImage4DSGIS, glTexImage4DSGIS)
  glTexImage4DSGIS(target, level, internalformat, width, height, depth, size4d, border, format, type, pixels);
  OGLM_CHECK_ERR(glTexImage4DSGIS, )

void
glTexPageCommitmentARB(target, level, xoffset, yoffset, zoffset, width, height, depth, commit)
  GLenum target;
  GLint level;
  GLint xoffset;
  GLint yoffset;
  GLint zoffset;
  GLsizei width;
  GLsizei height;
  GLsizei depth;
  GLboolean commit;
ALIAS:
  glTexPageCommitmentEXT = 1
CODE:
  OGLM_GLEWINIT
  OGLM_CHECK_ERR(glTexPageCommitmentARB, )
  OGLM_AVAIL_CHECK(__glewTexPageCommitmentARB, glTexPageCommitmentARB)
  glTexPageCommitmentARB(target, level, xoffset, yoffset, zoffset, width, height, depth, commit);
  OGLM_CHECK_ERR(glTexPageCommitmentARB, )

void
glTexPageCommitmentMemNV(target, layer, level, xoffset, yoffset, zoffset, width, height, depth, memory, offset, commit)
  GLenum target;
  GLint layer;
  GLint level;
  GLint xoffset;
  GLint yoffset;
  GLint zoffset;
  GLsizei width;
  GLsizei height;
  GLsizei depth;
  GLuint memory;
  GLuint64 offset;
  GLboolean commit;
CODE:
  OGLM_GLEWINIT
  OGLM_CHECK_ERR(glTexPageCommitmentMemNV, )
  OGLM_AVAIL_CHECK(__glewTexPageCommitmentMemNV, glTexPageCommitmentMemNV)
  glTexPageCommitmentMemNV(target, layer, level, xoffset, yoffset, zoffset, width, height, depth, memory, offset, commit);
  OGLM_CHECK_ERR(glTexPageCommitmentMemNV, )

void
glTexParameterIiv_c(target, pname, params)
  GLenum target;
  GLenum pname;
  const GLint* params;
ALIAS:
  glTexParameterIivEXT_c = 1
CODE:
  OGLM_GLEWINIT
  OGLM_CHECK_ERR(glTexParameterIiv, )
  OGLM_AVAIL_CHECK(__glewTexParameterIiv, glTexParameterIiv)
  glTexParameterIiv(target, pname, params);
  OGLM_CHECK_ERR(glTexParameterIiv, )

void
glTexParameterIiv_p(target, pname, ...)
  GLenum target;
  GLenum pname;
ALIAS:
  glTexParameterIivEXT_p = 1
CODE:
  OGLM_GLEWINIT
  OGLM_CHECK_ERR(glTexParameterIiv, )
  OGLM_AVAIL_CHECK(__glewTexParameterIiv, glTexParameterIiv)
  OGLM_SIZE_ENUM(TextureParameterName,pname,1)
  GLint* params = OGLM_GET_VARARGS(params,2,GLint,IV,pname_count);
  glTexParameterIiv((GLenum )target, (GLenum )pname, (const GLint* )params);
  OGLM_CHECK_ERR(glTexParameterIiv, free(params);)
  free(params);

void
glTexParameterIivOES_c(target, pname, params)
  GLenum target;
  GLenum pname;
  const GLint* params;
CODE:
  OGLM_GLEWINIT
  OGLM_CHECK_ERR(glTexParameterIivOES, )
  OGLM_AVAIL_CHECK(__glewTexParameterIivOES, glTexParameterIivOES)
  glTexParameterIivOES(target, pname, params);
  OGLM_CHECK_ERR(glTexParameterIivOES, )

void
glTexParameterIuiv_c(target, pname, params)
  GLenum target;
  GLenum pname;
  const GLuint* params;
ALIAS:
  glTexParameterIuivEXT_c = 1
CODE:
  OGLM_GLEWINIT
  OGLM_CHECK_ERR(glTexParameterIuiv, )
  OGLM_AVAIL_CHECK(__glewTexParameterIuiv, glTexParameterIuiv)
  glTexParameterIuiv(target, pname, params);
  OGLM_CHECK_ERR(glTexParameterIuiv, )

void
glTexParameterIuiv_p(target, pname, ...)
  GLenum target;
  GLenum pname;
ALIAS:
  glTexParameterIuivEXT_p = 1
CODE:
  OGLM_GLEWINIT
  OGLM_CHECK_ERR(glTexParameterIuiv, )
  OGLM_AVAIL_CHECK(__glewTexParameterIuiv, glTexParameterIuiv)
  OGLM_SIZE_ENUM(TextureParameterName,pname,1)
  GLuint* params = OGLM_GET_VARARGS(params,2,GLuint,UV,pname_count);
  glTexParameterIuiv((GLenum )target, (GLenum )pname, (const GLuint* )params);
  OGLM_CHECK_ERR(glTexParameterIuiv, free(params);)
  free(params);

void
glTexParameterIuivOES_c(target, pname, params)
  GLenum target;
  GLenum pname;
  const GLuint* params;
CODE:
  OGLM_GLEWINIT
  OGLM_CHECK_ERR(glTexParameterIuivOES, )
  OGLM_AVAIL_CHECK(__glewTexParameterIuivOES, glTexParameterIuivOES)
  glTexParameterIuivOES(target, pname, params);
  OGLM_CHECK_ERR(glTexParameterIuivOES, )

void
glTexParameterf(target, pname, param)
  GLenum target;
  GLenum pname;
  GLfloat param;
CODE:
  OGLM_GLEWINIT
  OGLM_CHECK_ERR(glTexParameterf, )
  glTexParameterf(target, pname, param);
  OGLM_CHECK_ERR(glTexParameterf, )

void
glTexParameterfv_c(target, pname, params)
  GLenum target;
  GLenum pname;
  const GLfloat *params;
CODE:
  OGLM_GLEWINIT
  OGLM_CHECK_ERR(glTexParameterfv, )
  glTexParameterfv(target, pname, params);
  OGLM_CHECK_ERR(glTexParameterfv, )

void
glTexParameterfv_p(target, pname, ...)
  GLenum target;
  GLenum pname;
CODE:
  OGLM_GLEWINIT
  OGLM_CHECK_ERR(glTexParameterfv, )
  OGLM_SIZE_ENUM(TextureParameterName,pname,1)
  GLfloat *params = OGLM_GET_VARARGS(params,2,GLfloat,NV,pname_count);
  glTexParameterfv((GLenum )target, (GLenum )pname, (const GLfloat *)params);
  OGLM_CHECK_ERR(glTexParameterfv, free(params);)
  free(params);

void
glTexParameteri(target, pname, param)
  GLenum target;
  GLenum pname;
  GLint param;
CODE:
  OGLM_GLEWINIT
  OGLM_CHECK_ERR(glTexParameteri, )
  glTexParameteri(target, pname, param);
  OGLM_CHECK_ERR(glTexParameteri, )

void
glTexParameteriv_c(target, pname, params)
  GLenum target;
  GLenum pname;
  const GLint *params;
CODE:
  OGLM_GLEWINIT
  OGLM_CHECK_ERR(glTexParameteriv, )
  glTexParameteriv(target, pname, params);
  OGLM_CHECK_ERR(glTexParameteriv, )

void
glTexParameteriv_p(target, pname, ...)
  GLenum target;
  GLenum pname;
CODE:
  OGLM_GLEWINIT
  OGLM_CHECK_ERR(glTexParameteriv, )
  OGLM_SIZE_ENUM(TextureParameterName,pname,1)
  GLint *params = OGLM_GET_VARARGS(params,2,GLint,IV,pname_count);
  glTexParameteriv((GLenum )target, (GLenum )pname, (const GLint *)params);
  OGLM_CHECK_ERR(glTexParameteriv, free(params);)
  free(params);

void
glTexParameterx(target, pname, param)
  GLenum target;
  GLenum pname;
  GLfixed param;
CODE:
  OGLM_GLEWINIT
  OGLM_CHECK_ERR(glTexParameterx, )
  OGLM_AVAIL_CHECK(__glewTexParameterx, glTexParameterx)
  glTexParameterx(target, pname, param);
  OGLM_CHECK_ERR(glTexParameterx, )

void
glTexParameterxv_c(target, pname, params)
  GLenum target;
  GLenum pname;
  const GLfixed* params;
CODE:
  OGLM_GLEWINIT
  OGLM_CHECK_ERR(glTexParameterxv, )
  OGLM_AVAIL_CHECK(__glewTexParameterxv, glTexParameterxv)
  glTexParameterxv(target, pname, params);
  OGLM_CHECK_ERR(glTexParameterxv, )

void
glTexParameterxv_p(target, pname, ...)
  GLenum target;
  GLenum pname;
CODE:
  OGLM_GLEWINIT
  OGLM_CHECK_ERR(glTexParameterxv, )
  OGLM_AVAIL_CHECK(__glewTexParameterxv, glTexParameterxv)
  OGLM_SIZE_ENUM(GetTextureParameter,pname,1)
  GLfixed* params = OGLM_GET_VARARGS(params,2,GLfixed,IV,pname_count);
  glTexParameterxv((GLenum )target, (GLenum )pname, (const GLfixed* )params);
  OGLM_CHECK_ERR(glTexParameterxv, free(params);)
  free(params);

void
glTexRenderbufferNV(target, renderbuffer)
  GLenum target;
  GLuint renderbuffer;
CODE:
  OGLM_GLEWINIT
  OGLM_CHECK_ERR(glTexRenderbufferNV, )
  OGLM_AVAIL_CHECK(__glewTexRenderbufferNV, glTexRenderbufferNV)
  glTexRenderbufferNV(target, renderbuffer);
  OGLM_CHECK_ERR(glTexRenderbufferNV, )

void
glTexScissorFuncINTEL(target, lfunc, hfunc)
  GLenum target;
  GLenum lfunc;
  GLenum hfunc;
CODE:
  OGLM_GLEWINIT
  OGLM_CHECK_ERR(glTexScissorFuncINTEL, )
  OGLM_AVAIL_CHECK(__glewTexScissorFuncINTEL, glTexScissorFuncINTEL)
  glTexScissorFuncINTEL(target, lfunc, hfunc);
  OGLM_CHECK_ERR(glTexScissorFuncINTEL, )

void
glTexScissorINTEL(target, tlow, thigh)
  GLenum target;
  GLclampf tlow;
  GLclampf thigh;
CODE:
  OGLM_GLEWINIT
  OGLM_CHECK_ERR(glTexScissorINTEL, )
  OGLM_AVAIL_CHECK(__glewTexScissorINTEL, glTexScissorINTEL)
  glTexScissorINTEL(target, tlow, thigh);
  OGLM_CHECK_ERR(glTexScissorINTEL, )

void
glTexStorage1D(target, levels, internalformat, width)
  GLenum target;
  GLsizei levels;
  GLenum internalformat;
  GLsizei width;
ALIAS:
  glTexStorage1DEXT = 1
CODE:
  OGLM_GLEWINIT
  OGLM_CHECK_ERR(glTexStorage1D, )
  OGLM_AVAIL_CHECK(__glewTexStorage1D, glTexStorage1D)
  glTexStorage1D(target, levels, internalformat, width);
  OGLM_CHECK_ERR(glTexStorage1D, )

void
glTexStorage2D(target, levels, internalformat, width, height)
  GLenum target;
  GLsizei levels;
  GLenum internalformat;
  GLsizei width;
  GLsizei height;
ALIAS:
  glTexStorage2DEXT = 1
CODE:
  OGLM_GLEWINIT
  OGLM_CHECK_ERR(glTexStorage2D, )
  OGLM_AVAIL_CHECK(__glewTexStorage2D, glTexStorage2D)
  glTexStorage2D(target, levels, internalformat, width, height);
  OGLM_CHECK_ERR(glTexStorage2D, )

void
glTexStorage2DMultisample(target, samples, internalformat, width, height, fixedsamplelocations)
  GLenum target;
  GLsizei samples;
  GLenum internalformat;
  GLsizei width;
  GLsizei height;
  GLboolean fixedsamplelocations;
CODE:
  OGLM_GLEWINIT
  OGLM_CHECK_ERR(glTexStorage2DMultisample, )
  OGLM_AVAIL_CHECK(__glewTexStorage2DMultisample, glTexStorage2DMultisample)
  glTexStorage2DMultisample(target, samples, internalformat, width, height, fixedsamplelocations);
  OGLM_CHECK_ERR(glTexStorage2DMultisample, )

void
glTexStorage3D(target, levels, internalformat, width, height, depth)
  GLenum target;
  GLsizei levels;
  GLenum internalformat;
  GLsizei width;
  GLsizei height;
  GLsizei depth;
ALIAS:
  glTexStorage3DEXT = 1
CODE:
  OGLM_GLEWINIT
  OGLM_CHECK_ERR(glTexStorage3D, )
  OGLM_AVAIL_CHECK(__glewTexStorage3D, glTexStorage3D)
  glTexStorage3D(target, levels, internalformat, width, height, depth);
  OGLM_CHECK_ERR(glTexStorage3D, )

void
glTexStorage3DMultisample(target, samples, internalformat, width, height, depth, fixedsamplelocations)
  GLenum target;
  GLsizei samples;
  GLenum internalformat;
  GLsizei width;
  GLsizei height;
  GLsizei depth;
  GLboolean fixedsamplelocations;
CODE:
  OGLM_GLEWINIT
  OGLM_CHECK_ERR(glTexStorage3DMultisample, )
  OGLM_AVAIL_CHECK(__glewTexStorage3DMultisample, glTexStorage3DMultisample)
  glTexStorage3DMultisample(target, samples, internalformat, width, height, depth, fixedsamplelocations);
  OGLM_CHECK_ERR(glTexStorage3DMultisample, )

void
glTexStorage3DMultisampleOES(target, samples, internalformat, width, height, depth, fixedsamplelocations)
  GLenum target;
  GLsizei samples;
  GLenum internalformat;
  GLsizei width;
  GLsizei height;
  GLsizei depth;
  GLboolean fixedsamplelocations;
CODE:
  OGLM_GLEWINIT
  OGLM_CHECK_ERR(glTexStorage3DMultisampleOES, )
  OGLM_AVAIL_CHECK(__glewTexStorage3DMultisampleOES, glTexStorage3DMultisampleOES)
  glTexStorage3DMultisampleOES(target, samples, internalformat, width, height, depth, fixedsamplelocations);
  OGLM_CHECK_ERR(glTexStorage3DMultisampleOES, )

void
glTexStorageAttribs2DEXT_c(target, levels, internalformat, width, height, attrib_list)
  GLenum target;
  GLsizei levels;
  GLenum internalformat;
  GLsizei width;
  GLsizei height;
  const GLint* attrib_list;
CODE:
  OGLM_GLEWINIT
  OGLM_CHECK_ERR(glTexStorageAttribs2DEXT, )
  OGLM_AVAIL_CHECK(__glewTexStorageAttribs2DEXT, glTexStorageAttribs2DEXT)
  glTexStorageAttribs2DEXT(target, levels, internalformat, width, height, attrib_list);
  OGLM_CHECK_ERR(glTexStorageAttribs2DEXT, )

void
glTexStorageAttribs3DEXT_c(target, levels, internalformat, width, height, depth, attrib_list)
  GLenum target;
  GLsizei levels;
  GLenum internalformat;
  GLsizei width;
  GLsizei height;
  GLsizei depth;
  const GLint* attrib_list;
CODE:
  OGLM_GLEWINIT
  OGLM_CHECK_ERR(glTexStorageAttribs3DEXT, )
  OGLM_AVAIL_CHECK(__glewTexStorageAttribs3DEXT, glTexStorageAttribs3DEXT)
  glTexStorageAttribs3DEXT(target, levels, internalformat, width, height, depth, attrib_list);
  OGLM_CHECK_ERR(glTexStorageAttribs3DEXT, )

void
glTexStorageMem1DEXT(target, levels, internalFormat, width, memory, offset)
  GLenum target;
  GLsizei levels;
  GLenum internalFormat;
  GLsizei width;
  GLuint memory;
  GLuint64 offset;
CODE:
  OGLM_GLEWINIT
  OGLM_CHECK_ERR(glTexStorageMem1DEXT, )
  OGLM_AVAIL_CHECK(__glewTexStorageMem1DEXT, glTexStorageMem1DEXT)
  glTexStorageMem1DEXT(target, levels, internalFormat, width, memory, offset);
  OGLM_CHECK_ERR(glTexStorageMem1DEXT, )

void
glTexStorageMem2DEXT(target, levels, internalFormat, width, height, memory, offset)
  GLenum target;
  GLsizei levels;
  GLenum internalFormat;
  GLsizei width;
  GLsizei height;
  GLuint memory;
  GLuint64 offset;
CODE:
  OGLM_GLEWINIT
  OGLM_CHECK_ERR(glTexStorageMem2DEXT, )
  OGLM_AVAIL_CHECK(__glewTexStorageMem2DEXT, glTexStorageMem2DEXT)
  glTexStorageMem2DEXT(target, levels, internalFormat, width, height, memory, offset);
  OGLM_CHECK_ERR(glTexStorageMem2DEXT, )

void
glTexStorageMem2DMultisampleEXT(target, samples, internalFormat, width, height, fixedSampleLocations, memory, offset)
  GLenum target;
  GLsizei samples;
  GLenum internalFormat;
  GLsizei width;
  GLsizei height;
  GLboolean fixedSampleLocations;
  GLuint memory;
  GLuint64 offset;
CODE:
  OGLM_GLEWINIT
  OGLM_CHECK_ERR(glTexStorageMem2DMultisampleEXT, )
  OGLM_AVAIL_CHECK(__glewTexStorageMem2DMultisampleEXT, glTexStorageMem2DMultisampleEXT)
  glTexStorageMem2DMultisampleEXT(target, samples, internalFormat, width, height, fixedSampleLocations, memory, offset);
  OGLM_CHECK_ERR(glTexStorageMem2DMultisampleEXT, )

void
glTexStorageMem3DEXT(target, levels, internalFormat, width, height, depth, memory, offset)
  GLenum target;
  GLsizei levels;
  GLenum internalFormat;
  GLsizei width;
  GLsizei height;
  GLsizei depth;
  GLuint memory;
  GLuint64 offset;
CODE:
  OGLM_GLEWINIT
  OGLM_CHECK_ERR(glTexStorageMem3DEXT, )
  OGLM_AVAIL_CHECK(__glewTexStorageMem3DEXT, glTexStorageMem3DEXT)
  glTexStorageMem3DEXT(target, levels, internalFormat, width, height, depth, memory, offset);
  OGLM_CHECK_ERR(glTexStorageMem3DEXT, )

void
glTexStorageMem3DMultisampleEXT(target, samples, internalFormat, width, height, depth, fixedSampleLocations, memory, offset)
  GLenum target;
  GLsizei samples;
  GLenum internalFormat;
  GLsizei width;
  GLsizei height;
  GLsizei depth;
  GLboolean fixedSampleLocations;
  GLuint memory;
  GLuint64 offset;
CODE:
  OGLM_GLEWINIT
  OGLM_CHECK_ERR(glTexStorageMem3DMultisampleEXT, )
  OGLM_AVAIL_CHECK(__glewTexStorageMem3DMultisampleEXT, glTexStorageMem3DMultisampleEXT)
  glTexStorageMem3DMultisampleEXT(target, samples, internalFormat, width, height, depth, fixedSampleLocations, memory, offset);
  OGLM_CHECK_ERR(glTexStorageMem3DMultisampleEXT, )

void
glTexStorageSparseAMD(target, internalFormat, width, height, depth, layers, flags)
  GLenum target;
  GLenum internalFormat;
  GLsizei width;
  GLsizei height;
  GLsizei depth;
  GLsizei layers;
  GLbitfield flags;
CODE:
  OGLM_GLEWINIT
  OGLM_CHECK_ERR(glTexStorageSparseAMD, )
  OGLM_AVAIL_CHECK(__glewTexStorageSparseAMD, glTexStorageSparseAMD)
  glTexStorageSparseAMD(target, internalFormat, width, height, depth, layers, flags);
  OGLM_CHECK_ERR(glTexStorageSparseAMD, )

void
glTexSubImage1D_c(target, level, xoffset, width, format, type, pixels)
  GLenum target;
  GLint level;
  GLint xoffset;
  GLsizei width;
  GLenum format;
  GLenum type;
  const void *pixels;
ALIAS:
  glTexSubImage1DEXT_c = 1
CODE:
  OGLM_GLEWINIT
  OGLM_CHECK_ERR(glTexSubImage1D, )
  glTexSubImage1D(target, level, xoffset, width, format, type, pixels);
  OGLM_CHECK_ERR(glTexSubImage1D, )

void
glTexSubImage2D_c(target, level, xoffset, yoffset, width, height, format, type, pixels)
  GLenum target;
  GLint level;
  GLint xoffset;
  GLint yoffset;
  GLsizei width;
  GLsizei height;
  GLenum format;
  GLenum type;
  const void *pixels;
ALIAS:
  glTexSubImage2DEXT_c = 1
CODE:
  OGLM_GLEWINIT
  OGLM_CHECK_ERR(glTexSubImage2D, )
  glTexSubImage2D(target, level, xoffset, yoffset, width, height, format, type, pixels);
  OGLM_CHECK_ERR(glTexSubImage2D, )

void
glTexSubImage3D_c(target, level, xoffset, yoffset, zoffset, width, height, depth, format, type, pixels)
  GLenum target;
  GLint level;
  GLint xoffset;
  GLint yoffset;
  GLint zoffset;
  GLsizei width;
  GLsizei height;
  GLsizei depth;
  GLenum format;
  GLenum type;
  const void *pixels;
ALIAS:
  glTexSubImage3DEXT_c = 1
CODE:
  OGLM_GLEWINIT
  OGLM_CHECK_ERR(glTexSubImage3D, )
  OGLM_AVAIL_CHECK(__glewTexSubImage3D, glTexSubImage3D)
  glTexSubImage3D(target, level, xoffset, yoffset, zoffset, width, height, depth, format, type, pixels);
  OGLM_CHECK_ERR(glTexSubImage3D, )

void
glTexSubImage3DNV_c(target, level, xoffset, yoffset, zoffset, width, height, depth, format, type, pixels)
  GLenum target;
  GLint level;
  GLint xoffset;
  GLint yoffset;
  GLint zoffset;
  GLsizei width;
  GLsizei height;
  GLsizei depth;
  GLenum format;
  GLenum type;
  const void *pixels;
CODE:
  OGLM_GLEWINIT
  OGLM_CHECK_ERR(glTexSubImage3DNV, )
  OGLM_AVAIL_CHECK(__glewTexSubImage3DNV, glTexSubImage3DNV)
  glTexSubImage3DNV(target, level, xoffset, yoffset, zoffset, width, height, depth, format, type, pixels);
  OGLM_CHECK_ERR(glTexSubImage3DNV, )

void
glTexSubImage3DOES_c(target, level, xoffset, yoffset, zoffset, width, height, depth, format, type, pixels)
  GLenum target;
  GLint level;
  GLint xoffset;
  GLint yoffset;
  GLint zoffset;
  GLsizei width;
  GLsizei height;
  GLsizei depth;
  GLenum format;
  GLenum type;
  const void *pixels;
CODE:
  OGLM_GLEWINIT
  OGLM_CHECK_ERR(glTexSubImage3DOES, )
  OGLM_AVAIL_CHECK(__glewTexSubImage3DOES, glTexSubImage3DOES)
  glTexSubImage3DOES(target, level, xoffset, yoffset, zoffset, width, height, depth, format, type, pixels);
  OGLM_CHECK_ERR(glTexSubImage3DOES, )

void
glTexSubImage4DSGIS_c(target, level, xoffset, yoffset, zoffset, woffset, width, height, depth, size4d, format, type, pixels)
  GLenum target;
  GLint level;
  GLint xoffset;
  GLint yoffset;
  GLint zoffset;
  GLint woffset;
  GLsizei width;
  GLsizei height;
  GLsizei depth;
  GLsizei size4d;
  GLenum format;
  GLenum type;
  const void *pixels;
CODE:
  OGLM_GLEWINIT
  OGLM_CHECK_ERR(glTexSubImage4DSGIS, )
  OGLM_AVAIL_CHECK(__glewTexSubImage4DSGIS, glTexSubImage4DSGIS)
  glTexSubImage4DSGIS(target, level, xoffset, yoffset, zoffset, woffset, width, height, depth, size4d, format, type, pixels);
  OGLM_CHECK_ERR(glTexSubImage4DSGIS, )

void
glTextureAttachMemoryNV(texture, memory, offset)
  GLuint texture;
  GLuint memory;
  GLuint64 offset;
CODE:
  OGLM_GLEWINIT
  OGLM_CHECK_ERR(glTextureAttachMemoryNV, )
  OGLM_AVAIL_CHECK(__glewTextureAttachMemoryNV, glTextureAttachMemoryNV)
  glTextureAttachMemoryNV(texture, memory, offset);
  OGLM_CHECK_ERR(glTextureAttachMemoryNV, )

void
glTextureBarrier()
CODE:
  OGLM_GLEWINIT
  OGLM_CHECK_ERR(glTextureBarrier, )
  OGLM_AVAIL_CHECK(__glewTextureBarrier, glTextureBarrier)
  glTextureBarrier();
  OGLM_CHECK_ERR(glTextureBarrier, )

void
glTextureBarrierNV()
CODE:
  OGLM_GLEWINIT
  OGLM_CHECK_ERR(glTextureBarrierNV, )
  OGLM_AVAIL_CHECK(__glewTextureBarrierNV, glTextureBarrierNV)
  glTextureBarrierNV();
  OGLM_CHECK_ERR(glTextureBarrierNV, )

void
glTextureBuffer(texture, internalformat, buffer)
  GLuint texture;
  GLenum internalformat;
  GLuint buffer;
CODE:
  OGLM_GLEWINIT
  OGLM_CHECK_ERR(glTextureBuffer, )
  OGLM_AVAIL_CHECK(__glewTextureBuffer, glTextureBuffer)
  glTextureBuffer(texture, internalformat, buffer);
  OGLM_CHECK_ERR(glTextureBuffer, )

void
glTextureBufferEXT(texture, target, internalformat, buffer)
  GLuint texture;
  GLenum target;
  GLenum internalformat;
  GLuint buffer;
CODE:
  OGLM_GLEWINIT
  OGLM_CHECK_ERR(glTextureBufferEXT, )
  OGLM_AVAIL_CHECK(__glewTextureBufferEXT, glTextureBufferEXT)
  glTextureBufferEXT(texture, target, internalformat, buffer);
  OGLM_CHECK_ERR(glTextureBufferEXT, )

void
glTextureBufferRange(texture, internalformat, buffer, offset, size)
  GLuint texture;
  GLenum internalformat;
  GLuint buffer;
  GLintptr offset;
  GLsizeiptr size;
CODE:
  OGLM_GLEWINIT
  OGLM_CHECK_ERR(glTextureBufferRange, )
  OGLM_AVAIL_CHECK(__glewTextureBufferRange, glTextureBufferRange)
  glTextureBufferRange(texture, internalformat, buffer, offset, size);
  OGLM_CHECK_ERR(glTextureBufferRange, )

void
glTextureBufferRangeEXT(texture, target, internalformat, buffer, offset, size)
  GLuint texture;
  GLenum target;
  GLenum internalformat;
  GLuint buffer;
  GLintptr offset;
  GLsizeiptr size;
CODE:
  OGLM_GLEWINIT
  OGLM_CHECK_ERR(glTextureBufferRangeEXT, )
  OGLM_AVAIL_CHECK(__glewTextureBufferRangeEXT, glTextureBufferRangeEXT)
  glTextureBufferRangeEXT(texture, target, internalformat, buffer, offset, size);
  OGLM_CHECK_ERR(glTextureBufferRangeEXT, )

void
glTextureFogSGIX(pname)
  GLenum pname;
CODE:
  OGLM_GLEWINIT
  OGLM_CHECK_ERR(glTextureFogSGIX, )
  OGLM_AVAIL_CHECK(__glewTextureFogSGIX, glTextureFogSGIX)
  glTextureFogSGIX(pname);
  OGLM_CHECK_ERR(glTextureFogSGIX, )

void
glTextureFoveationParametersQCOM(texture, layer, focalPoint, focalX, focalY, gainX, gainY, foveaArea)
  GLuint texture;
  GLuint layer;
  GLuint focalPoint;
  GLfloat focalX;
  GLfloat focalY;
  GLfloat gainX;
  GLfloat gainY;
  GLfloat foveaArea;
CODE:
  OGLM_GLEWINIT
  OGLM_CHECK_ERR(glTextureFoveationParametersQCOM, )
  OGLM_AVAIL_CHECK(__glewTextureFoveationParametersQCOM, glTextureFoveationParametersQCOM)
  glTextureFoveationParametersQCOM(texture, layer, focalPoint, focalX, focalY, gainX, gainY, foveaArea);
  OGLM_CHECK_ERR(glTextureFoveationParametersQCOM, )

void
glTextureImage1DEXT_c(texture, target, level, internalformat, width, border, format, type, pixels)
  GLuint texture;
  GLenum target;
  GLint level;
  GLint internalformat;
  GLsizei width;
  GLint border;
  GLenum format;
  GLenum type;
  const void *pixels;
CODE:
  OGLM_GLEWINIT
  OGLM_CHECK_ERR(glTextureImage1DEXT, )
  OGLM_AVAIL_CHECK(__glewTextureImage1DEXT, glTextureImage1DEXT)
  glTextureImage1DEXT(texture, target, level, internalformat, width, border, format, type, pixels);
  OGLM_CHECK_ERR(glTextureImage1DEXT, )

void
glTextureImage2DEXT_c(texture, target, level, internalformat, width, height, border, format, type, pixels)
  GLuint texture;
  GLenum target;
  GLint level;
  GLint internalformat;
  GLsizei width;
  GLsizei height;
  GLint border;
  GLenum format;
  GLenum type;
  const void *pixels;
CODE:
  OGLM_GLEWINIT
  OGLM_CHECK_ERR(glTextureImage2DEXT, )
  OGLM_AVAIL_CHECK(__glewTextureImage2DEXT, glTextureImage2DEXT)
  glTextureImage2DEXT(texture, target, level, internalformat, width, height, border, format, type, pixels);
  OGLM_CHECK_ERR(glTextureImage2DEXT, )

void
glTextureImage2DMultisampleCoverageNV(texture, target, coverageSamples, colorSamples, internalFormat, width, height, fixedSampleLocations)
  GLuint texture;
  GLenum target;
  GLsizei coverageSamples;
  GLsizei colorSamples;
  GLint internalFormat;
  GLsizei width;
  GLsizei height;
  GLboolean fixedSampleLocations;
CODE:
  OGLM_GLEWINIT
  OGLM_CHECK_ERR(glTextureImage2DMultisampleCoverageNV, )
  OGLM_AVAIL_CHECK(__glewTextureImage2DMultisampleCoverageNV, glTextureImage2DMultisampleCoverageNV)
  glTextureImage2DMultisampleCoverageNV(texture, target, coverageSamples, colorSamples, internalFormat, width, height, fixedSampleLocations);
  OGLM_CHECK_ERR(glTextureImage2DMultisampleCoverageNV, )

void
glTextureImage2DMultisampleNV(texture, target, samples, internalFormat, width, height, fixedSampleLocations)
  GLuint texture;
  GLenum target;
  GLsizei samples;
  GLint internalFormat;
  GLsizei width;
  GLsizei height;
  GLboolean fixedSampleLocations;
CODE:
  OGLM_GLEWINIT
  OGLM_CHECK_ERR(glTextureImage2DMultisampleNV, )
  OGLM_AVAIL_CHECK(__glewTextureImage2DMultisampleNV, glTextureImage2DMultisampleNV)
  glTextureImage2DMultisampleNV(texture, target, samples, internalFormat, width, height, fixedSampleLocations);
  OGLM_CHECK_ERR(glTextureImage2DMultisampleNV, )

void
glTextureImage3DEXT_c(texture, target, level, internalformat, width, height, depth, border, format, type, pixels)
  GLuint texture;
  GLenum target;
  GLint level;
  GLint internalformat;
  GLsizei width;
  GLsizei height;
  GLsizei depth;
  GLint border;
  GLenum format;
  GLenum type;
  const void *pixels;
CODE:
  OGLM_GLEWINIT
  OGLM_CHECK_ERR(glTextureImage3DEXT, )
  OGLM_AVAIL_CHECK(__glewTextureImage3DEXT, glTextureImage3DEXT)
  glTextureImage3DEXT(texture, target, level, internalformat, width, height, depth, border, format, type, pixels);
  OGLM_CHECK_ERR(glTextureImage3DEXT, )

void
glTextureImage3DMultisampleCoverageNV(texture, target, coverageSamples, colorSamples, internalFormat, width, height, depth, fixedSampleLocations)
  GLuint texture;
  GLenum target;
  GLsizei coverageSamples;
  GLsizei colorSamples;
  GLint internalFormat;
  GLsizei width;
  GLsizei height;
  GLsizei depth;
  GLboolean fixedSampleLocations;
CODE:
  OGLM_GLEWINIT
  OGLM_CHECK_ERR(glTextureImage3DMultisampleCoverageNV, )
  OGLM_AVAIL_CHECK(__glewTextureImage3DMultisampleCoverageNV, glTextureImage3DMultisampleCoverageNV)
  glTextureImage3DMultisampleCoverageNV(texture, target, coverageSamples, colorSamples, internalFormat, width, height, depth, fixedSampleLocations);
  OGLM_CHECK_ERR(glTextureImage3DMultisampleCoverageNV, )

void
glTextureImage3DMultisampleNV(texture, target, samples, internalFormat, width, height, depth, fixedSampleLocations)
  GLuint texture;
  GLenum target;
  GLsizei samples;
  GLint internalFormat;
  GLsizei width;
  GLsizei height;
  GLsizei depth;
  GLboolean fixedSampleLocations;
CODE:
  OGLM_GLEWINIT
  OGLM_CHECK_ERR(glTextureImage3DMultisampleNV, )
  OGLM_AVAIL_CHECK(__glewTextureImage3DMultisampleNV, glTextureImage3DMultisampleNV)
  glTextureImage3DMultisampleNV(texture, target, samples, internalFormat, width, height, depth, fixedSampleLocations);
  OGLM_CHECK_ERR(glTextureImage3DMultisampleNV, )

void
glTextureLightEXT(pname)
  GLenum pname;
CODE:
  OGLM_GLEWINIT
  OGLM_CHECK_ERR(glTextureLightEXT, )
  OGLM_AVAIL_CHECK(__glewTextureLightEXT, glTextureLightEXT)
  glTextureLightEXT(pname);
  OGLM_CHECK_ERR(glTextureLightEXT, )

void
glTextureMaterialEXT(face, mode)
  GLenum face;
  GLenum mode;
CODE:
  OGLM_GLEWINIT
  OGLM_CHECK_ERR(glTextureMaterialEXT, )
  OGLM_AVAIL_CHECK(__glewTextureMaterialEXT, glTextureMaterialEXT)
  glTextureMaterialEXT(face, mode);
  OGLM_CHECK_ERR(glTextureMaterialEXT, )

void
glTextureNormalEXT(mode)
  GLenum mode;
CODE:
  OGLM_GLEWINIT
  OGLM_CHECK_ERR(glTextureNormalEXT, )
  OGLM_AVAIL_CHECK(__glewTextureNormalEXT, glTextureNormalEXT)
  glTextureNormalEXT(mode);
  OGLM_CHECK_ERR(glTextureNormalEXT, )

void
glTexturePageCommitmentEXT(texture, level, xoffset, yoffset, zoffset, width, height, depth, commit)
  GLuint texture;
  GLint level;
  GLint xoffset;
  GLint yoffset;
  GLint zoffset;
  GLsizei width;
  GLsizei height;
  GLsizei depth;
  GLboolean commit;
CODE:
  OGLM_GLEWINIT
  OGLM_CHECK_ERR(glTexturePageCommitmentEXT, )
  OGLM_AVAIL_CHECK(__glewTexturePageCommitmentEXT, glTexturePageCommitmentEXT)
  glTexturePageCommitmentEXT(texture, level, xoffset, yoffset, zoffset, width, height, depth, commit);
  OGLM_CHECK_ERR(glTexturePageCommitmentEXT, )

void
glTexturePageCommitmentMemNV(texture, layer, level, xoffset, yoffset, zoffset, width, height, depth, memory, offset, commit)
  GLuint texture;
  GLint layer;
  GLint level;
  GLint xoffset;
  GLint yoffset;
  GLint zoffset;
  GLsizei width;
  GLsizei height;
  GLsizei depth;
  GLuint memory;
  GLuint64 offset;
  GLboolean commit;
CODE:
  OGLM_GLEWINIT
  OGLM_CHECK_ERR(glTexturePageCommitmentMemNV, )
  OGLM_AVAIL_CHECK(__glewTexturePageCommitmentMemNV, glTexturePageCommitmentMemNV)
  glTexturePageCommitmentMemNV(texture, layer, level, xoffset, yoffset, zoffset, width, height, depth, memory, offset, commit);
  OGLM_CHECK_ERR(glTexturePageCommitmentMemNV, )

void
glTextureParameterIiv_c(texture, pname, params)
  GLuint texture;
  GLenum pname;
  const GLint* params;
CODE:
  OGLM_GLEWINIT
  OGLM_CHECK_ERR(glTextureParameterIiv, )
  OGLM_AVAIL_CHECK(__glewTextureParameterIiv, glTextureParameterIiv)
  glTextureParameterIiv(texture, pname, params);
  OGLM_CHECK_ERR(glTextureParameterIiv, )

void
glTextureParameterIiv_p(texture, pname, ...)
  GLuint texture;
  GLenum pname;
CODE:
  OGLM_GLEWINIT
  OGLM_CHECK_ERR(glTextureParameterIiv, )
  OGLM_AVAIL_CHECK(__glewTextureParameterIiv, glTextureParameterIiv)
  OGLM_SIZE_ENUM(TextureParameterName,pname,1)
  GLint* params = OGLM_GET_VARARGS(params,2,GLint,IV,pname_count);
  glTextureParameterIiv((GLuint )texture, (GLenum )pname, (const GLint* )params);
  OGLM_CHECK_ERR(glTextureParameterIiv, free(params);)
  free(params);

void
glTextureParameterIivEXT_c(texture, target, pname, params)
  GLuint texture;
  GLenum target;
  GLenum pname;
  const GLint* params;
CODE:
  OGLM_GLEWINIT
  OGLM_CHECK_ERR(glTextureParameterIivEXT, )
  OGLM_AVAIL_CHECK(__glewTextureParameterIivEXT, glTextureParameterIivEXT)
  glTextureParameterIivEXT(texture, target, pname, params);
  OGLM_CHECK_ERR(glTextureParameterIivEXT, )

void
glTextureParameterIivEXT_p(texture, target, pname, ...)
  GLuint texture;
  GLenum target;
  GLenum pname;
CODE:
  OGLM_GLEWINIT
  OGLM_CHECK_ERR(glTextureParameterIivEXT, )
  OGLM_AVAIL_CHECK(__glewTextureParameterIivEXT, glTextureParameterIivEXT)
  OGLM_SIZE_ENUM(TextureParameterName,pname,1)
  GLint* params = OGLM_GET_VARARGS(params,3,GLint,IV,pname_count);
  glTextureParameterIivEXT((GLuint )texture, (GLenum )target, (GLenum )pname, (const GLint* )params);
  OGLM_CHECK_ERR(glTextureParameterIivEXT, free(params);)
  free(params);

void
glTextureParameterIuiv_c(texture, pname, params)
  GLuint texture;
  GLenum pname;
  const GLuint* params;
CODE:
  OGLM_GLEWINIT
  OGLM_CHECK_ERR(glTextureParameterIuiv, )
  OGLM_AVAIL_CHECK(__glewTextureParameterIuiv, glTextureParameterIuiv)
  glTextureParameterIuiv(texture, pname, params);
  OGLM_CHECK_ERR(glTextureParameterIuiv, )

void
glTextureParameterIuiv_p(texture, pname, ...)
  GLuint texture;
  GLenum pname;
CODE:
  OGLM_GLEWINIT
  OGLM_CHECK_ERR(glTextureParameterIuiv, )
  OGLM_AVAIL_CHECK(__glewTextureParameterIuiv, glTextureParameterIuiv)
  OGLM_SIZE_ENUM(TextureParameterName,pname,1)
  GLuint* params = OGLM_GET_VARARGS(params,2,GLuint,UV,pname_count);
  glTextureParameterIuiv((GLuint )texture, (GLenum )pname, (const GLuint* )params);
  OGLM_CHECK_ERR(glTextureParameterIuiv, free(params);)
  free(params);

void
glTextureParameterIuivEXT_c(texture, target, pname, params)
  GLuint texture;
  GLenum target;
  GLenum pname;
  const GLuint* params;
CODE:
  OGLM_GLEWINIT
  OGLM_CHECK_ERR(glTextureParameterIuivEXT, )
  OGLM_AVAIL_CHECK(__glewTextureParameterIuivEXT, glTextureParameterIuivEXT)
  glTextureParameterIuivEXT(texture, target, pname, params);
  OGLM_CHECK_ERR(glTextureParameterIuivEXT, )

void
glTextureParameterIuivEXT_p(texture, target, pname, ...)
  GLuint texture;
  GLenum target;
  GLenum pname;
CODE:
  OGLM_GLEWINIT
  OGLM_CHECK_ERR(glTextureParameterIuivEXT, )
  OGLM_AVAIL_CHECK(__glewTextureParameterIuivEXT, glTextureParameterIuivEXT)
  OGLM_SIZE_ENUM(TextureParameterName,pname,1)
  GLuint* params = OGLM_GET_VARARGS(params,3,GLuint,UV,pname_count);
  glTextureParameterIuivEXT((GLuint )texture, (GLenum )target, (GLenum )pname, (const GLuint* )params);
  OGLM_CHECK_ERR(glTextureParameterIuivEXT, free(params);)
  free(params);

void
glTextureParameterf(texture, pname, param)
  GLuint texture;
  GLenum pname;
  GLfloat param;
CODE:
  OGLM_GLEWINIT
  OGLM_CHECK_ERR(glTextureParameterf, )
  OGLM_AVAIL_CHECK(__glewTextureParameterf, glTextureParameterf)
  glTextureParameterf(texture, pname, param);
  OGLM_CHECK_ERR(glTextureParameterf, )

void
glTextureParameterfEXT(texture, target, pname, param)
  GLuint texture;
  GLenum target;
  GLenum pname;
  GLfloat param;
CODE:
  OGLM_GLEWINIT
  OGLM_CHECK_ERR(glTextureParameterfEXT, )
  OGLM_AVAIL_CHECK(__glewTextureParameterfEXT, glTextureParameterfEXT)
  glTextureParameterfEXT(texture, target, pname, param);
  OGLM_CHECK_ERR(glTextureParameterfEXT, )

void
glTextureParameterfv_c(texture, pname, param)
  GLuint texture;
  GLenum pname;
  const GLfloat* param;
CODE:
  OGLM_GLEWINIT
  OGLM_CHECK_ERR(glTextureParameterfv, )
  OGLM_AVAIL_CHECK(__glewTextureParameterfv, glTextureParameterfv)
  glTextureParameterfv(texture, pname, param);
  OGLM_CHECK_ERR(glTextureParameterfv, )

void
glTextureParameterfv_p(texture, pname, ...)
  GLuint texture;
  GLenum pname;
CODE:
  OGLM_GLEWINIT
  OGLM_CHECK_ERR(glTextureParameterfv, )
  OGLM_AVAIL_CHECK(__glewTextureParameterfv, glTextureParameterfv)
  OGLM_SIZE_ENUM(TextureParameterName,pname,1)
  GLfloat* param = OGLM_GET_VARARGS(param,2,GLfloat,NV,pname_count);
  glTextureParameterfv((GLuint )texture, (GLenum )pname, (const GLfloat* )param);
  OGLM_CHECK_ERR(glTextureParameterfv, free(param);)
  free(param);

void
glTextureParameterfvEXT_c(texture, target, pname, params)
  GLuint texture;
  GLenum target;
  GLenum pname;
  const GLfloat* params;
CODE:
  OGLM_GLEWINIT
  OGLM_CHECK_ERR(glTextureParameterfvEXT, )
  OGLM_AVAIL_CHECK(__glewTextureParameterfvEXT, glTextureParameterfvEXT)
  glTextureParameterfvEXT(texture, target, pname, params);
  OGLM_CHECK_ERR(glTextureParameterfvEXT, )

void
glTextureParameterfvEXT_p(texture, target, pname, ...)
  GLuint texture;
  GLenum target;
  GLenum pname;
CODE:
  OGLM_GLEWINIT
  OGLM_CHECK_ERR(glTextureParameterfvEXT, )
  OGLM_AVAIL_CHECK(__glewTextureParameterfvEXT, glTextureParameterfvEXT)
  OGLM_SIZE_ENUM(TextureParameterName,pname,1)
  GLfloat* params = OGLM_GET_VARARGS(params,3,GLfloat,NV,pname_count);
  glTextureParameterfvEXT((GLuint )texture, (GLenum )target, (GLenum )pname, (const GLfloat* )params);
  OGLM_CHECK_ERR(glTextureParameterfvEXT, free(params);)
  free(params);

void
glTextureParameteri(texture, pname, param)
  GLuint texture;
  GLenum pname;
  GLint param;
CODE:
  OGLM_GLEWINIT
  OGLM_CHECK_ERR(glTextureParameteri, )
  OGLM_AVAIL_CHECK(__glewTextureParameteri, glTextureParameteri)
  glTextureParameteri(texture, pname, param);
  OGLM_CHECK_ERR(glTextureParameteri, )

void
glTextureParameteriEXT(texture, target, pname, param)
  GLuint texture;
  GLenum target;
  GLenum pname;
  GLint param;
CODE:
  OGLM_GLEWINIT
  OGLM_CHECK_ERR(glTextureParameteriEXT, )
  OGLM_AVAIL_CHECK(__glewTextureParameteriEXT, glTextureParameteriEXT)
  glTextureParameteriEXT(texture, target, pname, param);
  OGLM_CHECK_ERR(glTextureParameteriEXT, )

void
glTextureParameteriv_c(texture, pname, param)
  GLuint texture;
  GLenum pname;
  const GLint* param;
CODE:
  OGLM_GLEWINIT
  OGLM_CHECK_ERR(glTextureParameteriv, )
  OGLM_AVAIL_CHECK(__glewTextureParameteriv, glTextureParameteriv)
  glTextureParameteriv(texture, pname, param);
  OGLM_CHECK_ERR(glTextureParameteriv, )

void
glTextureParameteriv_p(texture, pname, ...)
  GLuint texture;
  GLenum pname;
CODE:
  OGLM_GLEWINIT
  OGLM_CHECK_ERR(glTextureParameteriv, )
  OGLM_AVAIL_CHECK(__glewTextureParameteriv, glTextureParameteriv)
  OGLM_SIZE_ENUM(TextureParameterName,pname,1)
  GLint* param = OGLM_GET_VARARGS(param,2,GLint,IV,pname_count);
  glTextureParameteriv((GLuint )texture, (GLenum )pname, (const GLint* )param);
  OGLM_CHECK_ERR(glTextureParameteriv, free(param);)
  free(param);

void
glTextureParameterivEXT_c(texture, target, pname, params)
  GLuint texture;
  GLenum target;
  GLenum pname;
  const GLint* params;
CODE:
  OGLM_GLEWINIT
  OGLM_CHECK_ERR(glTextureParameterivEXT, )
  OGLM_AVAIL_CHECK(__glewTextureParameterivEXT, glTextureParameterivEXT)
  glTextureParameterivEXT(texture, target, pname, params);
  OGLM_CHECK_ERR(glTextureParameterivEXT, )

void
glTextureParameterivEXT_p(texture, target, pname, ...)
  GLuint texture;
  GLenum target;
  GLenum pname;
CODE:
  OGLM_GLEWINIT
  OGLM_CHECK_ERR(glTextureParameterivEXT, )
  OGLM_AVAIL_CHECK(__glewTextureParameterivEXT, glTextureParameterivEXT)
  OGLM_SIZE_ENUM(TextureParameterName,pname,1)
  GLint* params = OGLM_GET_VARARGS(params,3,GLint,IV,pname_count);
  glTextureParameterivEXT((GLuint )texture, (GLenum )target, (GLenum )pname, (const GLint* )params);
  OGLM_CHECK_ERR(glTextureParameterivEXT, free(params);)
  free(params);

void
glTextureRangeAPPLE_c(target, length, pointer)
  GLenum target;
  GLsizei length;
  void *pointer;
CODE:
  OGLM_GLEWINIT
  OGLM_CHECK_ERR(glTextureRangeAPPLE, )
  OGLM_AVAIL_CHECK(__glewTextureRangeAPPLE, glTextureRangeAPPLE)
  glTextureRangeAPPLE(target, length, pointer);
  OGLM_CHECK_ERR(glTextureRangeAPPLE, )

void
glTextureRenderbufferEXT(texture, target, renderbuffer)
  GLuint texture;
  GLenum target;
  GLuint renderbuffer;
CODE:
  OGLM_GLEWINIT
  OGLM_CHECK_ERR(glTextureRenderbufferEXT, )
  OGLM_AVAIL_CHECK(__glewTextureRenderbufferEXT, glTextureRenderbufferEXT)
  glTextureRenderbufferEXT(texture, target, renderbuffer);
  OGLM_CHECK_ERR(glTextureRenderbufferEXT, )

void
glTextureStorage1D(texture, levels, internalformat, width)
  GLuint texture;
  GLsizei levels;
  GLenum internalformat;
  GLsizei width;
CODE:
  OGLM_GLEWINIT
  OGLM_CHECK_ERR(glTextureStorage1D, )
  OGLM_AVAIL_CHECK(__glewTextureStorage1D, glTextureStorage1D)
  glTextureStorage1D(texture, levels, internalformat, width);
  OGLM_CHECK_ERR(glTextureStorage1D, )

void
glTextureStorage1DEXT(texture, target, levels, internalformat, width)
  GLuint texture;
  GLenum target;
  GLsizei levels;
  GLenum internalformat;
  GLsizei width;
CODE:
  OGLM_GLEWINIT
  OGLM_CHECK_ERR(glTextureStorage1DEXT, )
  OGLM_AVAIL_CHECK(__glewTextureStorage1DEXT, glTextureStorage1DEXT)
  glTextureStorage1DEXT(texture, target, levels, internalformat, width);
  OGLM_CHECK_ERR(glTextureStorage1DEXT, )

void
glTextureStorage2D(texture, levels, internalformat, width, height)
  GLuint texture;
  GLsizei levels;
  GLenum internalformat;
  GLsizei width;
  GLsizei height;
CODE:
  OGLM_GLEWINIT
  OGLM_CHECK_ERR(glTextureStorage2D, )
  OGLM_AVAIL_CHECK(__glewTextureStorage2D, glTextureStorage2D)
  glTextureStorage2D(texture, levels, internalformat, width, height);
  OGLM_CHECK_ERR(glTextureStorage2D, )

void
glTextureStorage2DEXT(texture, target, levels, internalformat, width, height)
  GLuint texture;
  GLenum target;
  GLsizei levels;
  GLenum internalformat;
  GLsizei width;
  GLsizei height;
CODE:
  OGLM_GLEWINIT
  OGLM_CHECK_ERR(glTextureStorage2DEXT, )
  OGLM_AVAIL_CHECK(__glewTextureStorage2DEXT, glTextureStorage2DEXT)
  glTextureStorage2DEXT(texture, target, levels, internalformat, width, height);
  OGLM_CHECK_ERR(glTextureStorage2DEXT, )

void
glTextureStorage2DMultisample(texture, samples, internalformat, width, height, fixedsamplelocations)
  GLuint texture;
  GLsizei samples;
  GLenum internalformat;
  GLsizei width;
  GLsizei height;
  GLboolean fixedsamplelocations;
CODE:
  OGLM_GLEWINIT
  OGLM_CHECK_ERR(glTextureStorage2DMultisample, )
  OGLM_AVAIL_CHECK(__glewTextureStorage2DMultisample, glTextureStorage2DMultisample)
  glTextureStorage2DMultisample(texture, samples, internalformat, width, height, fixedsamplelocations);
  OGLM_CHECK_ERR(glTextureStorage2DMultisample, )

void
glTextureStorage2DMultisampleEXT(texture, target, samples, internalformat, width, height, fixedsamplelocations)
  GLuint texture;
  GLenum target;
  GLsizei samples;
  GLenum internalformat;
  GLsizei width;
  GLsizei height;
  GLboolean fixedsamplelocations;
CODE:
  OGLM_GLEWINIT
  OGLM_CHECK_ERR(glTextureStorage2DMultisampleEXT, )
  OGLM_AVAIL_CHECK(__glewTextureStorage2DMultisampleEXT, glTextureStorage2DMultisampleEXT)
  glTextureStorage2DMultisampleEXT(texture, target, samples, internalformat, width, height, fixedsamplelocations);
  OGLM_CHECK_ERR(glTextureStorage2DMultisampleEXT, )

void
glTextureStorage3D(texture, levels, internalformat, width, height, depth)
  GLuint texture;
  GLsizei levels;
  GLenum internalformat;
  GLsizei width;
  GLsizei height;
  GLsizei depth;
CODE:
  OGLM_GLEWINIT
  OGLM_CHECK_ERR(glTextureStorage3D, )
  OGLM_AVAIL_CHECK(__glewTextureStorage3D, glTextureStorage3D)
  glTextureStorage3D(texture, levels, internalformat, width, height, depth);
  OGLM_CHECK_ERR(glTextureStorage3D, )

void
glTextureStorage3DEXT(texture, target, levels, internalformat, width, height, depth)
  GLuint texture;
  GLenum target;
  GLsizei levels;
  GLenum internalformat;
  GLsizei width;
  GLsizei height;
  GLsizei depth;
CODE:
  OGLM_GLEWINIT
  OGLM_CHECK_ERR(glTextureStorage3DEXT, )
  OGLM_AVAIL_CHECK(__glewTextureStorage3DEXT, glTextureStorage3DEXT)
  glTextureStorage3DEXT(texture, target, levels, internalformat, width, height, depth);
  OGLM_CHECK_ERR(glTextureStorage3DEXT, )

void
glTextureStorage3DMultisample(texture, samples, internalformat, width, height, depth, fixedsamplelocations)
  GLuint texture;
  GLsizei samples;
  GLenum internalformat;
  GLsizei width;
  GLsizei height;
  GLsizei depth;
  GLboolean fixedsamplelocations;
CODE:
  OGLM_GLEWINIT
  OGLM_CHECK_ERR(glTextureStorage3DMultisample, )
  OGLM_AVAIL_CHECK(__glewTextureStorage3DMultisample, glTextureStorage3DMultisample)
  glTextureStorage3DMultisample(texture, samples, internalformat, width, height, depth, fixedsamplelocations);
  OGLM_CHECK_ERR(glTextureStorage3DMultisample, )

void
glTextureStorage3DMultisampleEXT(texture, target, samples, internalformat, width, height, depth, fixedsamplelocations)
  GLuint texture;
  GLenum target;
  GLsizei samples;
  GLenum internalformat;
  GLsizei width;
  GLsizei height;
  GLsizei depth;
  GLboolean fixedsamplelocations;
CODE:
  OGLM_GLEWINIT
  OGLM_CHECK_ERR(glTextureStorage3DMultisampleEXT, )
  OGLM_AVAIL_CHECK(__glewTextureStorage3DMultisampleEXT, glTextureStorage3DMultisampleEXT)
  glTextureStorage3DMultisampleEXT(texture, target, samples, internalformat, width, height, depth, fixedsamplelocations);
  OGLM_CHECK_ERR(glTextureStorage3DMultisampleEXT, )

void
glTextureStorageMem1DEXT(texture, levels, internalFormat, width, memory, offset)
  GLuint texture;
  GLsizei levels;
  GLenum internalFormat;
  GLsizei width;
  GLuint memory;
  GLuint64 offset;
CODE:
  OGLM_GLEWINIT
  OGLM_CHECK_ERR(glTextureStorageMem1DEXT, )
  OGLM_AVAIL_CHECK(__glewTextureStorageMem1DEXT, glTextureStorageMem1DEXT)
  glTextureStorageMem1DEXT(texture, levels, internalFormat, width, memory, offset);
  OGLM_CHECK_ERR(glTextureStorageMem1DEXT, )

void
glTextureStorageMem2DEXT(texture, levels, internalFormat, width, height, memory, offset)
  GLuint texture;
  GLsizei levels;
  GLenum internalFormat;
  GLsizei width;
  GLsizei height;
  GLuint memory;
  GLuint64 offset;
CODE:
  OGLM_GLEWINIT
  OGLM_CHECK_ERR(glTextureStorageMem2DEXT, )
  OGLM_AVAIL_CHECK(__glewTextureStorageMem2DEXT, glTextureStorageMem2DEXT)
  glTextureStorageMem2DEXT(texture, levels, internalFormat, width, height, memory, offset);
  OGLM_CHECK_ERR(glTextureStorageMem2DEXT, )

void
glTextureStorageMem2DMultisampleEXT(texture, samples, internalFormat, width, height, fixedSampleLocations, memory, offset)
  GLuint texture;
  GLsizei samples;
  GLenum internalFormat;
  GLsizei width;
  GLsizei height;
  GLboolean fixedSampleLocations;
  GLuint memory;
  GLuint64 offset;
CODE:
  OGLM_GLEWINIT
  OGLM_CHECK_ERR(glTextureStorageMem2DMultisampleEXT, )
  OGLM_AVAIL_CHECK(__glewTextureStorageMem2DMultisampleEXT, glTextureStorageMem2DMultisampleEXT)
  glTextureStorageMem2DMultisampleEXT(texture, samples, internalFormat, width, height, fixedSampleLocations, memory, offset);
  OGLM_CHECK_ERR(glTextureStorageMem2DMultisampleEXT, )

void
glTextureStorageMem3DEXT(texture, levels, internalFormat, width, height, depth, memory, offset)
  GLuint texture;
  GLsizei levels;
  GLenum internalFormat;
  GLsizei width;
  GLsizei height;
  GLsizei depth;
  GLuint memory;
  GLuint64 offset;
CODE:
  OGLM_GLEWINIT
  OGLM_CHECK_ERR(glTextureStorageMem3DEXT, )
  OGLM_AVAIL_CHECK(__glewTextureStorageMem3DEXT, glTextureStorageMem3DEXT)
  glTextureStorageMem3DEXT(texture, levels, internalFormat, width, height, depth, memory, offset);
  OGLM_CHECK_ERR(glTextureStorageMem3DEXT, )

void
glTextureStorageMem3DMultisampleEXT(texture, samples, internalFormat, width, height, depth, fixedSampleLocations, memory, offset)
  GLuint texture;
  GLsizei samples;
  GLenum internalFormat;
  GLsizei width;
  GLsizei height;
  GLsizei depth;
  GLboolean fixedSampleLocations;
  GLuint memory;
  GLuint64 offset;
CODE:
  OGLM_GLEWINIT
  OGLM_CHECK_ERR(glTextureStorageMem3DMultisampleEXT, )
  OGLM_AVAIL_CHECK(__glewTextureStorageMem3DMultisampleEXT, glTextureStorageMem3DMultisampleEXT)
  glTextureStorageMem3DMultisampleEXT(texture, samples, internalFormat, width, height, depth, fixedSampleLocations, memory, offset);
  OGLM_CHECK_ERR(glTextureStorageMem3DMultisampleEXT, )

void
glTextureStorageSparseAMD(texture, target, internalFormat, width, height, depth, layers, flags)
  GLuint texture;
  GLenum target;
  GLenum internalFormat;
  GLsizei width;
  GLsizei height;
  GLsizei depth;
  GLsizei layers;
  GLbitfield flags;
CODE:
  OGLM_GLEWINIT
  OGLM_CHECK_ERR(glTextureStorageSparseAMD, )
  OGLM_AVAIL_CHECK(__glewTextureStorageSparseAMD, glTextureStorageSparseAMD)
  glTextureStorageSparseAMD(texture, target, internalFormat, width, height, depth, layers, flags);
  OGLM_CHECK_ERR(glTextureStorageSparseAMD, )

void
glTextureSubImage1D_c(texture, level, xoffset, width, format, type, pixels)
  GLuint texture;
  GLint level;
  GLint xoffset;
  GLsizei width;
  GLenum format;
  GLenum type;
  const void *pixels;
CODE:
  OGLM_GLEWINIT
  OGLM_CHECK_ERR(glTextureSubImage1D, )
  OGLM_AVAIL_CHECK(__glewTextureSubImage1D, glTextureSubImage1D)
  glTextureSubImage1D(texture, level, xoffset, width, format, type, pixels);
  OGLM_CHECK_ERR(glTextureSubImage1D, )

void
glTextureSubImage1DEXT_c(texture, target, level, xoffset, width, format, type, pixels)
  GLuint texture;
  GLenum target;
  GLint level;
  GLint xoffset;
  GLsizei width;
  GLenum format;
  GLenum type;
  const void *pixels;
CODE:
  OGLM_GLEWINIT
  OGLM_CHECK_ERR(glTextureSubImage1DEXT, )
  OGLM_AVAIL_CHECK(__glewTextureSubImage1DEXT, glTextureSubImage1DEXT)
  glTextureSubImage1DEXT(texture, target, level, xoffset, width, format, type, pixels);
  OGLM_CHECK_ERR(glTextureSubImage1DEXT, )

void
glTextureSubImage2D_c(texture, level, xoffset, yoffset, width, height, format, type, pixels)
  GLuint texture;
  GLint level;
  GLint xoffset;
  GLint yoffset;
  GLsizei width;
  GLsizei height;
  GLenum format;
  GLenum type;
  const void *pixels;
CODE:
  OGLM_GLEWINIT
  OGLM_CHECK_ERR(glTextureSubImage2D, )
  OGLM_AVAIL_CHECK(__glewTextureSubImage2D, glTextureSubImage2D)
  glTextureSubImage2D(texture, level, xoffset, yoffset, width, height, format, type, pixels);
  OGLM_CHECK_ERR(glTextureSubImage2D, )

void
glTextureSubImage2DEXT_c(texture, target, level, xoffset, yoffset, width, height, format, type, pixels)
  GLuint texture;
  GLenum target;
  GLint level;
  GLint xoffset;
  GLint yoffset;
  GLsizei width;
  GLsizei height;
  GLenum format;
  GLenum type;
  const void *pixels;
CODE:
  OGLM_GLEWINIT
  OGLM_CHECK_ERR(glTextureSubImage2DEXT, )
  OGLM_AVAIL_CHECK(__glewTextureSubImage2DEXT, glTextureSubImage2DEXT)
  glTextureSubImage2DEXT(texture, target, level, xoffset, yoffset, width, height, format, type, pixels);
  OGLM_CHECK_ERR(glTextureSubImage2DEXT, )

void
glTextureSubImage3D_c(texture, level, xoffset, yoffset, zoffset, width, height, depth, format, type, pixels)
  GLuint texture;
  GLint level;
  GLint xoffset;
  GLint yoffset;
  GLint zoffset;
  GLsizei width;
  GLsizei height;
  GLsizei depth;
  GLenum format;
  GLenum type;
  const void *pixels;
CODE:
  OGLM_GLEWINIT
  OGLM_CHECK_ERR(glTextureSubImage3D, )
  OGLM_AVAIL_CHECK(__glewTextureSubImage3D, glTextureSubImage3D)
  glTextureSubImage3D(texture, level, xoffset, yoffset, zoffset, width, height, depth, format, type, pixels);
  OGLM_CHECK_ERR(glTextureSubImage3D, )

void
glTextureSubImage3DEXT_c(texture, target, level, xoffset, yoffset, zoffset, width, height, depth, format, type, pixels)
  GLuint texture;
  GLenum target;
  GLint level;
  GLint xoffset;
  GLint yoffset;
  GLint zoffset;
  GLsizei width;
  GLsizei height;
  GLsizei depth;
  GLenum format;
  GLenum type;
  const void *pixels;
CODE:
  OGLM_GLEWINIT
  OGLM_CHECK_ERR(glTextureSubImage3DEXT, )
  OGLM_AVAIL_CHECK(__glewTextureSubImage3DEXT, glTextureSubImage3DEXT)
  glTextureSubImage3DEXT(texture, target, level, xoffset, yoffset, zoffset, width, height, depth, format, type, pixels);
  OGLM_CHECK_ERR(glTextureSubImage3DEXT, )

void
glTextureView(texture, target, origtexture, internalformat, minlevel, numlevels, minlayer, numlayers)
  GLuint texture;
  GLenum target;
  GLuint origtexture;
  GLenum internalformat;
  GLuint minlevel;
  GLuint numlevels;
  GLuint minlayer;
  GLuint numlayers;
ALIAS:
  glTextureViewEXT = 1
CODE:
  OGLM_GLEWINIT
  OGLM_CHECK_ERR(glTextureView, )
  OGLM_AVAIL_CHECK(__glewTextureView, glTextureView)
  glTextureView(texture, target, origtexture, internalformat, minlevel, numlevels, minlayer, numlayers);
  OGLM_CHECK_ERR(glTextureView, )

void
glTextureViewOES(texture, target, origtexture, internalformat, minlevel, numlevels, minlayer, numlayers)
  GLuint texture;
  GLenum target;
  GLuint origtexture;
  GLenum internalformat;
  GLuint minlevel;
  GLuint numlevels;
  GLuint minlayer;
  GLuint numlayers;
CODE:
  OGLM_GLEWINIT
  OGLM_CHECK_ERR(glTextureViewOES, )
  OGLM_AVAIL_CHECK(__glewTextureViewOES, glTextureViewOES)
  glTextureViewOES(texture, target, origtexture, internalformat, minlevel, numlevels, minlayer, numlayers);
  OGLM_CHECK_ERR(glTextureViewOES, )

void
glTrackMatrixNV(target, address, matrix, transform)
  GLenum target;
  GLuint address;
  GLenum matrix;
  GLenum transform;
CODE:
  OGLM_GLEWINIT
  OGLM_CHECK_ERR(glTrackMatrixNV, )
  OGLM_AVAIL_CHECK(__glewTrackMatrixNV, glTrackMatrixNV)
  glTrackMatrixNV(target, address, matrix, transform);
  OGLM_CHECK_ERR(glTrackMatrixNV, )

void
glTransformFeedbackAttribsNV_c(count, attribs, bufferMode)
  GLuint count;
  const GLint *attribs;
  GLenum bufferMode;
CODE:
  OGLM_GLEWINIT
  OGLM_CHECK_ERR(glTransformFeedbackAttribsNV, )
  OGLM_AVAIL_CHECK(__glewTransformFeedbackAttribsNV, glTransformFeedbackAttribsNV)
  glTransformFeedbackAttribsNV(count, attribs, bufferMode);
  OGLM_CHECK_ERR(glTransformFeedbackAttribsNV, )

void
glTransformFeedbackBufferBase(xfb, index, buffer)
  GLuint xfb;
  GLuint index;
  GLuint buffer;
CODE:
  OGLM_GLEWINIT
  OGLM_CHECK_ERR(glTransformFeedbackBufferBase, )
  OGLM_AVAIL_CHECK(__glewTransformFeedbackBufferBase, glTransformFeedbackBufferBase)
  glTransformFeedbackBufferBase(xfb, index, buffer);
  OGLM_CHECK_ERR(glTransformFeedbackBufferBase, )

void
glTransformFeedbackBufferRange(xfb, index, buffer, offset, size)
  GLuint xfb;
  GLuint index;
  GLuint buffer;
  GLintptr offset;
  GLsizeiptr size;
CODE:
  OGLM_GLEWINIT
  OGLM_CHECK_ERR(glTransformFeedbackBufferRange, )
  OGLM_AVAIL_CHECK(__glewTransformFeedbackBufferRange, glTransformFeedbackBufferRange)
  glTransformFeedbackBufferRange(xfb, index, buffer, offset, size);
  OGLM_CHECK_ERR(glTransformFeedbackBufferRange, )

void
glTransformFeedbackVaryings_c(program, count, varyings, bufferMode)
  GLuint program;
  GLsizei count;
  const GLchar *const* varyings;
  GLenum bufferMode;
ALIAS:
  glTransformFeedbackVaryingsEXT_c = 1
CODE:
  OGLM_GLEWINIT
  OGLM_CHECK_ERR(glTransformFeedbackVaryings, )
  OGLM_AVAIL_CHECK(__glewTransformFeedbackVaryings, glTransformFeedbackVaryings)
  glTransformFeedbackVaryings(program, count, varyings, bufferMode);
  OGLM_CHECK_ERR(glTransformFeedbackVaryings, )

void
glTransformFeedbackVaryings_p(program, bufferMode, ...)
  GLuint program;
  GLenum bufferMode;
ALIAS:
  glTransformFeedbackVaryingsEXT_p = 1
CODE:
  OGLM_GLEWINIT
  OGLM_CHECK_ERR(glTransformFeedbackVaryings, )
  OGLM_AVAIL_CHECK(__glewTransformFeedbackVaryings, glTransformFeedbackVaryings)
  GLsizei count = items-2;
  GLchar ** varyings = OGLM_GET_VARARGS(varyings,2,GLchar*,PV_nolen,count);
  glTransformFeedbackVaryings((GLuint )program, (GLsizei )count, (const GLchar *const* )varyings, (GLenum )bufferMode);
  OGLM_CHECK_ERR(glTransformFeedbackVaryings, free(varyings);)
  free(varyings);

void
glTransformFeedbackVaryingsNV_c(program, count, locations, bufferMode)
  GLuint program;
  GLsizei count;
  const GLint *locations;
  GLenum bufferMode;
CODE:
  OGLM_GLEWINIT
  OGLM_CHECK_ERR(glTransformFeedbackVaryingsNV, )
  OGLM_AVAIL_CHECK(__glewTransformFeedbackVaryingsNV, glTransformFeedbackVaryingsNV)
  glTransformFeedbackVaryingsNV(program, count, locations, bufferMode);
  OGLM_CHECK_ERR(glTransformFeedbackVaryingsNV, )

void
glTransformFeedbackVaryingsNV_p(program, bufferMode, ...)
  GLuint program;
  GLenum bufferMode;
CODE:
  OGLM_GLEWINIT
  OGLM_CHECK_ERR(glTransformFeedbackVaryingsNV, )
  OGLM_AVAIL_CHECK(__glewTransformFeedbackVaryingsNV, glTransformFeedbackVaryingsNV)
  GLsizei count = items-2;
  GLint *locations = OGLM_GET_VARARGS(locations,2,GLint,IV,count);
  glTransformFeedbackVaryingsNV((GLuint )program, (GLsizei )count, (const GLint *)locations, (GLenum )bufferMode);
  OGLM_CHECK_ERR(glTransformFeedbackVaryingsNV, free(locations);)
  free(locations);

void
glTransformPathNV_c(resultPath, srcPath, transformType, transformValues)
  GLuint resultPath;
  GLuint srcPath;
  GLenum transformType;
  const GLfloat* transformValues;
CODE:
  OGLM_GLEWINIT
  OGLM_CHECK_ERR(glTransformPathNV, )
  OGLM_AVAIL_CHECK(__glewTransformPathNV, glTransformPathNV)
  glTransformPathNV(resultPath, srcPath, transformType, transformValues);
  OGLM_CHECK_ERR(glTransformPathNV, )

void
glTranslated(x, y, z)
  GLdouble x;
  GLdouble y;
  GLdouble z;
CODE:
  OGLM_GLEWINIT
  OGLM_CHECK_ERR(glTranslated, )
  glTranslated(x, y, z);
  OGLM_CHECK_ERR(glTranslated, )

void
glTranslatef(x, y, z)
  GLfloat x;
  GLfloat y;
  GLfloat z;
CODE:
  OGLM_GLEWINIT
  OGLM_CHECK_ERR(glTranslatef, )
  glTranslatef(x, y, z);
  OGLM_CHECK_ERR(glTranslatef, )

void
glTranslatex(x, y, z)
  GLfixed x;
  GLfixed y;
  GLfixed z;
CODE:
  OGLM_GLEWINIT
  OGLM_CHECK_ERR(glTranslatex, )
  OGLM_AVAIL_CHECK(__glewTranslatex, glTranslatex)
  glTranslatex(x, y, z);
  OGLM_CHECK_ERR(glTranslatex, )

void
glUniform1d(location, x)
  GLint location;
  GLdouble x;
CODE:
  OGLM_GLEWINIT
  OGLM_CHECK_ERR(glUniform1d, )
  OGLM_AVAIL_CHECK(__glewUniform1d, glUniform1d)
  glUniform1d(location, x);
  OGLM_CHECK_ERR(glUniform1d, )

void
glUniform1dv_c(location, count, value)
  GLint location;
  GLsizei count;
  const GLdouble* value;
CODE:
  OGLM_GLEWINIT
  OGLM_CHECK_ERR(glUniform1dv, )
  OGLM_AVAIL_CHECK(__glewUniform1dv, glUniform1dv)
  glUniform1dv(location, count, value);
  OGLM_CHECK_ERR(glUniform1dv, )

void
glUniform1dv_p(location, count, ...)
  GLint location;
  GLsizei count;
CODE:
  OGLM_GLEWINIT
  OGLM_CHECK_ERR(glUniform1dv, )
  OGLM_AVAIL_CHECK(__glewUniform1dv, glUniform1dv)
  GLdouble* value = OGLM_GET_VARARGS(value,2,GLdouble,NV,count*1);
  glUniform1dv((GLint )location, (GLsizei )count, (const GLdouble* )value);
  OGLM_CHECK_ERR(glUniform1dv, free(value);)
  free(value);

void
glUniform1f(location, v0)
  GLint location;
  GLfloat v0;
ALIAS:
  glUniform1fARB = 1
CODE:
  OGLM_GLEWINIT
  OGLM_CHECK_ERR(glUniform1f, )
  OGLM_AVAIL_CHECK(__glewUniform1f, glUniform1f)
  glUniform1f(location, v0);
  OGLM_CHECK_ERR(glUniform1f, )

void
glUniform1fv_c(location, count, value)
  GLint location;
  GLsizei count;
  const GLfloat* value;
ALIAS:
  glUniform1fvARB_c = 1
CODE:
  OGLM_GLEWINIT
  OGLM_CHECK_ERR(glUniform1fv, )
  OGLM_AVAIL_CHECK(__glewUniform1fv, glUniform1fv)
  glUniform1fv(location, count, value);
  OGLM_CHECK_ERR(glUniform1fv, )

void
glUniform1fv_p(location, count, ...)
  GLint location;
  GLsizei count;
ALIAS:
  glUniform1fvARB_p = 1
CODE:
  OGLM_GLEWINIT
  OGLM_CHECK_ERR(glUniform1fv, )
  OGLM_AVAIL_CHECK(__glewUniform1fv, glUniform1fv)
  GLfloat* value = OGLM_GET_VARARGS(value,2,GLfloat,NV,count*1);
  glUniform1fv((GLint )location, (GLsizei )count, (const GLfloat* )value);
  OGLM_CHECK_ERR(glUniform1fv, free(value);)
  free(value);

void
glUniform1i(location, v0)
  GLint location;
  GLint v0;
ALIAS:
  glUniform1iARB = 1
CODE:
  OGLM_GLEWINIT
  OGLM_CHECK_ERR(glUniform1i, )
  OGLM_AVAIL_CHECK(__glewUniform1i, glUniform1i)
  glUniform1i(location, v0);
  OGLM_CHECK_ERR(glUniform1i, )

void
glUniform1i64ARB(location, x)
  GLint location;
  GLint64 x;
CODE:
  OGLM_GLEWINIT
  OGLM_CHECK_ERR(glUniform1i64ARB, )
  OGLM_AVAIL_CHECK(__glewUniform1i64ARB, glUniform1i64ARB)
  glUniform1i64ARB(location, x);
  OGLM_CHECK_ERR(glUniform1i64ARB, )

void
glUniform1i64NV(location, x)
  GLint location;
  GLint64EXT x;
CODE:
  OGLM_GLEWINIT
  OGLM_CHECK_ERR(glUniform1i64NV, )
  OGLM_AVAIL_CHECK(__glewUniform1i64NV, glUniform1i64NV)
  glUniform1i64NV(location, x);
  OGLM_CHECK_ERR(glUniform1i64NV, )

void
glUniform1i64vARB_c(location, count, value)
  GLint location;
  GLsizei count;
  const GLint64* value;
CODE:
  OGLM_GLEWINIT
  OGLM_CHECK_ERR(glUniform1i64vARB, )
  OGLM_AVAIL_CHECK(__glewUniform1i64vARB, glUniform1i64vARB)
  glUniform1i64vARB(location, count, value);
  OGLM_CHECK_ERR(glUniform1i64vARB, )

void
glUniform1i64vARB_p(location, count, ...)
  GLint location;
  GLsizei count;
CODE:
  OGLM_GLEWINIT
  OGLM_CHECK_ERR(glUniform1i64vARB, )
  OGLM_AVAIL_CHECK(__glewUniform1i64vARB, glUniform1i64vARB)
  GLint64* value = OGLM_GET_VARARGS(value,2,GLint64,IV,count*1);
  glUniform1i64vARB((GLint )location, (GLsizei )count, (const GLint64* )value);
  OGLM_CHECK_ERR(glUniform1i64vARB, free(value);)
  free(value);

void
glUniform1i64vNV_c(location, count, value)
  GLint location;
  GLsizei count;
  const GLint64EXT* value;
CODE:
  OGLM_GLEWINIT
  OGLM_CHECK_ERR(glUniform1i64vNV, )
  OGLM_AVAIL_CHECK(__glewUniform1i64vNV, glUniform1i64vNV)
  glUniform1i64vNV(location, count, value);
  OGLM_CHECK_ERR(glUniform1i64vNV, )

void
glUniform1i64vNV_p(location, count, ...)
  GLint location;
  GLsizei count;
CODE:
  OGLM_GLEWINIT
  OGLM_CHECK_ERR(glUniform1i64vNV, )
  OGLM_AVAIL_CHECK(__glewUniform1i64vNV, glUniform1i64vNV)
  GLint64EXT* value = OGLM_GET_VARARGS(value,2,GLint64EXT,IV,count*1);
  glUniform1i64vNV((GLint )location, (GLsizei )count, (const GLint64EXT* )value);
  OGLM_CHECK_ERR(glUniform1i64vNV, free(value);)
  free(value);

void
glUniform1iv_c(location, count, value)
  GLint location;
  GLsizei count;
  const GLint* value;
ALIAS:
  glUniform1ivARB_c = 1
CODE:
  OGLM_GLEWINIT
  OGLM_CHECK_ERR(glUniform1iv, )
  OGLM_AVAIL_CHECK(__glewUniform1iv, glUniform1iv)
  glUniform1iv(location, count, value);
  OGLM_CHECK_ERR(glUniform1iv, )

void
glUniform1iv_p(location, count, ...)
  GLint location;
  GLsizei count;
ALIAS:
  glUniform1ivARB_p = 1
CODE:
  OGLM_GLEWINIT
  OGLM_CHECK_ERR(glUniform1iv, )
  OGLM_AVAIL_CHECK(__glewUniform1iv, glUniform1iv)
  GLint* value = OGLM_GET_VARARGS(value,2,GLint,IV,count*1);
  glUniform1iv((GLint )location, (GLsizei )count, (const GLint* )value);
  OGLM_CHECK_ERR(glUniform1iv, free(value);)
  free(value);

void
glUniform1ui(location, v0)
  GLint location;
  GLuint v0;
ALIAS:
  glUniform1uiEXT = 1
CODE:
  OGLM_GLEWINIT
  OGLM_CHECK_ERR(glUniform1ui, )
  OGLM_AVAIL_CHECK(__glewUniform1ui, glUniform1ui)
  glUniform1ui(location, v0);
  OGLM_CHECK_ERR(glUniform1ui, )

void
glUniform1ui64ARB(location, x)
  GLint location;
  GLuint64 x;
CODE:
  OGLM_GLEWINIT
  OGLM_CHECK_ERR(glUniform1ui64ARB, )
  OGLM_AVAIL_CHECK(__glewUniform1ui64ARB, glUniform1ui64ARB)
  glUniform1ui64ARB(location, x);
  OGLM_CHECK_ERR(glUniform1ui64ARB, )

void
glUniform1ui64NV(location, x)
  GLint location;
  GLuint64EXT x;
CODE:
  OGLM_GLEWINIT
  OGLM_CHECK_ERR(glUniform1ui64NV, )
  OGLM_AVAIL_CHECK(__glewUniform1ui64NV, glUniform1ui64NV)
  glUniform1ui64NV(location, x);
  OGLM_CHECK_ERR(glUniform1ui64NV, )

void
glUniform1ui64vARB_c(location, count, value)
  GLint location;
  GLsizei count;
  const GLuint64* value;
CODE:
  OGLM_GLEWINIT
  OGLM_CHECK_ERR(glUniform1ui64vARB, )
  OGLM_AVAIL_CHECK(__glewUniform1ui64vARB, glUniform1ui64vARB)
  glUniform1ui64vARB(location, count, value);
  OGLM_CHECK_ERR(glUniform1ui64vARB, )

void
glUniform1ui64vARB_p(location, count, ...)
  GLint location;
  GLsizei count;
CODE:
  OGLM_GLEWINIT
  OGLM_CHECK_ERR(glUniform1ui64vARB, )
  OGLM_AVAIL_CHECK(__glewUniform1ui64vARB, glUniform1ui64vARB)
  GLuint64* value = OGLM_GET_VARARGS(value,2,GLuint64,UV,count*1);
  glUniform1ui64vARB((GLint )location, (GLsizei )count, (const GLuint64* )value);
  OGLM_CHECK_ERR(glUniform1ui64vARB, free(value);)
  free(value);

void
glUniform1ui64vNV_c(location, count, value)
  GLint location;
  GLsizei count;
  const GLuint64EXT* value;
CODE:
  OGLM_GLEWINIT
  OGLM_CHECK_ERR(glUniform1ui64vNV, )
  OGLM_AVAIL_CHECK(__glewUniform1ui64vNV, glUniform1ui64vNV)
  glUniform1ui64vNV(location, count, value);
  OGLM_CHECK_ERR(glUniform1ui64vNV, )

void
glUniform1ui64vNV_p(location, count, ...)
  GLint location;
  GLsizei count;
CODE:
  OGLM_GLEWINIT
  OGLM_CHECK_ERR(glUniform1ui64vNV, )
  OGLM_AVAIL_CHECK(__glewUniform1ui64vNV, glUniform1ui64vNV)
  GLuint64EXT* value = OGLM_GET_VARARGS(value,2,GLuint64EXT,UV,count*1);
  glUniform1ui64vNV((GLint )location, (GLsizei )count, (const GLuint64EXT* )value);
  OGLM_CHECK_ERR(glUniform1ui64vNV, free(value);)
  free(value);

void
glUniform1uiv_c(location, count, value)
  GLint location;
  GLsizei count;
  const GLuint* value;
ALIAS:
  glUniform1uivEXT_c = 1
CODE:
  OGLM_GLEWINIT
  OGLM_CHECK_ERR(glUniform1uiv, )
  OGLM_AVAIL_CHECK(__glewUniform1uiv, glUniform1uiv)
  glUniform1uiv(location, count, value);
  OGLM_CHECK_ERR(glUniform1uiv, )

void
glUniform1uiv_p(location, count, ...)
  GLint location;
  GLsizei count;
ALIAS:
  glUniform1uivEXT_p = 1
CODE:
  OGLM_GLEWINIT
  OGLM_CHECK_ERR(glUniform1uiv, )
  OGLM_AVAIL_CHECK(__glewUniform1uiv, glUniform1uiv)
  GLuint* value = OGLM_GET_VARARGS(value,2,GLuint,UV,count*1);
  glUniform1uiv((GLint )location, (GLsizei )count, (const GLuint* )value);
  OGLM_CHECK_ERR(glUniform1uiv, free(value);)
  free(value);

void
glUniform2d(location, x, y)
  GLint location;
  GLdouble x;
  GLdouble y;
CODE:
  OGLM_GLEWINIT
  OGLM_CHECK_ERR(glUniform2d, )
  OGLM_AVAIL_CHECK(__glewUniform2d, glUniform2d)
  glUniform2d(location, x, y);
  OGLM_CHECK_ERR(glUniform2d, )

void
glUniform2dv_c(location, count, value)
  GLint location;
  GLsizei count;
  const GLdouble* value;
CODE:
  OGLM_GLEWINIT
  OGLM_CHECK_ERR(glUniform2dv, )
  OGLM_AVAIL_CHECK(__glewUniform2dv, glUniform2dv)
  glUniform2dv(location, count, value);
  OGLM_CHECK_ERR(glUniform2dv, )

void
glUniform2dv_p(location, count, ...)
  GLint location;
  GLsizei count;
CODE:
  OGLM_GLEWINIT
  OGLM_CHECK_ERR(glUniform2dv, )
  OGLM_AVAIL_CHECK(__glewUniform2dv, glUniform2dv)
  GLdouble* value = OGLM_GET_VARARGS(value,2,GLdouble,NV,count*2);
  glUniform2dv((GLint )location, (GLsizei )count, (const GLdouble* )value);
  OGLM_CHECK_ERR(glUniform2dv, free(value);)
  free(value);

void
glUniform2f(location, v0, v1)
  GLint location;
  GLfloat v0;
  GLfloat v1;
ALIAS:
  glUniform2fARB = 1
CODE:
  OGLM_GLEWINIT
  OGLM_CHECK_ERR(glUniform2f, )
  OGLM_AVAIL_CHECK(__glewUniform2f, glUniform2f)
  glUniform2f(location, v0, v1);
  OGLM_CHECK_ERR(glUniform2f, )

void
glUniform2fv_c(location, count, value)
  GLint location;
  GLsizei count;
  const GLfloat* value;
ALIAS:
  glUniform2fvARB_c = 1
CODE:
  OGLM_GLEWINIT
  OGLM_CHECK_ERR(glUniform2fv, )
  OGLM_AVAIL_CHECK(__glewUniform2fv, glUniform2fv)
  glUniform2fv(location, count, value);
  OGLM_CHECK_ERR(glUniform2fv, )

void
glUniform2fv_p(location, count, ...)
  GLint location;
  GLsizei count;
ALIAS:
  glUniform2fvARB_p = 1
CODE:
  OGLM_GLEWINIT
  OGLM_CHECK_ERR(glUniform2fv, )
  OGLM_AVAIL_CHECK(__glewUniform2fv, glUniform2fv)
  GLfloat* value = OGLM_GET_VARARGS(value,2,GLfloat,NV,count*2);
  glUniform2fv((GLint )location, (GLsizei )count, (const GLfloat* )value);
  OGLM_CHECK_ERR(glUniform2fv, free(value);)
  free(value);

void
glUniform2i(location, v0, v1)
  GLint location;
  GLint v0;
  GLint v1;
ALIAS:
  glUniform2iARB = 1
CODE:
  OGLM_GLEWINIT
  OGLM_CHECK_ERR(glUniform2i, )
  OGLM_AVAIL_CHECK(__glewUniform2i, glUniform2i)
  glUniform2i(location, v0, v1);
  OGLM_CHECK_ERR(glUniform2i, )

void
glUniform2i64ARB(location, x, y)
  GLint location;
  GLint64 x;
  GLint64 y;
CODE:
  OGLM_GLEWINIT
  OGLM_CHECK_ERR(glUniform2i64ARB, )
  OGLM_AVAIL_CHECK(__glewUniform2i64ARB, glUniform2i64ARB)
  glUniform2i64ARB(location, x, y);
  OGLM_CHECK_ERR(glUniform2i64ARB, )

void
glUniform2i64NV(location, x, y)
  GLint location;
  GLint64EXT x;
  GLint64EXT y;
CODE:
  OGLM_GLEWINIT
  OGLM_CHECK_ERR(glUniform2i64NV, )
  OGLM_AVAIL_CHECK(__glewUniform2i64NV, glUniform2i64NV)
  glUniform2i64NV(location, x, y);
  OGLM_CHECK_ERR(glUniform2i64NV, )

void
glUniform2i64vARB_c(location, count, value)
  GLint location;
  GLsizei count;
  const GLint64* value;
CODE:
  OGLM_GLEWINIT
  OGLM_CHECK_ERR(glUniform2i64vARB, )
  OGLM_AVAIL_CHECK(__glewUniform2i64vARB, glUniform2i64vARB)
  glUniform2i64vARB(location, count, value);
  OGLM_CHECK_ERR(glUniform2i64vARB, )

void
glUniform2i64vARB_p(location, count, ...)
  GLint location;
  GLsizei count;
CODE:
  OGLM_GLEWINIT
  OGLM_CHECK_ERR(glUniform2i64vARB, )
  OGLM_AVAIL_CHECK(__glewUniform2i64vARB, glUniform2i64vARB)
  GLint64* value = OGLM_GET_VARARGS(value,2,GLint64,IV,count*2);
  glUniform2i64vARB((GLint )location, (GLsizei )count, (const GLint64* )value);
  OGLM_CHECK_ERR(glUniform2i64vARB, free(value);)
  free(value);

void
glUniform2i64vNV_c(location, count, value)
  GLint location;
  GLsizei count;
  const GLint64EXT* value;
CODE:
  OGLM_GLEWINIT
  OGLM_CHECK_ERR(glUniform2i64vNV, )
  OGLM_AVAIL_CHECK(__glewUniform2i64vNV, glUniform2i64vNV)
  glUniform2i64vNV(location, count, value);
  OGLM_CHECK_ERR(glUniform2i64vNV, )

void
glUniform2i64vNV_p(location, count, ...)
  GLint location;
  GLsizei count;
CODE:
  OGLM_GLEWINIT
  OGLM_CHECK_ERR(glUniform2i64vNV, )
  OGLM_AVAIL_CHECK(__glewUniform2i64vNV, glUniform2i64vNV)
  GLint64EXT* value = OGLM_GET_VARARGS(value,2,GLint64EXT,IV,count*2);
  glUniform2i64vNV((GLint )location, (GLsizei )count, (const GLint64EXT* )value);
  OGLM_CHECK_ERR(glUniform2i64vNV, free(value);)
  free(value);

void
glUniform2iv_c(location, count, value)
  GLint location;
  GLsizei count;
  const GLint* value;
ALIAS:
  glUniform2ivARB_c = 1
CODE:
  OGLM_GLEWINIT
  OGLM_CHECK_ERR(glUniform2iv, )
  OGLM_AVAIL_CHECK(__glewUniform2iv, glUniform2iv)
  glUniform2iv(location, count, value);
  OGLM_CHECK_ERR(glUniform2iv, )

void
glUniform2iv_p(location, count, ...)
  GLint location;
  GLsizei count;
ALIAS:
  glUniform2ivARB_p = 1
CODE:
  OGLM_GLEWINIT
  OGLM_CHECK_ERR(glUniform2iv, )
  OGLM_AVAIL_CHECK(__glewUniform2iv, glUniform2iv)
  GLint* value = OGLM_GET_VARARGS(value,2,GLint,IV,count*2);
  glUniform2iv((GLint )location, (GLsizei )count, (const GLint* )value);
  OGLM_CHECK_ERR(glUniform2iv, free(value);)
  free(value);

void
glUniform2ui(location, v0, v1)
  GLint location;
  GLuint v0;
  GLuint v1;
ALIAS:
  glUniform2uiEXT = 1
CODE:
  OGLM_GLEWINIT
  OGLM_CHECK_ERR(glUniform2ui, )
  OGLM_AVAIL_CHECK(__glewUniform2ui, glUniform2ui)
  glUniform2ui(location, v0, v1);
  OGLM_CHECK_ERR(glUniform2ui, )

void
glUniform2ui64ARB(location, x, y)
  GLint location;
  GLuint64 x;
  GLuint64 y;
CODE:
  OGLM_GLEWINIT
  OGLM_CHECK_ERR(glUniform2ui64ARB, )
  OGLM_AVAIL_CHECK(__glewUniform2ui64ARB, glUniform2ui64ARB)
  glUniform2ui64ARB(location, x, y);
  OGLM_CHECK_ERR(glUniform2ui64ARB, )

void
glUniform2ui64NV(location, x, y)
  GLint location;
  GLuint64EXT x;
  GLuint64EXT y;
CODE:
  OGLM_GLEWINIT
  OGLM_CHECK_ERR(glUniform2ui64NV, )
  OGLM_AVAIL_CHECK(__glewUniform2ui64NV, glUniform2ui64NV)
  glUniform2ui64NV(location, x, y);
  OGLM_CHECK_ERR(glUniform2ui64NV, )

void
glUniform2ui64vARB_c(location, count, value)
  GLint location;
  GLsizei count;
  const GLuint64* value;
CODE:
  OGLM_GLEWINIT
  OGLM_CHECK_ERR(glUniform2ui64vARB, )
  OGLM_AVAIL_CHECK(__glewUniform2ui64vARB, glUniform2ui64vARB)
  glUniform2ui64vARB(location, count, value);
  OGLM_CHECK_ERR(glUniform2ui64vARB, )

void
glUniform2ui64vARB_p(location, count, ...)
  GLint location;
  GLsizei count;
CODE:
  OGLM_GLEWINIT
  OGLM_CHECK_ERR(glUniform2ui64vARB, )
  OGLM_AVAIL_CHECK(__glewUniform2ui64vARB, glUniform2ui64vARB)
  GLuint64* value = OGLM_GET_VARARGS(value,2,GLuint64,UV,count*2);
  glUniform2ui64vARB((GLint )location, (GLsizei )count, (const GLuint64* )value);
  OGLM_CHECK_ERR(glUniform2ui64vARB, free(value);)
  free(value);

void
glUniform2ui64vNV_c(location, count, value)
  GLint location;
  GLsizei count;
  const GLuint64EXT* value;
CODE:
  OGLM_GLEWINIT
  OGLM_CHECK_ERR(glUniform2ui64vNV, )
  OGLM_AVAIL_CHECK(__glewUniform2ui64vNV, glUniform2ui64vNV)
  glUniform2ui64vNV(location, count, value);
  OGLM_CHECK_ERR(glUniform2ui64vNV, )

void
glUniform2ui64vNV_p(location, count, ...)
  GLint location;
  GLsizei count;
CODE:
  OGLM_GLEWINIT
  OGLM_CHECK_ERR(glUniform2ui64vNV, )
  OGLM_AVAIL_CHECK(__glewUniform2ui64vNV, glUniform2ui64vNV)
  GLuint64EXT* value = OGLM_GET_VARARGS(value,2,GLuint64EXT,UV,count*2);
  glUniform2ui64vNV((GLint )location, (GLsizei )count, (const GLuint64EXT* )value);
  OGLM_CHECK_ERR(glUniform2ui64vNV, free(value);)
  free(value);

void
glUniform2uiv_c(location, count, value)
  GLint location;
  GLsizei count;
  const GLuint* value;
ALIAS:
  glUniform2uivEXT_c = 1
CODE:
  OGLM_GLEWINIT
  OGLM_CHECK_ERR(glUniform2uiv, )
  OGLM_AVAIL_CHECK(__glewUniform2uiv, glUniform2uiv)
  glUniform2uiv(location, count, value);
  OGLM_CHECK_ERR(glUniform2uiv, )

void
glUniform2uiv_p(location, count, ...)
  GLint location;
  GLsizei count;
ALIAS:
  glUniform2uivEXT_p = 1
CODE:
  OGLM_GLEWINIT
  OGLM_CHECK_ERR(glUniform2uiv, )
  OGLM_AVAIL_CHECK(__glewUniform2uiv, glUniform2uiv)
  GLuint* value = OGLM_GET_VARARGS(value,2,GLuint,UV,count*2);
  glUniform2uiv((GLint )location, (GLsizei )count, (const GLuint* )value);
  OGLM_CHECK_ERR(glUniform2uiv, free(value);)
  free(value);

void
glUniform3d(location, x, y, z)
  GLint location;
  GLdouble x;
  GLdouble y;
  GLdouble z;
CODE:
  OGLM_GLEWINIT
  OGLM_CHECK_ERR(glUniform3d, )
  OGLM_AVAIL_CHECK(__glewUniform3d, glUniform3d)
  glUniform3d(location, x, y, z);
  OGLM_CHECK_ERR(glUniform3d, )

void
glUniform3dv_c(location, count, value)
  GLint location;
  GLsizei count;
  const GLdouble* value;
CODE:
  OGLM_GLEWINIT
  OGLM_CHECK_ERR(glUniform3dv, )
  OGLM_AVAIL_CHECK(__glewUniform3dv, glUniform3dv)
  glUniform3dv(location, count, value);
  OGLM_CHECK_ERR(glUniform3dv, )

void
glUniform3dv_p(location, count, ...)
  GLint location;
  GLsizei count;
CODE:
  OGLM_GLEWINIT
  OGLM_CHECK_ERR(glUniform3dv, )
  OGLM_AVAIL_CHECK(__glewUniform3dv, glUniform3dv)
  GLdouble* value = OGLM_GET_VARARGS(value,2,GLdouble,NV,count*3);
  glUniform3dv((GLint )location, (GLsizei )count, (const GLdouble* )value);
  OGLM_CHECK_ERR(glUniform3dv, free(value);)
  free(value);

void
glUniform3f(location, v0, v1, v2)
  GLint location;
  GLfloat v0;
  GLfloat v1;
  GLfloat v2;
ALIAS:
  glUniform3fARB = 1
CODE:
  OGLM_GLEWINIT
  OGLM_CHECK_ERR(glUniform3f, )
  OGLM_AVAIL_CHECK(__glewUniform3f, glUniform3f)
  glUniform3f(location, v0, v1, v2);
  OGLM_CHECK_ERR(glUniform3f, )

void
glUniform3fv_c(location, count, value)
  GLint location;
  GLsizei count;
  const GLfloat* value;
ALIAS:
  glUniform3fvARB_c = 1
CODE:
  OGLM_GLEWINIT
  OGLM_CHECK_ERR(glUniform3fv, )
  OGLM_AVAIL_CHECK(__glewUniform3fv, glUniform3fv)
  glUniform3fv(location, count, value);
  OGLM_CHECK_ERR(glUniform3fv, )

void
glUniform3fv_p(location, count, ...)
  GLint location;
  GLsizei count;
ALIAS:
  glUniform3fvARB_p = 1
CODE:
  OGLM_GLEWINIT
  OGLM_CHECK_ERR(glUniform3fv, )
  OGLM_AVAIL_CHECK(__glewUniform3fv, glUniform3fv)
  GLfloat* value = OGLM_GET_VARARGS(value,2,GLfloat,NV,count*3);
  glUniform3fv((GLint )location, (GLsizei )count, (const GLfloat* )value);
  OGLM_CHECK_ERR(glUniform3fv, free(value);)
  free(value);

void
glUniform3i(location, v0, v1, v2)
  GLint location;
  GLint v0;
  GLint v1;
  GLint v2;
ALIAS:
  glUniform3iARB = 1
CODE:
  OGLM_GLEWINIT
  OGLM_CHECK_ERR(glUniform3i, )
  OGLM_AVAIL_CHECK(__glewUniform3i, glUniform3i)
  glUniform3i(location, v0, v1, v2);
  OGLM_CHECK_ERR(glUniform3i, )

void
glUniform3i64ARB(location, x, y, z)
  GLint location;
  GLint64 x;
  GLint64 y;
  GLint64 z;
CODE:
  OGLM_GLEWINIT
  OGLM_CHECK_ERR(glUniform3i64ARB, )
  OGLM_AVAIL_CHECK(__glewUniform3i64ARB, glUniform3i64ARB)
  glUniform3i64ARB(location, x, y, z);
  OGLM_CHECK_ERR(glUniform3i64ARB, )

void
glUniform3i64NV(location, x, y, z)
  GLint location;
  GLint64EXT x;
  GLint64EXT y;
  GLint64EXT z;
CODE:
  OGLM_GLEWINIT
  OGLM_CHECK_ERR(glUniform3i64NV, )
  OGLM_AVAIL_CHECK(__glewUniform3i64NV, glUniform3i64NV)
  glUniform3i64NV(location, x, y, z);
  OGLM_CHECK_ERR(glUniform3i64NV, )

void
glUniform3i64vARB_c(location, count, value)
  GLint location;
  GLsizei count;
  const GLint64* value;
CODE:
  OGLM_GLEWINIT
  OGLM_CHECK_ERR(glUniform3i64vARB, )
  OGLM_AVAIL_CHECK(__glewUniform3i64vARB, glUniform3i64vARB)
  glUniform3i64vARB(location, count, value);
  OGLM_CHECK_ERR(glUniform3i64vARB, )

void
glUniform3i64vARB_p(location, count, ...)
  GLint location;
  GLsizei count;
CODE:
  OGLM_GLEWINIT
  OGLM_CHECK_ERR(glUniform3i64vARB, )
  OGLM_AVAIL_CHECK(__glewUniform3i64vARB, glUniform3i64vARB)
  GLint64* value = OGLM_GET_VARARGS(value,2,GLint64,IV,count*3);
  glUniform3i64vARB((GLint )location, (GLsizei )count, (const GLint64* )value);
  OGLM_CHECK_ERR(glUniform3i64vARB, free(value);)
  free(value);

void
glUniform3i64vNV_c(location, count, value)
  GLint location;
  GLsizei count;
  const GLint64EXT* value;
CODE:
  OGLM_GLEWINIT
  OGLM_CHECK_ERR(glUniform3i64vNV, )
  OGLM_AVAIL_CHECK(__glewUniform3i64vNV, glUniform3i64vNV)
  glUniform3i64vNV(location, count, value);
  OGLM_CHECK_ERR(glUniform3i64vNV, )

void
glUniform3i64vNV_p(location, count, ...)
  GLint location;
  GLsizei count;
CODE:
  OGLM_GLEWINIT
  OGLM_CHECK_ERR(glUniform3i64vNV, )
  OGLM_AVAIL_CHECK(__glewUniform3i64vNV, glUniform3i64vNV)
  GLint64EXT* value = OGLM_GET_VARARGS(value,2,GLint64EXT,IV,count*3);
  glUniform3i64vNV((GLint )location, (GLsizei )count, (const GLint64EXT* )value);
  OGLM_CHECK_ERR(glUniform3i64vNV, free(value);)
  free(value);

void
glUniform3iv_c(location, count, value)
  GLint location;
  GLsizei count;
  const GLint* value;
ALIAS:
  glUniform3ivARB_c = 1
CODE:
  OGLM_GLEWINIT
  OGLM_CHECK_ERR(glUniform3iv, )
  OGLM_AVAIL_CHECK(__glewUniform3iv, glUniform3iv)
  glUniform3iv(location, count, value);
  OGLM_CHECK_ERR(glUniform3iv, )

void
glUniform3iv_p(location, count, ...)
  GLint location;
  GLsizei count;
ALIAS:
  glUniform3ivARB_p = 1
CODE:
  OGLM_GLEWINIT
  OGLM_CHECK_ERR(glUniform3iv, )
  OGLM_AVAIL_CHECK(__glewUniform3iv, glUniform3iv)
  GLint* value = OGLM_GET_VARARGS(value,2,GLint,IV,count*3);
  glUniform3iv((GLint )location, (GLsizei )count, (const GLint* )value);
  OGLM_CHECK_ERR(glUniform3iv, free(value);)
  free(value);

void
glUniform3ui(location, v0, v1, v2)
  GLint location;
  GLuint v0;
  GLuint v1;
  GLuint v2;
ALIAS:
  glUniform3uiEXT = 1
CODE:
  OGLM_GLEWINIT
  OGLM_CHECK_ERR(glUniform3ui, )
  OGLM_AVAIL_CHECK(__glewUniform3ui, glUniform3ui)
  glUniform3ui(location, v0, v1, v2);
  OGLM_CHECK_ERR(glUniform3ui, )

void
glUniform3ui64ARB(location, x, y, z)
  GLint location;
  GLuint64 x;
  GLuint64 y;
  GLuint64 z;
CODE:
  OGLM_GLEWINIT
  OGLM_CHECK_ERR(glUniform3ui64ARB, )
  OGLM_AVAIL_CHECK(__glewUniform3ui64ARB, glUniform3ui64ARB)
  glUniform3ui64ARB(location, x, y, z);
  OGLM_CHECK_ERR(glUniform3ui64ARB, )

void
glUniform3ui64NV(location, x, y, z)
  GLint location;
  GLuint64EXT x;
  GLuint64EXT y;
  GLuint64EXT z;
CODE:
  OGLM_GLEWINIT
  OGLM_CHECK_ERR(glUniform3ui64NV, )
  OGLM_AVAIL_CHECK(__glewUniform3ui64NV, glUniform3ui64NV)
  glUniform3ui64NV(location, x, y, z);
  OGLM_CHECK_ERR(glUniform3ui64NV, )

void
glUniform3ui64vARB_c(location, count, value)
  GLint location;
  GLsizei count;
  const GLuint64* value;
CODE:
  OGLM_GLEWINIT
  OGLM_CHECK_ERR(glUniform3ui64vARB, )
  OGLM_AVAIL_CHECK(__glewUniform3ui64vARB, glUniform3ui64vARB)
  glUniform3ui64vARB(location, count, value);
  OGLM_CHECK_ERR(glUniform3ui64vARB, )

void
glUniform3ui64vARB_p(location, count, ...)
  GLint location;
  GLsizei count;
CODE:
  OGLM_GLEWINIT
  OGLM_CHECK_ERR(glUniform3ui64vARB, )
  OGLM_AVAIL_CHECK(__glewUniform3ui64vARB, glUniform3ui64vARB)
  GLuint64* value = OGLM_GET_VARARGS(value,2,GLuint64,UV,count*3);
  glUniform3ui64vARB((GLint )location, (GLsizei )count, (const GLuint64* )value);
  OGLM_CHECK_ERR(glUniform3ui64vARB, free(value);)
  free(value);

void
glUniform3ui64vNV_c(location, count, value)
  GLint location;
  GLsizei count;
  const GLuint64EXT* value;
CODE:
  OGLM_GLEWINIT
  OGLM_CHECK_ERR(glUniform3ui64vNV, )
  OGLM_AVAIL_CHECK(__glewUniform3ui64vNV, glUniform3ui64vNV)
  glUniform3ui64vNV(location, count, value);
  OGLM_CHECK_ERR(glUniform3ui64vNV, )

void
glUniform3ui64vNV_p(location, count, ...)
  GLint location;
  GLsizei count;
CODE:
  OGLM_GLEWINIT
  OGLM_CHECK_ERR(glUniform3ui64vNV, )
  OGLM_AVAIL_CHECK(__glewUniform3ui64vNV, glUniform3ui64vNV)
  GLuint64EXT* value = OGLM_GET_VARARGS(value,2,GLuint64EXT,UV,count*3);
  glUniform3ui64vNV((GLint )location, (GLsizei )count, (const GLuint64EXT* )value);
  OGLM_CHECK_ERR(glUniform3ui64vNV, free(value);)
  free(value);

void
glUniform3uiv_c(location, count, value)
  GLint location;
  GLsizei count;
  const GLuint* value;
ALIAS:
  glUniform3uivEXT_c = 1
CODE:
  OGLM_GLEWINIT
  OGLM_CHECK_ERR(glUniform3uiv, )
  OGLM_AVAIL_CHECK(__glewUniform3uiv, glUniform3uiv)
  glUniform3uiv(location, count, value);
  OGLM_CHECK_ERR(glUniform3uiv, )

void
glUniform3uiv_p(location, count, ...)
  GLint location;
  GLsizei count;
ALIAS:
  glUniform3uivEXT_p = 1
CODE:
  OGLM_GLEWINIT
  OGLM_CHECK_ERR(glUniform3uiv, )
  OGLM_AVAIL_CHECK(__glewUniform3uiv, glUniform3uiv)
  GLuint* value = OGLM_GET_VARARGS(value,2,GLuint,UV,count*3);
  glUniform3uiv((GLint )location, (GLsizei )count, (const GLuint* )value);
  OGLM_CHECK_ERR(glUniform3uiv, free(value);)
  free(value);

void
glUniform4d(location, x, y, z, w)
  GLint location;
  GLdouble x;
  GLdouble y;
  GLdouble z;
  GLdouble w;
CODE:
  OGLM_GLEWINIT
  OGLM_CHECK_ERR(glUniform4d, )
  OGLM_AVAIL_CHECK(__glewUniform4d, glUniform4d)
  glUniform4d(location, x, y, z, w);
  OGLM_CHECK_ERR(glUniform4d, )

void
glUniform4dv_c(location, count, value)
  GLint location;
  GLsizei count;
  const GLdouble* value;
CODE:
  OGLM_GLEWINIT
  OGLM_CHECK_ERR(glUniform4dv, )
  OGLM_AVAIL_CHECK(__glewUniform4dv, glUniform4dv)
  glUniform4dv(location, count, value);
  OGLM_CHECK_ERR(glUniform4dv, )

void
glUniform4dv_p(location, count, ...)
  GLint location;
  GLsizei count;
CODE:
  OGLM_GLEWINIT
  OGLM_CHECK_ERR(glUniform4dv, )
  OGLM_AVAIL_CHECK(__glewUniform4dv, glUniform4dv)
  GLdouble* value = OGLM_GET_VARARGS(value,2,GLdouble,NV,count*4);
  glUniform4dv((GLint )location, (GLsizei )count, (const GLdouble* )value);
  OGLM_CHECK_ERR(glUniform4dv, free(value);)
  free(value);

void
glUniform4f(location, v0, v1, v2, v3)
  GLint location;
  GLfloat v0;
  GLfloat v1;
  GLfloat v2;
  GLfloat v3;
ALIAS:
  glUniform4fARB = 1
CODE:
  OGLM_GLEWINIT
  OGLM_CHECK_ERR(glUniform4f, )
  OGLM_AVAIL_CHECK(__glewUniform4f, glUniform4f)
  glUniform4f(location, v0, v1, v2, v3);
  OGLM_CHECK_ERR(glUniform4f, )

void
glUniform4fv_c(location, count, value)
  GLint location;
  GLsizei count;
  const GLfloat* value;
ALIAS:
  glUniform4fvARB_c = 1
CODE:
  OGLM_GLEWINIT
  OGLM_CHECK_ERR(glUniform4fv, )
  OGLM_AVAIL_CHECK(__glewUniform4fv, glUniform4fv)
  glUniform4fv(location, count, value);
  OGLM_CHECK_ERR(glUniform4fv, )

void
glUniform4fv_p(location, count, ...)
  GLint location;
  GLsizei count;
ALIAS:
  glUniform4fvARB_p = 1
CODE:
  OGLM_GLEWINIT
  OGLM_CHECK_ERR(glUniform4fv, )
  OGLM_AVAIL_CHECK(__glewUniform4fv, glUniform4fv)
  GLfloat* value = OGLM_GET_VARARGS(value,2,GLfloat,NV,count*4);
  glUniform4fv((GLint )location, (GLsizei )count, (const GLfloat* )value);
  OGLM_CHECK_ERR(glUniform4fv, free(value);)
  free(value);

void
glUniform4i(location, v0, v1, v2, v3)
  GLint location;
  GLint v0;
  GLint v1;
  GLint v2;
  GLint v3;
ALIAS:
  glUniform4iARB = 1
CODE:
  OGLM_GLEWINIT
  OGLM_CHECK_ERR(glUniform4i, )
  OGLM_AVAIL_CHECK(__glewUniform4i, glUniform4i)
  glUniform4i(location, v0, v1, v2, v3);
  OGLM_CHECK_ERR(glUniform4i, )

void
glUniform4i64ARB(location, x, y, z, w)
  GLint location;
  GLint64 x;
  GLint64 y;
  GLint64 z;
  GLint64 w;
CODE:
  OGLM_GLEWINIT
  OGLM_CHECK_ERR(glUniform4i64ARB, )
  OGLM_AVAIL_CHECK(__glewUniform4i64ARB, glUniform4i64ARB)
  glUniform4i64ARB(location, x, y, z, w);
  OGLM_CHECK_ERR(glUniform4i64ARB, )

void
glUniform4i64NV(location, x, y, z, w)
  GLint location;
  GLint64EXT x;
  GLint64EXT y;
  GLint64EXT z;
  GLint64EXT w;
CODE:
  OGLM_GLEWINIT
  OGLM_CHECK_ERR(glUniform4i64NV, )
  OGLM_AVAIL_CHECK(__glewUniform4i64NV, glUniform4i64NV)
  glUniform4i64NV(location, x, y, z, w);
  OGLM_CHECK_ERR(glUniform4i64NV, )

void
glUniform4i64vARB_c(location, count, value)
  GLint location;
  GLsizei count;
  const GLint64* value;
CODE:
  OGLM_GLEWINIT
  OGLM_CHECK_ERR(glUniform4i64vARB, )
  OGLM_AVAIL_CHECK(__glewUniform4i64vARB, glUniform4i64vARB)
  glUniform4i64vARB(location, count, value);
  OGLM_CHECK_ERR(glUniform4i64vARB, )

void
glUniform4i64vARB_p(location, count, ...)
  GLint location;
  GLsizei count;
CODE:
  OGLM_GLEWINIT
  OGLM_CHECK_ERR(glUniform4i64vARB, )
  OGLM_AVAIL_CHECK(__glewUniform4i64vARB, glUniform4i64vARB)
  GLint64* value = OGLM_GET_VARARGS(value,2,GLint64,IV,count*4);
  glUniform4i64vARB((GLint )location, (GLsizei )count, (const GLint64* )value);
  OGLM_CHECK_ERR(glUniform4i64vARB, free(value);)
  free(value);

void
glUniform4i64vNV_c(location, count, value)
  GLint location;
  GLsizei count;
  const GLint64EXT* value;
CODE:
  OGLM_GLEWINIT
  OGLM_CHECK_ERR(glUniform4i64vNV, )
  OGLM_AVAIL_CHECK(__glewUniform4i64vNV, glUniform4i64vNV)
  glUniform4i64vNV(location, count, value);
  OGLM_CHECK_ERR(glUniform4i64vNV, )

void
glUniform4i64vNV_p(location, count, ...)
  GLint location;
  GLsizei count;
CODE:
  OGLM_GLEWINIT
  OGLM_CHECK_ERR(glUniform4i64vNV, )
  OGLM_AVAIL_CHECK(__glewUniform4i64vNV, glUniform4i64vNV)
  GLint64EXT* value = OGLM_GET_VARARGS(value,2,GLint64EXT,IV,count*4);
  glUniform4i64vNV((GLint )location, (GLsizei )count, (const GLint64EXT* )value);
  OGLM_CHECK_ERR(glUniform4i64vNV, free(value);)
  free(value);

void
glUniform4iv_c(location, count, value)
  GLint location;
  GLsizei count;
  const GLint* value;
ALIAS:
  glUniform4ivARB_c = 1
CODE:
  OGLM_GLEWINIT
  OGLM_CHECK_ERR(glUniform4iv, )
  OGLM_AVAIL_CHECK(__glewUniform4iv, glUniform4iv)
  glUniform4iv(location, count, value);
  OGLM_CHECK_ERR(glUniform4iv, )

void
glUniform4iv_p(location, count, ...)
  GLint location;
  GLsizei count;
ALIAS:
  glUniform4ivARB_p = 1
CODE:
  OGLM_GLEWINIT
  OGLM_CHECK_ERR(glUniform4iv, )
  OGLM_AVAIL_CHECK(__glewUniform4iv, glUniform4iv)
  GLint* value = OGLM_GET_VARARGS(value,2,GLint,IV,count*4);
  glUniform4iv((GLint )location, (GLsizei )count, (const GLint* )value);
  OGLM_CHECK_ERR(glUniform4iv, free(value);)
  free(value);

void
glUniform4ui(location, v0, v1, v2, v3)
  GLint location;
  GLuint v0;
  GLuint v1;
  GLuint v2;
  GLuint v3;
ALIAS:
  glUniform4uiEXT = 1
CODE:
  OGLM_GLEWINIT
  OGLM_CHECK_ERR(glUniform4ui, )
  OGLM_AVAIL_CHECK(__glewUniform4ui, glUniform4ui)
  glUniform4ui(location, v0, v1, v2, v3);
  OGLM_CHECK_ERR(glUniform4ui, )

void
glUniform4ui64ARB(location, x, y, z, w)
  GLint location;
  GLuint64 x;
  GLuint64 y;
  GLuint64 z;
  GLuint64 w;
CODE:
  OGLM_GLEWINIT
  OGLM_CHECK_ERR(glUniform4ui64ARB, )
  OGLM_AVAIL_CHECK(__glewUniform4ui64ARB, glUniform4ui64ARB)
  glUniform4ui64ARB(location, x, y, z, w);
  OGLM_CHECK_ERR(glUniform4ui64ARB, )

void
glUniform4ui64NV(location, x, y, z, w)
  GLint location;
  GLuint64EXT x;
  GLuint64EXT y;
  GLuint64EXT z;
  GLuint64EXT w;
CODE:
  OGLM_GLEWINIT
  OGLM_CHECK_ERR(glUniform4ui64NV, )
  OGLM_AVAIL_CHECK(__glewUniform4ui64NV, glUniform4ui64NV)
  glUniform4ui64NV(location, x, y, z, w);
  OGLM_CHECK_ERR(glUniform4ui64NV, )

void
glUniform4ui64vARB_c(location, count, value)
  GLint location;
  GLsizei count;
  const GLuint64* value;
CODE:
  OGLM_GLEWINIT
  OGLM_CHECK_ERR(glUniform4ui64vARB, )
  OGLM_AVAIL_CHECK(__glewUniform4ui64vARB, glUniform4ui64vARB)
  glUniform4ui64vARB(location, count, value);
  OGLM_CHECK_ERR(glUniform4ui64vARB, )

void
glUniform4ui64vARB_p(location, count, ...)
  GLint location;
  GLsizei count;
CODE:
  OGLM_GLEWINIT
  OGLM_CHECK_ERR(glUniform4ui64vARB, )
  OGLM_AVAIL_CHECK(__glewUniform4ui64vARB, glUniform4ui64vARB)
  GLuint64* value = OGLM_GET_VARARGS(value,2,GLuint64,UV,count*4);
  glUniform4ui64vARB((GLint )location, (GLsizei )count, (const GLuint64* )value);
  OGLM_CHECK_ERR(glUniform4ui64vARB, free(value);)
  free(value);

void
glUniform4ui64vNV_c(location, count, value)
  GLint location;
  GLsizei count;
  const GLuint64EXT* value;
CODE:
  OGLM_GLEWINIT
  OGLM_CHECK_ERR(glUniform4ui64vNV, )
  OGLM_AVAIL_CHECK(__glewUniform4ui64vNV, glUniform4ui64vNV)
  glUniform4ui64vNV(location, count, value);
  OGLM_CHECK_ERR(glUniform4ui64vNV, )

void
glUniform4ui64vNV_p(location, count, ...)
  GLint location;
  GLsizei count;
CODE:
  OGLM_GLEWINIT
  OGLM_CHECK_ERR(glUniform4ui64vNV, )
  OGLM_AVAIL_CHECK(__glewUniform4ui64vNV, glUniform4ui64vNV)
  GLuint64EXT* value = OGLM_GET_VARARGS(value,2,GLuint64EXT,UV,count*4);
  glUniform4ui64vNV((GLint )location, (GLsizei )count, (const GLuint64EXT* )value);
  OGLM_CHECK_ERR(glUniform4ui64vNV, free(value);)
  free(value);

void
glUniform4uiv_c(location, count, value)
  GLint location;
  GLsizei count;
  const GLuint* value;
ALIAS:
  glUniform4uivEXT_c = 1
CODE:
  OGLM_GLEWINIT
  OGLM_CHECK_ERR(glUniform4uiv, )
  OGLM_AVAIL_CHECK(__glewUniform4uiv, glUniform4uiv)
  glUniform4uiv(location, count, value);
  OGLM_CHECK_ERR(glUniform4uiv, )

void
glUniform4uiv_p(location, count, ...)
  GLint location;
  GLsizei count;
ALIAS:
  glUniform4uivEXT_p = 1
CODE:
  OGLM_GLEWINIT
  OGLM_CHECK_ERR(glUniform4uiv, )
  OGLM_AVAIL_CHECK(__glewUniform4uiv, glUniform4uiv)
  GLuint* value = OGLM_GET_VARARGS(value,2,GLuint,UV,count*4);
  glUniform4uiv((GLint )location, (GLsizei )count, (const GLuint* )value);
  OGLM_CHECK_ERR(glUniform4uiv, free(value);)
  free(value);

void
glUniformBlockBinding(program, uniformBlockIndex, uniformBlockBinding)
  GLuint program;
  GLuint uniformBlockIndex;
  GLuint uniformBlockBinding;
CODE:
  OGLM_GLEWINIT
  OGLM_CHECK_ERR(glUniformBlockBinding, )
  OGLM_AVAIL_CHECK(__glewUniformBlockBinding, glUniformBlockBinding)
  glUniformBlockBinding(program, uniformBlockIndex, uniformBlockBinding);
  OGLM_CHECK_ERR(glUniformBlockBinding, )

void
glUniformBufferEXT(program, location, buffer)
  GLuint program;
  GLint location;
  GLuint buffer;
CODE:
  OGLM_GLEWINIT
  OGLM_CHECK_ERR(glUniformBufferEXT, )
  OGLM_AVAIL_CHECK(__glewUniformBufferEXT, glUniformBufferEXT)
  glUniformBufferEXT(program, location, buffer);
  OGLM_CHECK_ERR(glUniformBufferEXT, )

void
glUniformHandleui64ARB(location, value)
  GLint location;
  GLuint64 value;
ALIAS:
  glUniformHandleui64IMG = 1
CODE:
  OGLM_GLEWINIT
  OGLM_CHECK_ERR(glUniformHandleui64ARB, )
  OGLM_AVAIL_CHECK(__glewUniformHandleui64ARB, glUniformHandleui64ARB)
  glUniformHandleui64ARB(location, value);
  OGLM_CHECK_ERR(glUniformHandleui64ARB, )

void
glUniformHandleui64NV(location, value)
  GLint location;
  GLuint64 value;
CODE:
  OGLM_GLEWINIT
  OGLM_CHECK_ERR(glUniformHandleui64NV, )
  OGLM_AVAIL_CHECK(__glewUniformHandleui64NV, glUniformHandleui64NV)
  glUniformHandleui64NV(location, value);
  OGLM_CHECK_ERR(glUniformHandleui64NV, )

void
glUniformHandleui64vARB_c(location, count, value)
  GLint location;
  GLsizei count;
  const GLuint64* value;
ALIAS:
  glUniformHandleui64vIMG_c = 1
CODE:
  OGLM_GLEWINIT
  OGLM_CHECK_ERR(glUniformHandleui64vARB, )
  OGLM_AVAIL_CHECK(__glewUniformHandleui64vARB, glUniformHandleui64vARB)
  glUniformHandleui64vARB(location, count, value);
  OGLM_CHECK_ERR(glUniformHandleui64vARB, )

void
glUniformHandleui64vARB_p(location, ...)
  GLint location;
ALIAS:
  glUniformHandleui64vIMG_p = 1
CODE:
  OGLM_GLEWINIT
  OGLM_CHECK_ERR(glUniformHandleui64vARB, )
  OGLM_AVAIL_CHECK(__glewUniformHandleui64vARB, glUniformHandleui64vARB)
  GLsizei count = items-1;
  GLuint64* value = OGLM_GET_VARARGS(value,1,GLuint64,UV,count);
  glUniformHandleui64vARB((GLint )location, (GLsizei )count, (const GLuint64* )value);
  OGLM_CHECK_ERR(glUniformHandleui64vARB, free(value);)
  free(value);

void
glUniformHandleui64vNV_c(location, count, value)
  GLint location;
  GLsizei count;
  const GLuint64* value;
CODE:
  OGLM_GLEWINIT
  OGLM_CHECK_ERR(glUniformHandleui64vNV, )
  OGLM_AVAIL_CHECK(__glewUniformHandleui64vNV, glUniformHandleui64vNV)
  glUniformHandleui64vNV(location, count, value);
  OGLM_CHECK_ERR(glUniformHandleui64vNV, )

void
glUniformHandleui64vNV_p(location, ...)
  GLint location;
CODE:
  OGLM_GLEWINIT
  OGLM_CHECK_ERR(glUniformHandleui64vNV, )
  OGLM_AVAIL_CHECK(__glewUniformHandleui64vNV, glUniformHandleui64vNV)
  GLsizei count = items-1;
  GLuint64* value = OGLM_GET_VARARGS(value,1,GLuint64,UV,count);
  glUniformHandleui64vNV((GLint )location, (GLsizei )count, (const GLuint64* )value);
  OGLM_CHECK_ERR(glUniformHandleui64vNV, free(value);)
  free(value);

void
glUniformMatrix2dv_c(location, count, transpose, value)
  GLint location;
  GLsizei count;
  GLboolean transpose;
  const GLdouble* value;
CODE:
  OGLM_GLEWINIT
  OGLM_CHECK_ERR(glUniformMatrix2dv, )
  OGLM_AVAIL_CHECK(__glewUniformMatrix2dv, glUniformMatrix2dv)
  glUniformMatrix2dv(location, count, transpose, value);
  OGLM_CHECK_ERR(glUniformMatrix2dv, )

void
glUniformMatrix2dv_p(location, count, transpose, ...)
  GLint location;
  GLsizei count;
  GLboolean transpose;
CODE:
  OGLM_GLEWINIT
  OGLM_CHECK_ERR(glUniformMatrix2dv, )
  OGLM_AVAIL_CHECK(__glewUniformMatrix2dv, glUniformMatrix2dv)
  GLdouble* value = OGLM_GET_VARARGS(value,3,GLdouble,NV,count*4);
  glUniformMatrix2dv((GLint )location, (GLsizei )count, (GLboolean )transpose, (const GLdouble* )value);
  OGLM_CHECK_ERR(glUniformMatrix2dv, free(value);)
  free(value);

void
glUniformMatrix2fv_c(location, count, transpose, value)
  GLint location;
  GLsizei count;
  GLboolean transpose;
  const GLfloat* value;
ALIAS:
  glUniformMatrix2fvARB_c = 1
CODE:
  OGLM_GLEWINIT
  OGLM_CHECK_ERR(glUniformMatrix2fv, )
  OGLM_AVAIL_CHECK(__glewUniformMatrix2fv, glUniformMatrix2fv)
  glUniformMatrix2fv(location, count, transpose, value);
  OGLM_CHECK_ERR(glUniformMatrix2fv, )

void
glUniformMatrix2fv_p(location, count, transpose, ...)
  GLint location;
  GLsizei count;
  GLboolean transpose;
ALIAS:
  glUniformMatrix2fvARB_p = 1
CODE:
  OGLM_GLEWINIT
  OGLM_CHECK_ERR(glUniformMatrix2fv, )
  OGLM_AVAIL_CHECK(__glewUniformMatrix2fv, glUniformMatrix2fv)
  GLfloat* value = OGLM_GET_VARARGS(value,3,GLfloat,NV,count*4);
  glUniformMatrix2fv((GLint )location, (GLsizei )count, (GLboolean )transpose, (const GLfloat* )value);
  OGLM_CHECK_ERR(glUniformMatrix2fv, free(value);)
  free(value);

void
glUniformMatrix2x3dv_c(location, count, transpose, value)
  GLint location;
  GLsizei count;
  GLboolean transpose;
  const GLdouble* value;
CODE:
  OGLM_GLEWINIT
  OGLM_CHECK_ERR(glUniformMatrix2x3dv, )
  OGLM_AVAIL_CHECK(__glewUniformMatrix2x3dv, glUniformMatrix2x3dv)
  glUniformMatrix2x3dv(location, count, transpose, value);
  OGLM_CHECK_ERR(glUniformMatrix2x3dv, )

void
glUniformMatrix2x3dv_p(location, count, transpose, ...)
  GLint location;
  GLsizei count;
  GLboolean transpose;
CODE:
  OGLM_GLEWINIT
  OGLM_CHECK_ERR(glUniformMatrix2x3dv, )
  OGLM_AVAIL_CHECK(__glewUniformMatrix2x3dv, glUniformMatrix2x3dv)
  GLdouble* value = OGLM_GET_VARARGS(value,3,GLdouble,NV,count*6);
  glUniformMatrix2x3dv((GLint )location, (GLsizei )count, (GLboolean )transpose, (const GLdouble* )value);
  OGLM_CHECK_ERR(glUniformMatrix2x3dv, free(value);)
  free(value);

void
glUniformMatrix2x3fv_c(location, count, transpose, value)
  GLint location;
  GLsizei count;
  GLboolean transpose;
  const GLfloat *value;
ALIAS:
  glUniformMatrix2x3fvNV_c = 1
CODE:
  OGLM_GLEWINIT
  OGLM_CHECK_ERR(glUniformMatrix2x3fv, )
  OGLM_AVAIL_CHECK(__glewUniformMatrix2x3fv, glUniformMatrix2x3fv)
  glUniformMatrix2x3fv(location, count, transpose, value);
  OGLM_CHECK_ERR(glUniformMatrix2x3fv, )

void
glUniformMatrix2x3fv_p(location, count, transpose, ...)
  GLint location;
  GLsizei count;
  GLboolean transpose;
ALIAS:
  glUniformMatrix2x3fvNV_p = 1
CODE:
  OGLM_GLEWINIT
  OGLM_CHECK_ERR(glUniformMatrix2x3fv, )
  OGLM_AVAIL_CHECK(__glewUniformMatrix2x3fv, glUniformMatrix2x3fv)
  GLfloat *value = OGLM_GET_VARARGS(value,3,GLfloat,NV,count*6);
  glUniformMatrix2x3fv((GLint )location, (GLsizei )count, (GLboolean )transpose, (const GLfloat *)value);
  OGLM_CHECK_ERR(glUniformMatrix2x3fv, free(value);)
  free(value);

void
glUniformMatrix2x4dv_c(location, count, transpose, value)
  GLint location;
  GLsizei count;
  GLboolean transpose;
  const GLdouble* value;
CODE:
  OGLM_GLEWINIT
  OGLM_CHECK_ERR(glUniformMatrix2x4dv, )
  OGLM_AVAIL_CHECK(__glewUniformMatrix2x4dv, glUniformMatrix2x4dv)
  glUniformMatrix2x4dv(location, count, transpose, value);
  OGLM_CHECK_ERR(glUniformMatrix2x4dv, )

void
glUniformMatrix2x4dv_p(location, count, transpose, ...)
  GLint location;
  GLsizei count;
  GLboolean transpose;
CODE:
  OGLM_GLEWINIT
  OGLM_CHECK_ERR(glUniformMatrix2x4dv, )
  OGLM_AVAIL_CHECK(__glewUniformMatrix2x4dv, glUniformMatrix2x4dv)
  GLdouble* value = OGLM_GET_VARARGS(value,3,GLdouble,NV,count*8);
  glUniformMatrix2x4dv((GLint )location, (GLsizei )count, (GLboolean )transpose, (const GLdouble* )value);
  OGLM_CHECK_ERR(glUniformMatrix2x4dv, free(value);)
  free(value);

void
glUniformMatrix2x4fv_c(location, count, transpose, value)
  GLint location;
  GLsizei count;
  GLboolean transpose;
  const GLfloat *value;
ALIAS:
  glUniformMatrix2x4fvNV_c = 1
CODE:
  OGLM_GLEWINIT
  OGLM_CHECK_ERR(glUniformMatrix2x4fv, )
  OGLM_AVAIL_CHECK(__glewUniformMatrix2x4fv, glUniformMatrix2x4fv)
  glUniformMatrix2x4fv(location, count, transpose, value);
  OGLM_CHECK_ERR(glUniformMatrix2x4fv, )

void
glUniformMatrix2x4fv_p(location, count, transpose, ...)
  GLint location;
  GLsizei count;
  GLboolean transpose;
ALIAS:
  glUniformMatrix2x4fvNV_p = 1
CODE:
  OGLM_GLEWINIT
  OGLM_CHECK_ERR(glUniformMatrix2x4fv, )
  OGLM_AVAIL_CHECK(__glewUniformMatrix2x4fv, glUniformMatrix2x4fv)
  GLfloat *value = OGLM_GET_VARARGS(value,3,GLfloat,NV,count*8);
  glUniformMatrix2x4fv((GLint )location, (GLsizei )count, (GLboolean )transpose, (const GLfloat *)value);
  OGLM_CHECK_ERR(glUniformMatrix2x4fv, free(value);)
  free(value);

void
glUniformMatrix3dv_c(location, count, transpose, value)
  GLint location;
  GLsizei count;
  GLboolean transpose;
  const GLdouble* value;
CODE:
  OGLM_GLEWINIT
  OGLM_CHECK_ERR(glUniformMatrix3dv, )
  OGLM_AVAIL_CHECK(__glewUniformMatrix3dv, glUniformMatrix3dv)
  glUniformMatrix3dv(location, count, transpose, value);
  OGLM_CHECK_ERR(glUniformMatrix3dv, )

void
glUniformMatrix3dv_p(location, count, transpose, ...)
  GLint location;
  GLsizei count;
  GLboolean transpose;
CODE:
  OGLM_GLEWINIT
  OGLM_CHECK_ERR(glUniformMatrix3dv, )
  OGLM_AVAIL_CHECK(__glewUniformMatrix3dv, glUniformMatrix3dv)
  GLdouble* value = OGLM_GET_VARARGS(value,3,GLdouble,NV,count*9);
  glUniformMatrix3dv((GLint )location, (GLsizei )count, (GLboolean )transpose, (const GLdouble* )value);
  OGLM_CHECK_ERR(glUniformMatrix3dv, free(value);)
  free(value);

void
glUniformMatrix3fv_c(location, count, transpose, value)
  GLint location;
  GLsizei count;
  GLboolean transpose;
  const GLfloat* value;
ALIAS:
  glUniformMatrix3fvARB_c = 1
CODE:
  OGLM_GLEWINIT
  OGLM_CHECK_ERR(glUniformMatrix3fv, )
  OGLM_AVAIL_CHECK(__glewUniformMatrix3fv, glUniformMatrix3fv)
  glUniformMatrix3fv(location, count, transpose, value);
  OGLM_CHECK_ERR(glUniformMatrix3fv, )

void
glUniformMatrix3fv_p(location, count, transpose, ...)
  GLint location;
  GLsizei count;
  GLboolean transpose;
ALIAS:
  glUniformMatrix3fvARB_p = 1
CODE:
  OGLM_GLEWINIT
  OGLM_CHECK_ERR(glUniformMatrix3fv, )
  OGLM_AVAIL_CHECK(__glewUniformMatrix3fv, glUniformMatrix3fv)
  GLfloat* value = OGLM_GET_VARARGS(value,3,GLfloat,NV,count*9);
  glUniformMatrix3fv((GLint )location, (GLsizei )count, (GLboolean )transpose, (const GLfloat* )value);
  OGLM_CHECK_ERR(glUniformMatrix3fv, free(value);)
  free(value);

void
glUniformMatrix3x2dv_c(location, count, transpose, value)
  GLint location;
  GLsizei count;
  GLboolean transpose;
  const GLdouble* value;
CODE:
  OGLM_GLEWINIT
  OGLM_CHECK_ERR(glUniformMatrix3x2dv, )
  OGLM_AVAIL_CHECK(__glewUniformMatrix3x2dv, glUniformMatrix3x2dv)
  glUniformMatrix3x2dv(location, count, transpose, value);
  OGLM_CHECK_ERR(glUniformMatrix3x2dv, )

void
glUniformMatrix3x2dv_p(location, count, transpose, ...)
  GLint location;
  GLsizei count;
  GLboolean transpose;
CODE:
  OGLM_GLEWINIT
  OGLM_CHECK_ERR(glUniformMatrix3x2dv, )
  OGLM_AVAIL_CHECK(__glewUniformMatrix3x2dv, glUniformMatrix3x2dv)
  GLdouble* value = OGLM_GET_VARARGS(value,3,GLdouble,NV,count*6);
  glUniformMatrix3x2dv((GLint )location, (GLsizei )count, (GLboolean )transpose, (const GLdouble* )value);
  OGLM_CHECK_ERR(glUniformMatrix3x2dv, free(value);)
  free(value);

void
glUniformMatrix3x2fv_c(location, count, transpose, value)
  GLint location;
  GLsizei count;
  GLboolean transpose;
  const GLfloat *value;
ALIAS:
  glUniformMatrix3x2fvNV_c = 1
CODE:
  OGLM_GLEWINIT
  OGLM_CHECK_ERR(glUniformMatrix3x2fv, )
  OGLM_AVAIL_CHECK(__glewUniformMatrix3x2fv, glUniformMatrix3x2fv)
  glUniformMatrix3x2fv(location, count, transpose, value);
  OGLM_CHECK_ERR(glUniformMatrix3x2fv, )

void
glUniformMatrix3x2fv_p(location, count, transpose, ...)
  GLint location;
  GLsizei count;
  GLboolean transpose;
ALIAS:
  glUniformMatrix3x2fvNV_p = 1
CODE:
  OGLM_GLEWINIT
  OGLM_CHECK_ERR(glUniformMatrix3x2fv, )
  OGLM_AVAIL_CHECK(__glewUniformMatrix3x2fv, glUniformMatrix3x2fv)
  GLfloat *value = OGLM_GET_VARARGS(value,3,GLfloat,NV,count*6);
  glUniformMatrix3x2fv((GLint )location, (GLsizei )count, (GLboolean )transpose, (const GLfloat *)value);
  OGLM_CHECK_ERR(glUniformMatrix3x2fv, free(value);)
  free(value);

void
glUniformMatrix3x4dv_c(location, count, transpose, value)
  GLint location;
  GLsizei count;
  GLboolean transpose;
  const GLdouble* value;
CODE:
  OGLM_GLEWINIT
  OGLM_CHECK_ERR(glUniformMatrix3x4dv, )
  OGLM_AVAIL_CHECK(__glewUniformMatrix3x4dv, glUniformMatrix3x4dv)
  glUniformMatrix3x4dv(location, count, transpose, value);
  OGLM_CHECK_ERR(glUniformMatrix3x4dv, )

void
glUniformMatrix3x4dv_p(location, count, transpose, ...)
  GLint location;
  GLsizei count;
  GLboolean transpose;
CODE:
  OGLM_GLEWINIT
  OGLM_CHECK_ERR(glUniformMatrix3x4dv, )
  OGLM_AVAIL_CHECK(__glewUniformMatrix3x4dv, glUniformMatrix3x4dv)
  GLdouble* value = OGLM_GET_VARARGS(value,3,GLdouble,NV,count*12);
  glUniformMatrix3x4dv((GLint )location, (GLsizei )count, (GLboolean )transpose, (const GLdouble* )value);
  OGLM_CHECK_ERR(glUniformMatrix3x4dv, free(value);)
  free(value);

void
glUniformMatrix3x4fv_c(location, count, transpose, value)
  GLint location;
  GLsizei count;
  GLboolean transpose;
  const GLfloat *value;
ALIAS:
  glUniformMatrix3x4fvNV_c = 1
CODE:
  OGLM_GLEWINIT
  OGLM_CHECK_ERR(glUniformMatrix3x4fv, )
  OGLM_AVAIL_CHECK(__glewUniformMatrix3x4fv, glUniformMatrix3x4fv)
  glUniformMatrix3x4fv(location, count, transpose, value);
  OGLM_CHECK_ERR(glUniformMatrix3x4fv, )

void
glUniformMatrix3x4fv_p(location, count, transpose, ...)
  GLint location;
  GLsizei count;
  GLboolean transpose;
ALIAS:
  glUniformMatrix3x4fvNV_p = 1
CODE:
  OGLM_GLEWINIT
  OGLM_CHECK_ERR(glUniformMatrix3x4fv, )
  OGLM_AVAIL_CHECK(__glewUniformMatrix3x4fv, glUniformMatrix3x4fv)
  GLfloat *value = OGLM_GET_VARARGS(value,3,GLfloat,NV,count*12);
  glUniformMatrix3x4fv((GLint )location, (GLsizei )count, (GLboolean )transpose, (const GLfloat *)value);
  OGLM_CHECK_ERR(glUniformMatrix3x4fv, free(value);)
  free(value);

void
glUniformMatrix4dv_c(location, count, transpose, value)
  GLint location;
  GLsizei count;
  GLboolean transpose;
  const GLdouble* value;
CODE:
  OGLM_GLEWINIT
  OGLM_CHECK_ERR(glUniformMatrix4dv, )
  OGLM_AVAIL_CHECK(__glewUniformMatrix4dv, glUniformMatrix4dv)
  glUniformMatrix4dv(location, count, transpose, value);
  OGLM_CHECK_ERR(glUniformMatrix4dv, )

void
glUniformMatrix4dv_p(location, count, transpose, ...)
  GLint location;
  GLsizei count;
  GLboolean transpose;
CODE:
  OGLM_GLEWINIT
  OGLM_CHECK_ERR(glUniformMatrix4dv, )
  OGLM_AVAIL_CHECK(__glewUniformMatrix4dv, glUniformMatrix4dv)
  GLdouble* value = OGLM_GET_VARARGS(value,3,GLdouble,NV,count*16);
  glUniformMatrix4dv((GLint )location, (GLsizei )count, (GLboolean )transpose, (const GLdouble* )value);
  OGLM_CHECK_ERR(glUniformMatrix4dv, free(value);)
  free(value);

void
glUniformMatrix4fv_c(location, count, transpose, value)
  GLint location;
  GLsizei count;
  GLboolean transpose;
  const GLfloat* value;
ALIAS:
  glUniformMatrix4fvARB_c = 1
CODE:
  OGLM_GLEWINIT
  OGLM_CHECK_ERR(glUniformMatrix4fv, )
  OGLM_AVAIL_CHECK(__glewUniformMatrix4fv, glUniformMatrix4fv)
  glUniformMatrix4fv(location, count, transpose, value);
  OGLM_CHECK_ERR(glUniformMatrix4fv, )

void
glUniformMatrix4fv_p(location, count, transpose, ...)
  GLint location;
  GLsizei count;
  GLboolean transpose;
ALIAS:
  glUniformMatrix4fvARB_p = 1
CODE:
  OGLM_GLEWINIT
  OGLM_CHECK_ERR(glUniformMatrix4fv, )
  OGLM_AVAIL_CHECK(__glewUniformMatrix4fv, glUniformMatrix4fv)
  GLfloat* value = OGLM_GET_VARARGS(value,3,GLfloat,NV,count*16);
  glUniformMatrix4fv((GLint )location, (GLsizei )count, (GLboolean )transpose, (const GLfloat* )value);
  OGLM_CHECK_ERR(glUniformMatrix4fv, free(value);)
  free(value);

void
glUniformMatrix4x2dv_c(location, count, transpose, value)
  GLint location;
  GLsizei count;
  GLboolean transpose;
  const GLdouble* value;
CODE:
  OGLM_GLEWINIT
  OGLM_CHECK_ERR(glUniformMatrix4x2dv, )
  OGLM_AVAIL_CHECK(__glewUniformMatrix4x2dv, glUniformMatrix4x2dv)
  glUniformMatrix4x2dv(location, count, transpose, value);
  OGLM_CHECK_ERR(glUniformMatrix4x2dv, )

void
glUniformMatrix4x2dv_p(location, count, transpose, ...)
  GLint location;
  GLsizei count;
  GLboolean transpose;
CODE:
  OGLM_GLEWINIT
  OGLM_CHECK_ERR(glUniformMatrix4x2dv, )
  OGLM_AVAIL_CHECK(__glewUniformMatrix4x2dv, glUniformMatrix4x2dv)
  GLdouble* value = OGLM_GET_VARARGS(value,3,GLdouble,NV,count*8);
  glUniformMatrix4x2dv((GLint )location, (GLsizei )count, (GLboolean )transpose, (const GLdouble* )value);
  OGLM_CHECK_ERR(glUniformMatrix4x2dv, free(value);)
  free(value);

void
glUniformMatrix4x2fv_c(location, count, transpose, value)
  GLint location;
  GLsizei count;
  GLboolean transpose;
  const GLfloat *value;
ALIAS:
  glUniformMatrix4x2fvNV_c = 1
CODE:
  OGLM_GLEWINIT
  OGLM_CHECK_ERR(glUniformMatrix4x2fv, )
  OGLM_AVAIL_CHECK(__glewUniformMatrix4x2fv, glUniformMatrix4x2fv)
  glUniformMatrix4x2fv(location, count, transpose, value);
  OGLM_CHECK_ERR(glUniformMatrix4x2fv, )

void
glUniformMatrix4x2fv_p(location, count, transpose, ...)
  GLint location;
  GLsizei count;
  GLboolean transpose;
ALIAS:
  glUniformMatrix4x2fvNV_p = 1
CODE:
  OGLM_GLEWINIT
  OGLM_CHECK_ERR(glUniformMatrix4x2fv, )
  OGLM_AVAIL_CHECK(__glewUniformMatrix4x2fv, glUniformMatrix4x2fv)
  GLfloat *value = OGLM_GET_VARARGS(value,3,GLfloat,NV,count*8);
  glUniformMatrix4x2fv((GLint )location, (GLsizei )count, (GLboolean )transpose, (const GLfloat *)value);
  OGLM_CHECK_ERR(glUniformMatrix4x2fv, free(value);)
  free(value);

void
glUniformMatrix4x3dv_c(location, count, transpose, value)
  GLint location;
  GLsizei count;
  GLboolean transpose;
  const GLdouble* value;
CODE:
  OGLM_GLEWINIT
  OGLM_CHECK_ERR(glUniformMatrix4x3dv, )
  OGLM_AVAIL_CHECK(__glewUniformMatrix4x3dv, glUniformMatrix4x3dv)
  glUniformMatrix4x3dv(location, count, transpose, value);
  OGLM_CHECK_ERR(glUniformMatrix4x3dv, )

void
glUniformMatrix4x3dv_p(location, count, transpose, ...)
  GLint location;
  GLsizei count;
  GLboolean transpose;
CODE:
  OGLM_GLEWINIT
  OGLM_CHECK_ERR(glUniformMatrix4x3dv, )
  OGLM_AVAIL_CHECK(__glewUniformMatrix4x3dv, glUniformMatrix4x3dv)
  GLdouble* value = OGLM_GET_VARARGS(value,3,GLdouble,NV,count*12);
  glUniformMatrix4x3dv((GLint )location, (GLsizei )count, (GLboolean )transpose, (const GLdouble* )value);
  OGLM_CHECK_ERR(glUniformMatrix4x3dv, free(value);)
  free(value);

void
glUniformMatrix4x3fv_c(location, count, transpose, value)
  GLint location;
  GLsizei count;
  GLboolean transpose;
  const GLfloat *value;
ALIAS:
  glUniformMatrix4x3fvNV_c = 1
CODE:
  OGLM_GLEWINIT
  OGLM_CHECK_ERR(glUniformMatrix4x3fv, )
  OGLM_AVAIL_CHECK(__glewUniformMatrix4x3fv, glUniformMatrix4x3fv)
  glUniformMatrix4x3fv(location, count, transpose, value);
  OGLM_CHECK_ERR(glUniformMatrix4x3fv, )

void
glUniformMatrix4x3fv_p(location, count, transpose, ...)
  GLint location;
  GLsizei count;
  GLboolean transpose;
ALIAS:
  glUniformMatrix4x3fvNV_p = 1
CODE:
  OGLM_GLEWINIT
  OGLM_CHECK_ERR(glUniformMatrix4x3fv, )
  OGLM_AVAIL_CHECK(__glewUniformMatrix4x3fv, glUniformMatrix4x3fv)
  GLfloat *value = OGLM_GET_VARARGS(value,3,GLfloat,NV,count*12);
  glUniformMatrix4x3fv((GLint )location, (GLsizei )count, (GLboolean )transpose, (const GLfloat *)value);
  OGLM_CHECK_ERR(glUniformMatrix4x3fv, free(value);)
  free(value);

void
glUniformSubroutinesuiv_c(shadertype, count, indices)
  GLenum shadertype;
  GLsizei count;
  const GLuint* indices;
CODE:
  OGLM_GLEWINIT
  OGLM_CHECK_ERR(glUniformSubroutinesuiv, )
  OGLM_AVAIL_CHECK(__glewUniformSubroutinesuiv, glUniformSubroutinesuiv)
  glUniformSubroutinesuiv(shadertype, count, indices);
  OGLM_CHECK_ERR(glUniformSubroutinesuiv, )

void
glUniformSubroutinesuiv_p(shadertype, ...)
  GLenum shadertype;
CODE:
  OGLM_GLEWINIT
  OGLM_CHECK_ERR(glUniformSubroutinesuiv, )
  OGLM_AVAIL_CHECK(__glewUniformSubroutinesuiv, glUniformSubroutinesuiv)
  GLsizei count = items-1;
  GLuint* indices = OGLM_GET_VARARGS(indices,1,GLuint,UV,count);
  glUniformSubroutinesuiv((GLenum )shadertype, (GLsizei )count, (const GLuint* )indices);
  OGLM_CHECK_ERR(glUniformSubroutinesuiv, free(indices);)
  free(indices);

void
glUniformui64NV(location, value)
  GLint location;
  GLuint64EXT value;
CODE:
  OGLM_GLEWINIT
  OGLM_CHECK_ERR(glUniformui64NV, )
  OGLM_AVAIL_CHECK(__glewUniformui64NV, glUniformui64NV)
  glUniformui64NV(location, value);
  OGLM_CHECK_ERR(glUniformui64NV, )

void
glUniformui64vNV_c(location, count, value)
  GLint location;
  GLsizei count;
  const GLuint64EXT* value;
CODE:
  OGLM_GLEWINIT
  OGLM_CHECK_ERR(glUniformui64vNV, )
  OGLM_AVAIL_CHECK(__glewUniformui64vNV, glUniformui64vNV)
  glUniformui64vNV(location, count, value);
  OGLM_CHECK_ERR(glUniformui64vNV, )

void
glUniformui64vNV_p(location, count, ...)
  GLint location;
  GLsizei count;
CODE:
  OGLM_GLEWINIT
  OGLM_CHECK_ERR(glUniformui64vNV, )
  OGLM_AVAIL_CHECK(__glewUniformui64vNV, glUniformui64vNV)
  GLuint64EXT* value = OGLM_GET_VARARGS(value,2,GLuint64EXT,UV,count*1);
  glUniformui64vNV((GLint )location, (GLsizei )count, (const GLuint64EXT* )value);
  OGLM_CHECK_ERR(glUniformui64vNV, free(value);)
  free(value);

void
glUnlockArraysEXT()
CODE:
  OGLM_GLEWINIT
  OGLM_CHECK_ERR(glUnlockArraysEXT, )
  OGLM_AVAIL_CHECK(__glewUnlockArraysEXT, glUnlockArraysEXT)
  glUnlockArraysEXT();
  OGLM_CHECK_ERR(glUnlockArraysEXT, )

GLboolean
glUnmapBuffer(target)
  GLenum target;
ALIAS:
  glUnmapBufferARB = 1
CODE:
  OGLM_GLEWINIT
  OGLM_CHECK_ERR(glUnmapBuffer, )
  OGLM_AVAIL_CHECK(__glewUnmapBuffer, glUnmapBuffer)
  RETVAL = glUnmapBuffer(target);
  OGLM_CHECK_ERR(glUnmapBuffer, )
OUTPUT:
  RETVAL

GLboolean
glUnmapBufferOES(target)
  GLenum target;
CODE:
  OGLM_GLEWINIT
  OGLM_CHECK_ERR(glUnmapBufferOES, )
  OGLM_AVAIL_CHECK(__glewUnmapBufferOES, glUnmapBufferOES)
  RETVAL = glUnmapBufferOES(target);
  OGLM_CHECK_ERR(glUnmapBufferOES, )
OUTPUT:
  RETVAL

GLboolean
glUnmapNamedBuffer(buffer)
  GLuint buffer;
CODE:
  OGLM_GLEWINIT
  OGLM_CHECK_ERR(glUnmapNamedBuffer, )
  OGLM_AVAIL_CHECK(__glewUnmapNamedBuffer, glUnmapNamedBuffer)
  RETVAL = glUnmapNamedBuffer(buffer);
  OGLM_CHECK_ERR(glUnmapNamedBuffer, )
OUTPUT:
  RETVAL

GLboolean
glUnmapNamedBufferEXT(buffer)
  GLuint buffer;
CODE:
  OGLM_GLEWINIT
  OGLM_CHECK_ERR(glUnmapNamedBufferEXT, )
  OGLM_AVAIL_CHECK(__glewUnmapNamedBufferEXT, glUnmapNamedBufferEXT)
  RETVAL = glUnmapNamedBufferEXT(buffer);
  OGLM_CHECK_ERR(glUnmapNamedBufferEXT, )
OUTPUT:
  RETVAL

void
glUnmapObjectBufferATI(buffer)
  GLuint buffer;
CODE:
  OGLM_GLEWINIT
  OGLM_CHECK_ERR(glUnmapObjectBufferATI, )
  OGLM_AVAIL_CHECK(__glewUnmapObjectBufferATI, glUnmapObjectBufferATI)
  glUnmapObjectBufferATI(buffer);
  OGLM_CHECK_ERR(glUnmapObjectBufferATI, )

void
glUnmapTexture2DINTEL(texture, level)
  GLuint texture;
  GLint level;
CODE:
  OGLM_GLEWINIT
  OGLM_CHECK_ERR(glUnmapTexture2DINTEL, )
  OGLM_AVAIL_CHECK(__glewUnmapTexture2DINTEL, glUnmapTexture2DINTEL)
  glUnmapTexture2DINTEL(texture, level);
  OGLM_CHECK_ERR(glUnmapTexture2DINTEL, )

void
glUpdateObjectBufferATI_c(buffer, offset, size, pointer, preserve)
  GLuint buffer;
  GLuint offset;
  GLsizei size;
  const void *pointer;
  GLenum preserve;
CODE:
  OGLM_GLEWINIT
  OGLM_CHECK_ERR(glUpdateObjectBufferATI, )
  OGLM_AVAIL_CHECK(__glewUpdateObjectBufferATI, glUpdateObjectBufferATI)
  glUpdateObjectBufferATI(buffer, offset, size, pointer, preserve);
  OGLM_CHECK_ERR(glUpdateObjectBufferATI, )

void
glUploadGpuMaskNVX(mask)
  GLbitfield mask;
CODE:
  OGLM_GLEWINIT
  OGLM_CHECK_ERR(glUploadGpuMaskNVX, )
  OGLM_AVAIL_CHECK(__glewUploadGpuMaskNVX, glUploadGpuMaskNVX)
  glUploadGpuMaskNVX(mask);
  OGLM_CHECK_ERR(glUploadGpuMaskNVX, )

void
glUseProgram(program)
  GLuint program;
CODE:
  OGLM_GLEWINIT
  OGLM_CHECK_ERR(glUseProgram, )
  OGLM_AVAIL_CHECK(__glewUseProgram, glUseProgram)
  glUseProgram(program);
  OGLM_CHECK_ERR(glUseProgram, )

void
glUseProgramObjectARB(programObj)
  GLhandleARB programObj;
CODE:
  OGLM_GLEWINIT
  OGLM_CHECK_ERR(glUseProgramObjectARB, )
  OGLM_AVAIL_CHECK(__glewUseProgramObjectARB, glUseProgramObjectARB)
  glUseProgramObjectARB(programObj);
  OGLM_CHECK_ERR(glUseProgramObjectARB, )

void
glUseProgramStages(pipeline, stages, program)
  GLuint pipeline;
  GLbitfield stages;
  GLuint program;
CODE:
  OGLM_GLEWINIT
  OGLM_CHECK_ERR(glUseProgramStages, )
  OGLM_AVAIL_CHECK(__glewUseProgramStages, glUseProgramStages)
  glUseProgramStages(pipeline, stages, program);
  OGLM_CHECK_ERR(glUseProgramStages, )

void
glUseShaderProgramEXT(type, program)
  GLenum type;
  GLuint program;
CODE:
  OGLM_GLEWINIT
  OGLM_CHECK_ERR(glUseShaderProgramEXT, )
  OGLM_AVAIL_CHECK(__glewUseShaderProgramEXT, glUseShaderProgramEXT)
  glUseShaderProgramEXT(type, program);
  OGLM_CHECK_ERR(glUseShaderProgramEXT, )

void
glVDPAUFiniNV()
CODE:
  OGLM_GLEWINIT
  OGLM_CHECK_ERR(glVDPAUFiniNV, )
  OGLM_AVAIL_CHECK(__glewVDPAUFiniNV, glVDPAUFiniNV)
  glVDPAUFiniNV();
  OGLM_CHECK_ERR(glVDPAUFiniNV, )

void
glVDPAUGetSurfaceivNV_c(surface, pname, count, length, values)
  GLvdpauSurfaceNV surface;
  GLenum pname;
  GLsizei count;
  GLsizei* length;
  GLint *values;
CODE:
  OGLM_GLEWINIT
  OGLM_CHECK_ERR(glVDPAUGetSurfaceivNV, )
  OGLM_AVAIL_CHECK(__glewVDPAUGetSurfaceivNV, glVDPAUGetSurfaceivNV)
  glVDPAUGetSurfaceivNV(surface, pname, count, length, values);
  OGLM_CHECK_ERR(glVDPAUGetSurfaceivNV, )

void
glVDPAUInitNV_c(vdpDevice, getProcAddress)
  const void* vdpDevice;
  const void*getProcAddress;
CODE:
  OGLM_GLEWINIT
  OGLM_CHECK_ERR(glVDPAUInitNV, )
  OGLM_AVAIL_CHECK(__glewVDPAUInitNV, glVDPAUInitNV)
  glVDPAUInitNV(vdpDevice, getProcAddress);
  OGLM_CHECK_ERR(glVDPAUInitNV, )

void
glVDPAUIsSurfaceNV(surface)
  GLvdpauSurfaceNV surface;
CODE:
  OGLM_GLEWINIT
  OGLM_CHECK_ERR(glVDPAUIsSurfaceNV, )
  OGLM_AVAIL_CHECK(__glewVDPAUIsSurfaceNV, glVDPAUIsSurfaceNV)
  glVDPAUIsSurfaceNV(surface);
  OGLM_CHECK_ERR(glVDPAUIsSurfaceNV, )

void
glVDPAUMapSurfacesNV_c(numSurfaces, surfaces)
  GLsizei numSurfaces;
  const GLvdpauSurfaceNV* surfaces;
CODE:
  OGLM_GLEWINIT
  OGLM_CHECK_ERR(glVDPAUMapSurfacesNV, )
  OGLM_AVAIL_CHECK(__glewVDPAUMapSurfacesNV, glVDPAUMapSurfacesNV)
  glVDPAUMapSurfacesNV(numSurfaces, surfaces);
  OGLM_CHECK_ERR(glVDPAUMapSurfacesNV, )

GLvdpauSurfaceNV
glVDPAURegisterOutputSurfaceNV_c(vdpSurface, target, numTextureNames, textureNames)
  const void* vdpSurface;
  GLenum target;
  GLsizei numTextureNames;
  const GLuint *textureNames;
CODE:
  OGLM_GLEWINIT
  OGLM_CHECK_ERR(glVDPAURegisterOutputSurfaceNV, )
  OGLM_AVAIL_CHECK(__glewVDPAURegisterOutputSurfaceNV, glVDPAURegisterOutputSurfaceNV)
  RETVAL = glVDPAURegisterOutputSurfaceNV(vdpSurface, target, numTextureNames, textureNames);
  OGLM_CHECK_ERR(glVDPAURegisterOutputSurfaceNV, )
OUTPUT:
  RETVAL

GLvdpauSurfaceNV
glVDPAURegisterVideoSurfaceNV_c(vdpSurface, target, numTextureNames, textureNames)
  const void* vdpSurface;
  GLenum target;
  GLsizei numTextureNames;
  const GLuint *textureNames;
CODE:
  OGLM_GLEWINIT
  OGLM_CHECK_ERR(glVDPAURegisterVideoSurfaceNV, )
  OGLM_AVAIL_CHECK(__glewVDPAURegisterVideoSurfaceNV, glVDPAURegisterVideoSurfaceNV)
  RETVAL = glVDPAURegisterVideoSurfaceNV(vdpSurface, target, numTextureNames, textureNames);
  OGLM_CHECK_ERR(glVDPAURegisterVideoSurfaceNV, )
OUTPUT:
  RETVAL

GLvdpauSurfaceNV
glVDPAURegisterVideoSurfaceWithPictureStructureNV_c(vdpSurface, target, numTextureNames, textureNames, isFrameStructure)
  const void *vdpSurface;
  GLenum target;
  GLsizei numTextureNames;
  const GLuint *textureNames;
  GLboolean isFrameStructure;
CODE:
  OGLM_GLEWINIT
  OGLM_CHECK_ERR(glVDPAURegisterVideoSurfaceWithPictureStructureNV, )
  OGLM_AVAIL_CHECK(__glewVDPAURegisterVideoSurfaceWithPictureStructureNV, glVDPAURegisterVideoSurfaceWithPictureStructureNV)
  RETVAL = glVDPAURegisterVideoSurfaceWithPictureStructureNV(vdpSurface, target, numTextureNames, textureNames, isFrameStructure);
  OGLM_CHECK_ERR(glVDPAURegisterVideoSurfaceWithPictureStructureNV, )
OUTPUT:
  RETVAL

void
glVDPAUSurfaceAccessNV(surface, access)
  GLvdpauSurfaceNV surface;
  GLenum access;
CODE:
  OGLM_GLEWINIT
  OGLM_CHECK_ERR(glVDPAUSurfaceAccessNV, )
  OGLM_AVAIL_CHECK(__glewVDPAUSurfaceAccessNV, glVDPAUSurfaceAccessNV)
  glVDPAUSurfaceAccessNV(surface, access);
  OGLM_CHECK_ERR(glVDPAUSurfaceAccessNV, )

void
glVDPAUUnmapSurfacesNV_c(numSurface, surfaces)
  GLsizei numSurface;
  const GLvdpauSurfaceNV* surfaces;
CODE:
  OGLM_GLEWINIT
  OGLM_CHECK_ERR(glVDPAUUnmapSurfacesNV, )
  OGLM_AVAIL_CHECK(__glewVDPAUUnmapSurfacesNV, glVDPAUUnmapSurfacesNV)
  glVDPAUUnmapSurfacesNV(numSurface, surfaces);
  OGLM_CHECK_ERR(glVDPAUUnmapSurfacesNV, )

void
glVDPAUUnregisterSurfaceNV(surface)
  GLvdpauSurfaceNV surface;
CODE:
  OGLM_GLEWINIT
  OGLM_CHECK_ERR(glVDPAUUnregisterSurfaceNV, )
  OGLM_AVAIL_CHECK(__glewVDPAUUnregisterSurfaceNV, glVDPAUUnregisterSurfaceNV)
  glVDPAUUnregisterSurfaceNV(surface);
  OGLM_CHECK_ERR(glVDPAUUnregisterSurfaceNV, )

void
glValidateProgram(program)
  GLuint program;
CODE:
  OGLM_GLEWINIT
  OGLM_CHECK_ERR(glValidateProgram, )
  OGLM_AVAIL_CHECK(__glewValidateProgram, glValidateProgram)
  glValidateProgram(program);
  OGLM_CHECK_ERR(glValidateProgram, )

void
glValidateProgramARB(programObj)
  GLhandleARB programObj;
CODE:
  OGLM_GLEWINIT
  OGLM_CHECK_ERR(glValidateProgramARB, )
  OGLM_AVAIL_CHECK(__glewValidateProgramARB, glValidateProgramARB)
  glValidateProgramARB(programObj);
  OGLM_CHECK_ERR(glValidateProgramARB, )

void
glValidateProgramPipeline(pipeline)
  GLuint pipeline;
CODE:
  OGLM_GLEWINIT
  OGLM_CHECK_ERR(glValidateProgramPipeline, )
  OGLM_AVAIL_CHECK(__glewValidateProgramPipeline, glValidateProgramPipeline)
  glValidateProgramPipeline(pipeline);
  OGLM_CHECK_ERR(glValidateProgramPipeline, )

void
glVariantArrayObjectATI(id, type, stride, buffer, offset)
  GLuint id;
  GLenum type;
  GLsizei stride;
  GLuint buffer;
  GLuint offset;
CODE:
  OGLM_GLEWINIT
  OGLM_CHECK_ERR(glVariantArrayObjectATI, )
  OGLM_AVAIL_CHECK(__glewVariantArrayObjectATI, glVariantArrayObjectATI)
  glVariantArrayObjectATI(id, type, stride, buffer, offset);
  OGLM_CHECK_ERR(glVariantArrayObjectATI, )

void
glVariantPointerEXT_c(id, type, stride, addr)
  GLuint id;
  GLenum type;
  GLuint stride;
  void *addr;
CODE:
  OGLM_GLEWINIT
  OGLM_CHECK_ERR(glVariantPointerEXT, )
  OGLM_AVAIL_CHECK(__glewVariantPointerEXT, glVariantPointerEXT)
  glVariantPointerEXT(id, type, stride, addr);
  OGLM_CHECK_ERR(glVariantPointerEXT, )

void
glVariantbvEXT_c(id, addr)
  GLuint id;
  GLbyte *addr;
CODE:
  OGLM_GLEWINIT
  OGLM_CHECK_ERR(glVariantbvEXT, )
  OGLM_AVAIL_CHECK(__glewVariantbvEXT, glVariantbvEXT)
  glVariantbvEXT(id, addr);
  OGLM_CHECK_ERR(glVariantbvEXT, )

void
glVariantdvEXT_c(id, addr)
  GLuint id;
  GLdouble *addr;
CODE:
  OGLM_GLEWINIT
  OGLM_CHECK_ERR(glVariantdvEXT, )
  OGLM_AVAIL_CHECK(__glewVariantdvEXT, glVariantdvEXT)
  glVariantdvEXT(id, addr);
  OGLM_CHECK_ERR(glVariantdvEXT, )

void
glVariantfvEXT_c(id, addr)
  GLuint id;
  GLfloat *addr;
CODE:
  OGLM_GLEWINIT
  OGLM_CHECK_ERR(glVariantfvEXT, )
  OGLM_AVAIL_CHECK(__glewVariantfvEXT, glVariantfvEXT)
  glVariantfvEXT(id, addr);
  OGLM_CHECK_ERR(glVariantfvEXT, )

void
glVariantivEXT_c(id, addr)
  GLuint id;
  GLint *addr;
CODE:
  OGLM_GLEWINIT
  OGLM_CHECK_ERR(glVariantivEXT, )
  OGLM_AVAIL_CHECK(__glewVariantivEXT, glVariantivEXT)
  glVariantivEXT(id, addr);
  OGLM_CHECK_ERR(glVariantivEXT, )

void
glVariantsvEXT_c(id, addr)
  GLuint id;
  GLshort *addr;
CODE:
  OGLM_GLEWINIT
  OGLM_CHECK_ERR(glVariantsvEXT, )
  OGLM_AVAIL_CHECK(__glewVariantsvEXT, glVariantsvEXT)
  glVariantsvEXT(id, addr);
  OGLM_CHECK_ERR(glVariantsvEXT, )

void
glVariantubvEXT_c(id, addr)
  GLuint id;
  GLubyte *addr;
CODE:
  OGLM_GLEWINIT
  OGLM_CHECK_ERR(glVariantubvEXT, )
  OGLM_AVAIL_CHECK(__glewVariantubvEXT, glVariantubvEXT)
  glVariantubvEXT(id, addr);
  OGLM_CHECK_ERR(glVariantubvEXT, )

void
glVariantuivEXT_c(id, addr)
  GLuint id;
  GLuint *addr;
CODE:
  OGLM_GLEWINIT
  OGLM_CHECK_ERR(glVariantuivEXT, )
  OGLM_AVAIL_CHECK(__glewVariantuivEXT, glVariantuivEXT)
  glVariantuivEXT(id, addr);
  OGLM_CHECK_ERR(glVariantuivEXT, )

void
glVariantusvEXT_c(id, addr)
  GLuint id;
  GLushort *addr;
CODE:
  OGLM_GLEWINIT
  OGLM_CHECK_ERR(glVariantusvEXT, )
  OGLM_AVAIL_CHECK(__glewVariantusvEXT, glVariantusvEXT)
  glVariantusvEXT(id, addr);
  OGLM_CHECK_ERR(glVariantusvEXT, )

void
glVectorOperationSGIX(operation)
  GLenum operation;
CODE:
  OGLM_GLEWINIT
  OGLM_CHECK_ERR(glVectorOperationSGIX, )
  OGLM_AVAIL_CHECK(__glewVectorOperationSGIX, glVectorOperationSGIX)
  glVectorOperationSGIX(operation);
  OGLM_CHECK_ERR(glVectorOperationSGIX, )

void
glVertex2d(x, y)
  GLdouble x;
  GLdouble y;
CODE:
  OGLM_GLEWINIT
  OGLM_CHECK_ERR(glVertex2d, )
  glVertex2d(x, y);
  OGLM_CHECK_ERR(glVertex2d, )

void
glVertex2dv_c(v)
  const GLdouble *v;
CODE:
  OGLM_GLEWINIT
  OGLM_CHECK_ERR(glVertex2dv, )
  glVertex2dv(v);
  OGLM_CHECK_ERR(glVertex2dv, )

void
glVertex2dv_p(...)
CODE:
  OGLM_GLEWINIT
  OGLM_CHECK_ERR(glVertex2dv, )
  GLdouble *v = OGLM_GET_VARARGS(v,0,GLdouble,NV,2);
  glVertex2dv((const GLdouble *)v);
  OGLM_CHECK_ERR(glVertex2dv, free(v);)
  free(v);

void
glVertex2f(x, y)
  GLfloat x;
  GLfloat y;
CODE:
  OGLM_GLEWINIT
  OGLM_CHECK_ERR(glVertex2f, )
  glVertex2f(x, y);
  OGLM_CHECK_ERR(glVertex2f, )

void
glVertex2fv_c(v)
  const GLfloat *v;
CODE:
  OGLM_GLEWINIT
  OGLM_CHECK_ERR(glVertex2fv, )
  glVertex2fv(v);
  OGLM_CHECK_ERR(glVertex2fv, )

void
glVertex2fv_p(...)
CODE:
  OGLM_GLEWINIT
  OGLM_CHECK_ERR(glVertex2fv, )
  GLfloat *v = OGLM_GET_VARARGS(v,0,GLfloat,NV,2);
  glVertex2fv((const GLfloat *)v);
  OGLM_CHECK_ERR(glVertex2fv, free(v);)
  free(v);

void
glVertex2hNV(x, y)
  GLhalf x;
  GLhalf y;
CODE:
  OGLM_GLEWINIT
  OGLM_CHECK_ERR(glVertex2hNV, )
  OGLM_AVAIL_CHECK(__glewVertex2hNV, glVertex2hNV)
  glVertex2hNV(x, y);
  OGLM_CHECK_ERR(glVertex2hNV, )

void
glVertex2hvNV_c(v)
  const GLhalf* v;
CODE:
  OGLM_GLEWINIT
  OGLM_CHECK_ERR(glVertex2hvNV, )
  OGLM_AVAIL_CHECK(__glewVertex2hvNV, glVertex2hvNV)
  glVertex2hvNV(v);
  OGLM_CHECK_ERR(glVertex2hvNV, )

void
glVertex2hvNV_p(...)
CODE:
  OGLM_GLEWINIT
  OGLM_CHECK_ERR(glVertex2hvNV, )
  OGLM_AVAIL_CHECK(__glewVertex2hvNV, glVertex2hvNV)
  GLhalf* v = OGLM_GET_VARARGS(v,0,GLhalf,NV,2);
  glVertex2hvNV((const GLhalf* )v);
  OGLM_CHECK_ERR(glVertex2hvNV, free(v);)
  free(v);

void
glVertex2i(x, y)
  GLint x;
  GLint y;
CODE:
  OGLM_GLEWINIT
  OGLM_CHECK_ERR(glVertex2i, )
  glVertex2i(x, y);
  OGLM_CHECK_ERR(glVertex2i, )

void
glVertex2iv_c(v)
  const GLint *v;
CODE:
  OGLM_GLEWINIT
  OGLM_CHECK_ERR(glVertex2iv, )
  glVertex2iv(v);
  OGLM_CHECK_ERR(glVertex2iv, )

void
glVertex2iv_p(...)
CODE:
  OGLM_GLEWINIT
  OGLM_CHECK_ERR(glVertex2iv, )
  GLint *v = OGLM_GET_VARARGS(v,0,GLint,IV,2);
  glVertex2iv((const GLint *)v);
  OGLM_CHECK_ERR(glVertex2iv, free(v);)
  free(v);

void
glVertex2s(x, y)
  GLshort x;
  GLshort y;
CODE:
  OGLM_GLEWINIT
  OGLM_CHECK_ERR(glVertex2s, )
  glVertex2s(x, y);
  OGLM_CHECK_ERR(glVertex2s, )

void
glVertex2sv_c(v)
  const GLshort *v;
CODE:
  OGLM_GLEWINIT
  OGLM_CHECK_ERR(glVertex2sv, )
  glVertex2sv(v);
  OGLM_CHECK_ERR(glVertex2sv, )

void
glVertex2sv_p(...)
CODE:
  OGLM_GLEWINIT
  OGLM_CHECK_ERR(glVertex2sv, )
  GLshort *v = OGLM_GET_VARARGS(v,0,GLshort,IV,2);
  glVertex2sv((const GLshort *)v);
  OGLM_CHECK_ERR(glVertex2sv, free(v);)
  free(v);

void
glVertex3d(x, y, z)
  GLdouble x;
  GLdouble y;
  GLdouble z;
CODE:
  OGLM_GLEWINIT
  OGLM_CHECK_ERR(glVertex3d, )
  glVertex3d(x, y, z);
  OGLM_CHECK_ERR(glVertex3d, )

void
glVertex3dv_c(v)
  const GLdouble *v;
CODE:
  OGLM_GLEWINIT
  OGLM_CHECK_ERR(glVertex3dv, )
  glVertex3dv(v);
  OGLM_CHECK_ERR(glVertex3dv, )

void
glVertex3dv_p(...)
CODE:
  OGLM_GLEWINIT
  OGLM_CHECK_ERR(glVertex3dv, )
  GLdouble *v = OGLM_GET_VARARGS(v,0,GLdouble,NV,3);
  glVertex3dv((const GLdouble *)v);
  OGLM_CHECK_ERR(glVertex3dv, free(v);)
  free(v);

void
glVertex3f(x, y, z)
  GLfloat x;
  GLfloat y;
  GLfloat z;
CODE:
  OGLM_GLEWINIT
  OGLM_CHECK_ERR(glVertex3f, )
  glVertex3f(x, y, z);
  OGLM_CHECK_ERR(glVertex3f, )

void
glVertex3fv_c(v)
  const GLfloat *v;
CODE:
  OGLM_GLEWINIT
  OGLM_CHECK_ERR(glVertex3fv, )
  glVertex3fv(v);
  OGLM_CHECK_ERR(glVertex3fv, )

void
glVertex3fv_p(...)
CODE:
  OGLM_GLEWINIT
  OGLM_CHECK_ERR(glVertex3fv, )
  GLfloat *v = OGLM_GET_VARARGS(v,0,GLfloat,NV,3);
  glVertex3fv((const GLfloat *)v);
  OGLM_CHECK_ERR(glVertex3fv, free(v);)
  free(v);

void
glVertex3hNV(x, y, z)
  GLhalf x;
  GLhalf y;
  GLhalf z;
CODE:
  OGLM_GLEWINIT
  OGLM_CHECK_ERR(glVertex3hNV, )
  OGLM_AVAIL_CHECK(__glewVertex3hNV, glVertex3hNV)
  glVertex3hNV(x, y, z);
  OGLM_CHECK_ERR(glVertex3hNV, )

void
glVertex3hvNV_c(v)
  const GLhalf* v;
CODE:
  OGLM_GLEWINIT
  OGLM_CHECK_ERR(glVertex3hvNV, )
  OGLM_AVAIL_CHECK(__glewVertex3hvNV, glVertex3hvNV)
  glVertex3hvNV(v);
  OGLM_CHECK_ERR(glVertex3hvNV, )

void
glVertex3hvNV_p(...)
CODE:
  OGLM_GLEWINIT
  OGLM_CHECK_ERR(glVertex3hvNV, )
  OGLM_AVAIL_CHECK(__glewVertex3hvNV, glVertex3hvNV)
  GLhalf* v = OGLM_GET_VARARGS(v,0,GLhalf,NV,3);
  glVertex3hvNV((const GLhalf* )v);
  OGLM_CHECK_ERR(glVertex3hvNV, free(v);)
  free(v);

void
glVertex3i(x, y, z)
  GLint x;
  GLint y;
  GLint z;
CODE:
  OGLM_GLEWINIT
  OGLM_CHECK_ERR(glVertex3i, )
  glVertex3i(x, y, z);
  OGLM_CHECK_ERR(glVertex3i, )

void
glVertex3iv_c(v)
  const GLint *v;
CODE:
  OGLM_GLEWINIT
  OGLM_CHECK_ERR(glVertex3iv, )
  glVertex3iv(v);
  OGLM_CHECK_ERR(glVertex3iv, )

void
glVertex3iv_p(...)
CODE:
  OGLM_GLEWINIT
  OGLM_CHECK_ERR(glVertex3iv, )
  GLint *v = OGLM_GET_VARARGS(v,0,GLint,IV,3);
  glVertex3iv((const GLint *)v);
  OGLM_CHECK_ERR(glVertex3iv, free(v);)
  free(v);

void
glVertex3s(x, y, z)
  GLshort x;
  GLshort y;
  GLshort z;
CODE:
  OGLM_GLEWINIT
  OGLM_CHECK_ERR(glVertex3s, )
  glVertex3s(x, y, z);
  OGLM_CHECK_ERR(glVertex3s, )

void
glVertex3sv_c(v)
  const GLshort *v;
CODE:
  OGLM_GLEWINIT
  OGLM_CHECK_ERR(glVertex3sv, )
  glVertex3sv(v);
  OGLM_CHECK_ERR(glVertex3sv, )

void
glVertex3sv_p(...)
CODE:
  OGLM_GLEWINIT
  OGLM_CHECK_ERR(glVertex3sv, )
  GLshort *v = OGLM_GET_VARARGS(v,0,GLshort,IV,3);
  glVertex3sv((const GLshort *)v);
  OGLM_CHECK_ERR(glVertex3sv, free(v);)
  free(v);

void
glVertex4d(x, y, z, w)
  GLdouble x;
  GLdouble y;
  GLdouble z;
  GLdouble w;
CODE:
  OGLM_GLEWINIT
  OGLM_CHECK_ERR(glVertex4d, )
  glVertex4d(x, y, z, w);
  OGLM_CHECK_ERR(glVertex4d, )

void
glVertex4dv_c(v)
  const GLdouble *v;
CODE:
  OGLM_GLEWINIT
  OGLM_CHECK_ERR(glVertex4dv, )
  glVertex4dv(v);
  OGLM_CHECK_ERR(glVertex4dv, )

void
glVertex4dv_p(...)
CODE:
  OGLM_GLEWINIT
  OGLM_CHECK_ERR(glVertex4dv, )
  GLdouble *v = OGLM_GET_VARARGS(v,0,GLdouble,NV,4);
  glVertex4dv((const GLdouble *)v);
  OGLM_CHECK_ERR(glVertex4dv, free(v);)
  free(v);

void
glVertex4f(x, y, z, w)
  GLfloat x;
  GLfloat y;
  GLfloat z;
  GLfloat w;
CODE:
  OGLM_GLEWINIT
  OGLM_CHECK_ERR(glVertex4f, )
  glVertex4f(x, y, z, w);
  OGLM_CHECK_ERR(glVertex4f, )

void
glVertex4fv_c(v)
  const GLfloat *v;
CODE:
  OGLM_GLEWINIT
  OGLM_CHECK_ERR(glVertex4fv, )
  glVertex4fv(v);
  OGLM_CHECK_ERR(glVertex4fv, )

void
glVertex4fv_p(...)
CODE:
  OGLM_GLEWINIT
  OGLM_CHECK_ERR(glVertex4fv, )
  GLfloat *v = OGLM_GET_VARARGS(v,0,GLfloat,NV,4);
  glVertex4fv((const GLfloat *)v);
  OGLM_CHECK_ERR(glVertex4fv, free(v);)
  free(v);

void
glVertex4hNV(x, y, z, w)
  GLhalf x;
  GLhalf y;
  GLhalf z;
  GLhalf w;
CODE:
  OGLM_GLEWINIT
  OGLM_CHECK_ERR(glVertex4hNV, )
  OGLM_AVAIL_CHECK(__glewVertex4hNV, glVertex4hNV)
  glVertex4hNV(x, y, z, w);
  OGLM_CHECK_ERR(glVertex4hNV, )

void
glVertex4hvNV_c(v)
  const GLhalf* v;
CODE:
  OGLM_GLEWINIT
  OGLM_CHECK_ERR(glVertex4hvNV, )
  OGLM_AVAIL_CHECK(__glewVertex4hvNV, glVertex4hvNV)
  glVertex4hvNV(v);
  OGLM_CHECK_ERR(glVertex4hvNV, )

void
glVertex4hvNV_p(...)
CODE:
  OGLM_GLEWINIT
  OGLM_CHECK_ERR(glVertex4hvNV, )
  OGLM_AVAIL_CHECK(__glewVertex4hvNV, glVertex4hvNV)
  GLhalf* v = OGLM_GET_VARARGS(v,0,GLhalf,NV,4);
  glVertex4hvNV((const GLhalf* )v);
  OGLM_CHECK_ERR(glVertex4hvNV, free(v);)
  free(v);

void
glVertex4i(x, y, z, w)
  GLint x;
  GLint y;
  GLint z;
  GLint w;
CODE:
  OGLM_GLEWINIT
  OGLM_CHECK_ERR(glVertex4i, )
  glVertex4i(x, y, z, w);
  OGLM_CHECK_ERR(glVertex4i, )

void
glVertex4iv_c(v)
  const GLint *v;
CODE:
  OGLM_GLEWINIT
  OGLM_CHECK_ERR(glVertex4iv, )
  glVertex4iv(v);
  OGLM_CHECK_ERR(glVertex4iv, )

void
glVertex4iv_p(...)
CODE:
  OGLM_GLEWINIT
  OGLM_CHECK_ERR(glVertex4iv, )
  GLint *v = OGLM_GET_VARARGS(v,0,GLint,IV,4);
  glVertex4iv((const GLint *)v);
  OGLM_CHECK_ERR(glVertex4iv, free(v);)
  free(v);

void
glVertex4s(x, y, z, w)
  GLshort x;
  GLshort y;
  GLshort z;
  GLshort w;
CODE:
  OGLM_GLEWINIT
  OGLM_CHECK_ERR(glVertex4s, )
  glVertex4s(x, y, z, w);
  OGLM_CHECK_ERR(glVertex4s, )

void
glVertex4sv_c(v)
  const GLshort *v;
CODE:
  OGLM_GLEWINIT
  OGLM_CHECK_ERR(glVertex4sv, )
  glVertex4sv(v);
  OGLM_CHECK_ERR(glVertex4sv, )

void
glVertex4sv_p(...)
CODE:
  OGLM_GLEWINIT
  OGLM_CHECK_ERR(glVertex4sv, )
  GLshort *v = OGLM_GET_VARARGS(v,0,GLshort,IV,4);
  glVertex4sv((const GLshort *)v);
  OGLM_CHECK_ERR(glVertex4sv, free(v);)
  free(v);

void
glVertexArrayAttribBinding(vaobj, attribindex, bindingindex)
  GLuint vaobj;
  GLuint attribindex;
  GLuint bindingindex;
CODE:
  OGLM_GLEWINIT
  OGLM_CHECK_ERR(glVertexArrayAttribBinding, )
  OGLM_AVAIL_CHECK(__glewVertexArrayAttribBinding, glVertexArrayAttribBinding)
  glVertexArrayAttribBinding(vaobj, attribindex, bindingindex);
  OGLM_CHECK_ERR(glVertexArrayAttribBinding, )

void
glVertexArrayAttribFormat(vaobj, attribindex, size, type, normalized, relativeoffset)
  GLuint vaobj;
  GLuint attribindex;
  GLint size;
  GLenum type;
  GLboolean normalized;
  GLuint relativeoffset;
CODE:
  OGLM_GLEWINIT
  OGLM_CHECK_ERR(glVertexArrayAttribFormat, )
  OGLM_AVAIL_CHECK(__glewVertexArrayAttribFormat, glVertexArrayAttribFormat)
  glVertexArrayAttribFormat(vaobj, attribindex, size, type, normalized, relativeoffset);
  OGLM_CHECK_ERR(glVertexArrayAttribFormat, )

void
glVertexArrayAttribIFormat(vaobj, attribindex, size, type, relativeoffset)
  GLuint vaobj;
  GLuint attribindex;
  GLint size;
  GLenum type;
  GLuint relativeoffset;
CODE:
  OGLM_GLEWINIT
  OGLM_CHECK_ERR(glVertexArrayAttribIFormat, )
  OGLM_AVAIL_CHECK(__glewVertexArrayAttribIFormat, glVertexArrayAttribIFormat)
  glVertexArrayAttribIFormat(vaobj, attribindex, size, type, relativeoffset);
  OGLM_CHECK_ERR(glVertexArrayAttribIFormat, )

void
glVertexArrayAttribLFormat(vaobj, attribindex, size, type, relativeoffset)
  GLuint vaobj;
  GLuint attribindex;
  GLint size;
  GLenum type;
  GLuint relativeoffset;
CODE:
  OGLM_GLEWINIT
  OGLM_CHECK_ERR(glVertexArrayAttribLFormat, )
  OGLM_AVAIL_CHECK(__glewVertexArrayAttribLFormat, glVertexArrayAttribLFormat)
  glVertexArrayAttribLFormat(vaobj, attribindex, size, type, relativeoffset);
  OGLM_CHECK_ERR(glVertexArrayAttribLFormat, )

void
glVertexArrayBindVertexBufferEXT(vaobj, bindingindex, buffer, offset, stride)
  GLuint vaobj;
  GLuint bindingindex;
  GLuint buffer;
  GLintptr offset;
  GLsizei stride;
CODE:
  OGLM_GLEWINIT
  OGLM_CHECK_ERR(glVertexArrayBindVertexBufferEXT, )
  OGLM_AVAIL_CHECK(__glewVertexArrayBindVertexBufferEXT, glVertexArrayBindVertexBufferEXT)
  glVertexArrayBindVertexBufferEXT(vaobj, bindingindex, buffer, offset, stride);
  OGLM_CHECK_ERR(glVertexArrayBindVertexBufferEXT, )

void
glVertexArrayBindingDivisor(vaobj, bindingindex, divisor)
  GLuint vaobj;
  GLuint bindingindex;
  GLuint divisor;
CODE:
  OGLM_GLEWINIT
  OGLM_CHECK_ERR(glVertexArrayBindingDivisor, )
  OGLM_AVAIL_CHECK(__glewVertexArrayBindingDivisor, glVertexArrayBindingDivisor)
  glVertexArrayBindingDivisor(vaobj, bindingindex, divisor);
  OGLM_CHECK_ERR(glVertexArrayBindingDivisor, )

void
glVertexArrayColorOffsetEXT(vaobj, buffer, size, type, stride, offset)
  GLuint vaobj;
  GLuint buffer;
  GLint size;
  GLenum type;
  GLsizei stride;
  GLintptr offset;
CODE:
  OGLM_GLEWINIT
  OGLM_CHECK_ERR(glVertexArrayColorOffsetEXT, )
  OGLM_AVAIL_CHECK(__glewVertexArrayColorOffsetEXT, glVertexArrayColorOffsetEXT)
  glVertexArrayColorOffsetEXT(vaobj, buffer, size, type, stride, offset);
  OGLM_CHECK_ERR(glVertexArrayColorOffsetEXT, )

void
glVertexArrayEdgeFlagOffsetEXT(vaobj, buffer, stride, offset)
  GLuint vaobj;
  GLuint buffer;
  GLsizei stride;
  GLintptr offset;
CODE:
  OGLM_GLEWINIT
  OGLM_CHECK_ERR(glVertexArrayEdgeFlagOffsetEXT, )
  OGLM_AVAIL_CHECK(__glewVertexArrayEdgeFlagOffsetEXT, glVertexArrayEdgeFlagOffsetEXT)
  glVertexArrayEdgeFlagOffsetEXT(vaobj, buffer, stride, offset);
  OGLM_CHECK_ERR(glVertexArrayEdgeFlagOffsetEXT, )

void
glVertexArrayElementBuffer(vaobj, buffer)
  GLuint vaobj;
  GLuint buffer;
CODE:
  OGLM_GLEWINIT
  OGLM_CHECK_ERR(glVertexArrayElementBuffer, )
  OGLM_AVAIL_CHECK(__glewVertexArrayElementBuffer, glVertexArrayElementBuffer)
  glVertexArrayElementBuffer(vaobj, buffer);
  OGLM_CHECK_ERR(glVertexArrayElementBuffer, )

void
glVertexArrayFogCoordOffsetEXT(vaobj, buffer, type, stride, offset)
  GLuint vaobj;
  GLuint buffer;
  GLenum type;
  GLsizei stride;
  GLintptr offset;
CODE:
  OGLM_GLEWINIT
  OGLM_CHECK_ERR(glVertexArrayFogCoordOffsetEXT, )
  OGLM_AVAIL_CHECK(__glewVertexArrayFogCoordOffsetEXT, glVertexArrayFogCoordOffsetEXT)
  glVertexArrayFogCoordOffsetEXT(vaobj, buffer, type, stride, offset);
  OGLM_CHECK_ERR(glVertexArrayFogCoordOffsetEXT, )

void
glVertexArrayIndexOffsetEXT(vaobj, buffer, type, stride, offset)
  GLuint vaobj;
  GLuint buffer;
  GLenum type;
  GLsizei stride;
  GLintptr offset;
CODE:
  OGLM_GLEWINIT
  OGLM_CHECK_ERR(glVertexArrayIndexOffsetEXT, )
  OGLM_AVAIL_CHECK(__glewVertexArrayIndexOffsetEXT, glVertexArrayIndexOffsetEXT)
  glVertexArrayIndexOffsetEXT(vaobj, buffer, type, stride, offset);
  OGLM_CHECK_ERR(glVertexArrayIndexOffsetEXT, )

void
glVertexArrayMultiTexCoordOffsetEXT(vaobj, buffer, texunit, size, type, stride, offset)
  GLuint vaobj;
  GLuint buffer;
  GLenum texunit;
  GLint size;
  GLenum type;
  GLsizei stride;
  GLintptr offset;
CODE:
  OGLM_GLEWINIT
  OGLM_CHECK_ERR(glVertexArrayMultiTexCoordOffsetEXT, )
  OGLM_AVAIL_CHECK(__glewVertexArrayMultiTexCoordOffsetEXT, glVertexArrayMultiTexCoordOffsetEXT)
  glVertexArrayMultiTexCoordOffsetEXT(vaobj, buffer, texunit, size, type, stride, offset);
  OGLM_CHECK_ERR(glVertexArrayMultiTexCoordOffsetEXT, )

void
glVertexArrayNormalOffsetEXT(vaobj, buffer, type, stride, offset)
  GLuint vaobj;
  GLuint buffer;
  GLenum type;
  GLsizei stride;
  GLintptr offset;
CODE:
  OGLM_GLEWINIT
  OGLM_CHECK_ERR(glVertexArrayNormalOffsetEXT, )
  OGLM_AVAIL_CHECK(__glewVertexArrayNormalOffsetEXT, glVertexArrayNormalOffsetEXT)
  glVertexArrayNormalOffsetEXT(vaobj, buffer, type, stride, offset);
  OGLM_CHECK_ERR(glVertexArrayNormalOffsetEXT, )

void
glVertexArrayParameteriAPPLE(pname, param)
  GLenum pname;
  GLint param;
CODE:
  OGLM_GLEWINIT
  OGLM_CHECK_ERR(glVertexArrayParameteriAPPLE, )
  OGLM_AVAIL_CHECK(__glewVertexArrayParameteriAPPLE, glVertexArrayParameteriAPPLE)
  glVertexArrayParameteriAPPLE(pname, param);
  OGLM_CHECK_ERR(glVertexArrayParameteriAPPLE, )

void
glVertexArrayRangeAPPLE_c(length, pointer)
  GLsizei length;
  void *pointer;
CODE:
  OGLM_GLEWINIT
  OGLM_CHECK_ERR(glVertexArrayRangeAPPLE, )
  OGLM_AVAIL_CHECK(__glewVertexArrayRangeAPPLE, glVertexArrayRangeAPPLE)
  glVertexArrayRangeAPPLE(length, pointer);
  OGLM_CHECK_ERR(glVertexArrayRangeAPPLE, )

void
glVertexArrayRangeNV_c(length, pointer)
  GLsizei length;
  void *pointer;
CODE:
  OGLM_GLEWINIT
  OGLM_CHECK_ERR(glVertexArrayRangeNV, )
  OGLM_AVAIL_CHECK(__glewVertexArrayRangeNV, glVertexArrayRangeNV)
  glVertexArrayRangeNV(length, pointer);
  OGLM_CHECK_ERR(glVertexArrayRangeNV, )

void
glVertexArraySecondaryColorOffsetEXT(vaobj, buffer, size, type, stride, offset)
  GLuint vaobj;
  GLuint buffer;
  GLint size;
  GLenum type;
  GLsizei stride;
  GLintptr offset;
CODE:
  OGLM_GLEWINIT
  OGLM_CHECK_ERR(glVertexArraySecondaryColorOffsetEXT, )
  OGLM_AVAIL_CHECK(__glewVertexArraySecondaryColorOffsetEXT, glVertexArraySecondaryColorOffsetEXT)
  glVertexArraySecondaryColorOffsetEXT(vaobj, buffer, size, type, stride, offset);
  OGLM_CHECK_ERR(glVertexArraySecondaryColorOffsetEXT, )

void
glVertexArrayTexCoordOffsetEXT(vaobj, buffer, size, type, stride, offset)
  GLuint vaobj;
  GLuint buffer;
  GLint size;
  GLenum type;
  GLsizei stride;
  GLintptr offset;
CODE:
  OGLM_GLEWINIT
  OGLM_CHECK_ERR(glVertexArrayTexCoordOffsetEXT, )
  OGLM_AVAIL_CHECK(__glewVertexArrayTexCoordOffsetEXT, glVertexArrayTexCoordOffsetEXT)
  glVertexArrayTexCoordOffsetEXT(vaobj, buffer, size, type, stride, offset);
  OGLM_CHECK_ERR(glVertexArrayTexCoordOffsetEXT, )

void
glVertexArrayVertexAttribBindingEXT(vaobj, attribindex, bindingindex)
  GLuint vaobj;
  GLuint attribindex;
  GLuint bindingindex;
CODE:
  OGLM_GLEWINIT
  OGLM_CHECK_ERR(glVertexArrayVertexAttribBindingEXT, )
  OGLM_AVAIL_CHECK(__glewVertexArrayVertexAttribBindingEXT, glVertexArrayVertexAttribBindingEXT)
  glVertexArrayVertexAttribBindingEXT(vaobj, attribindex, bindingindex);
  OGLM_CHECK_ERR(glVertexArrayVertexAttribBindingEXT, )

void
glVertexArrayVertexAttribDivisorEXT(vaobj, index, divisor)
  GLuint vaobj;
  GLuint index;
  GLuint divisor;
CODE:
  OGLM_GLEWINIT
  OGLM_CHECK_ERR(glVertexArrayVertexAttribDivisorEXT, )
  OGLM_AVAIL_CHECK(__glewVertexArrayVertexAttribDivisorEXT, glVertexArrayVertexAttribDivisorEXT)
  glVertexArrayVertexAttribDivisorEXT(vaobj, index, divisor);
  OGLM_CHECK_ERR(glVertexArrayVertexAttribDivisorEXT, )

void
glVertexArrayVertexAttribFormatEXT(vaobj, attribindex, size, type, normalized, relativeoffset)
  GLuint vaobj;
  GLuint attribindex;
  GLint size;
  GLenum type;
  GLboolean normalized;
  GLuint relativeoffset;
CODE:
  OGLM_GLEWINIT
  OGLM_CHECK_ERR(glVertexArrayVertexAttribFormatEXT, )
  OGLM_AVAIL_CHECK(__glewVertexArrayVertexAttribFormatEXT, glVertexArrayVertexAttribFormatEXT)
  glVertexArrayVertexAttribFormatEXT(vaobj, attribindex, size, type, normalized, relativeoffset);
  OGLM_CHECK_ERR(glVertexArrayVertexAttribFormatEXT, )

void
glVertexArrayVertexAttribIFormatEXT(vaobj, attribindex, size, type, relativeoffset)
  GLuint vaobj;
  GLuint attribindex;
  GLint size;
  GLenum type;
  GLuint relativeoffset;
CODE:
  OGLM_GLEWINIT
  OGLM_CHECK_ERR(glVertexArrayVertexAttribIFormatEXT, )
  OGLM_AVAIL_CHECK(__glewVertexArrayVertexAttribIFormatEXT, glVertexArrayVertexAttribIFormatEXT)
  glVertexArrayVertexAttribIFormatEXT(vaobj, attribindex, size, type, relativeoffset);
  OGLM_CHECK_ERR(glVertexArrayVertexAttribIFormatEXT, )

void
glVertexArrayVertexAttribIOffsetEXT(vaobj, buffer, index, size, type, stride, offset)
  GLuint vaobj;
  GLuint buffer;
  GLuint index;
  GLint size;
  GLenum type;
  GLsizei stride;
  GLintptr offset;
CODE:
  OGLM_GLEWINIT
  OGLM_CHECK_ERR(glVertexArrayVertexAttribIOffsetEXT, )
  OGLM_AVAIL_CHECK(__glewVertexArrayVertexAttribIOffsetEXT, glVertexArrayVertexAttribIOffsetEXT)
  glVertexArrayVertexAttribIOffsetEXT(vaobj, buffer, index, size, type, stride, offset);
  OGLM_CHECK_ERR(glVertexArrayVertexAttribIOffsetEXT, )

void
glVertexArrayVertexAttribLFormatEXT(vaobj, attribindex, size, type, relativeoffset)
  GLuint vaobj;
  GLuint attribindex;
  GLint size;
  GLenum type;
  GLuint relativeoffset;
CODE:
  OGLM_GLEWINIT
  OGLM_CHECK_ERR(glVertexArrayVertexAttribLFormatEXT, )
  OGLM_AVAIL_CHECK(__glewVertexArrayVertexAttribLFormatEXT, glVertexArrayVertexAttribLFormatEXT)
  glVertexArrayVertexAttribLFormatEXT(vaobj, attribindex, size, type, relativeoffset);
  OGLM_CHECK_ERR(glVertexArrayVertexAttribLFormatEXT, )

void
glVertexArrayVertexAttribLOffsetEXT(vaobj, buffer, index, size, type, stride, offset)
  GLuint vaobj;
  GLuint buffer;
  GLuint index;
  GLint size;
  GLenum type;
  GLsizei stride;
  GLintptr offset;
CODE:
  OGLM_GLEWINIT
  OGLM_CHECK_ERR(glVertexArrayVertexAttribLOffsetEXT, )
  OGLM_AVAIL_CHECK(__glewVertexArrayVertexAttribLOffsetEXT, glVertexArrayVertexAttribLOffsetEXT)
  glVertexArrayVertexAttribLOffsetEXT(vaobj, buffer, index, size, type, stride, offset);
  OGLM_CHECK_ERR(glVertexArrayVertexAttribLOffsetEXT, )

void
glVertexArrayVertexAttribOffsetEXT(vaobj, buffer, index, size, type, normalized, stride, offset)
  GLuint vaobj;
  GLuint buffer;
  GLuint index;
  GLint size;
  GLenum type;
  GLboolean normalized;
  GLsizei stride;
  GLintptr offset;
CODE:
  OGLM_GLEWINIT
  OGLM_CHECK_ERR(glVertexArrayVertexAttribOffsetEXT, )
  OGLM_AVAIL_CHECK(__glewVertexArrayVertexAttribOffsetEXT, glVertexArrayVertexAttribOffsetEXT)
  glVertexArrayVertexAttribOffsetEXT(vaobj, buffer, index, size, type, normalized, stride, offset);
  OGLM_CHECK_ERR(glVertexArrayVertexAttribOffsetEXT, )

void
glVertexArrayVertexBindingDivisorEXT(vaobj, bindingindex, divisor)
  GLuint vaobj;
  GLuint bindingindex;
  GLuint divisor;
CODE:
  OGLM_GLEWINIT
  OGLM_CHECK_ERR(glVertexArrayVertexBindingDivisorEXT, )
  OGLM_AVAIL_CHECK(__glewVertexArrayVertexBindingDivisorEXT, glVertexArrayVertexBindingDivisorEXT)
  glVertexArrayVertexBindingDivisorEXT(vaobj, bindingindex, divisor);
  OGLM_CHECK_ERR(glVertexArrayVertexBindingDivisorEXT, )

void
glVertexArrayVertexBuffer(vaobj, bindingindex, buffer, offset, stride)
  GLuint vaobj;
  GLuint bindingindex;
  GLuint buffer;
  GLintptr offset;
  GLsizei stride;
CODE:
  OGLM_GLEWINIT
  OGLM_CHECK_ERR(glVertexArrayVertexBuffer, )
  OGLM_AVAIL_CHECK(__glewVertexArrayVertexBuffer, glVertexArrayVertexBuffer)
  glVertexArrayVertexBuffer(vaobj, bindingindex, buffer, offset, stride);
  OGLM_CHECK_ERR(glVertexArrayVertexBuffer, )

void
glVertexArrayVertexBuffers_c(vaobj, first, count, buffers, offsets, strides)
  GLuint vaobj;
  GLuint first;
  GLsizei count;
  const GLuint* buffers;
  const GLintptr *offsets;
  const GLsizei *strides;
CODE:
  OGLM_GLEWINIT
  OGLM_CHECK_ERR(glVertexArrayVertexBuffers, )
  OGLM_AVAIL_CHECK(__glewVertexArrayVertexBuffers, glVertexArrayVertexBuffers)
  glVertexArrayVertexBuffers(vaobj, first, count, buffers, offsets, strides);
  OGLM_CHECK_ERR(glVertexArrayVertexBuffers, )

void
glVertexArrayVertexOffsetEXT(vaobj, buffer, size, type, stride, offset)
  GLuint vaobj;
  GLuint buffer;
  GLint size;
  GLenum type;
  GLsizei stride;
  GLintptr offset;
CODE:
  OGLM_GLEWINIT
  OGLM_CHECK_ERR(glVertexArrayVertexOffsetEXT, )
  OGLM_AVAIL_CHECK(__glewVertexArrayVertexOffsetEXT, glVertexArrayVertexOffsetEXT)
  glVertexArrayVertexOffsetEXT(vaobj, buffer, size, type, stride, offset);
  OGLM_CHECK_ERR(glVertexArrayVertexOffsetEXT, )

void
glVertexAttrib1d(index, x)
  GLuint index;
  GLdouble x;
ALIAS:
  glVertexAttrib1dARB = 1
  glVertexAttrib1dNV = 2
CODE:
  OGLM_GLEWINIT
  OGLM_CHECK_ERR(glVertexAttrib1d, )
  OGLM_AVAIL_CHECK(__glewVertexAttrib1d, glVertexAttrib1d)
  glVertexAttrib1d(index, x);
  OGLM_CHECK_ERR(glVertexAttrib1d, )

void
glVertexAttrib1dv_c(index, v)
  GLuint index;
  const GLdouble* v;
ALIAS:
  glVertexAttrib1dvARB_c = 1
  glVertexAttrib1dvNV_c = 2
CODE:
  OGLM_GLEWINIT
  OGLM_CHECK_ERR(glVertexAttrib1dv, )
  OGLM_AVAIL_CHECK(__glewVertexAttrib1dv, glVertexAttrib1dv)
  glVertexAttrib1dv(index, v);
  OGLM_CHECK_ERR(glVertexAttrib1dv, )

void
glVertexAttrib1dv_p(index, ...)
  GLuint index;
ALIAS:
  glVertexAttrib1dvARB_p = 1
  glVertexAttrib1dvNV_p = 2
CODE:
  OGLM_GLEWINIT
  OGLM_CHECK_ERR(glVertexAttrib1dv, )
  OGLM_AVAIL_CHECK(__glewVertexAttrib1dv, glVertexAttrib1dv)
  GLdouble* v = OGLM_GET_VARARGS(v,1,GLdouble,NV,1);
  glVertexAttrib1dv((GLuint )index, (const GLdouble* )v);
  OGLM_CHECK_ERR(glVertexAttrib1dv, free(v);)
  free(v);

void
glVertexAttrib1f(index, x)
  GLuint index;
  GLfloat x;
ALIAS:
  glVertexAttrib1fARB = 1
  glVertexAttrib1fNV = 2
CODE:
  OGLM_GLEWINIT
  OGLM_CHECK_ERR(glVertexAttrib1f, )
  OGLM_AVAIL_CHECK(__glewVertexAttrib1f, glVertexAttrib1f)
  glVertexAttrib1f(index, x);
  OGLM_CHECK_ERR(glVertexAttrib1f, )

void
glVertexAttrib1fv_c(index, v)
  GLuint index;
  const GLfloat* v;
ALIAS:
  glVertexAttrib1fvARB_c = 1
  glVertexAttrib1fvNV_c = 2
CODE:
  OGLM_GLEWINIT
  OGLM_CHECK_ERR(glVertexAttrib1fv, )
  OGLM_AVAIL_CHECK(__glewVertexAttrib1fv, glVertexAttrib1fv)
  glVertexAttrib1fv(index, v);
  OGLM_CHECK_ERR(glVertexAttrib1fv, )

void
glVertexAttrib1fv_p(index, ...)
  GLuint index;
ALIAS:
  glVertexAttrib1fvARB_p = 1
  glVertexAttrib1fvNV_p = 2
CODE:
  OGLM_GLEWINIT
  OGLM_CHECK_ERR(glVertexAttrib1fv, )
  OGLM_AVAIL_CHECK(__glewVertexAttrib1fv, glVertexAttrib1fv)
  GLfloat* v = OGLM_GET_VARARGS(v,1,GLfloat,NV,1);
  glVertexAttrib1fv((GLuint )index, (const GLfloat* )v);
  OGLM_CHECK_ERR(glVertexAttrib1fv, free(v);)
  free(v);

void
glVertexAttrib1hNV(index, x)
  GLuint index;
  GLhalf x;
CODE:
  OGLM_GLEWINIT
  OGLM_CHECK_ERR(glVertexAttrib1hNV, )
  OGLM_AVAIL_CHECK(__glewVertexAttrib1hNV, glVertexAttrib1hNV)
  glVertexAttrib1hNV(index, x);
  OGLM_CHECK_ERR(glVertexAttrib1hNV, )

void
glVertexAttrib1hvNV_c(index, v)
  GLuint index;
  const GLhalf* v;
CODE:
  OGLM_GLEWINIT
  OGLM_CHECK_ERR(glVertexAttrib1hvNV, )
  OGLM_AVAIL_CHECK(__glewVertexAttrib1hvNV, glVertexAttrib1hvNV)
  glVertexAttrib1hvNV(index, v);
  OGLM_CHECK_ERR(glVertexAttrib1hvNV, )

void
glVertexAttrib1hvNV_p(index, ...)
  GLuint index;
CODE:
  OGLM_GLEWINIT
  OGLM_CHECK_ERR(glVertexAttrib1hvNV, )
  OGLM_AVAIL_CHECK(__glewVertexAttrib1hvNV, glVertexAttrib1hvNV)
  GLhalf* v = OGLM_GET_VARARGS(v,1,GLhalf,NV,1);
  glVertexAttrib1hvNV((GLuint )index, (const GLhalf* )v);
  OGLM_CHECK_ERR(glVertexAttrib1hvNV, free(v);)
  free(v);

void
glVertexAttrib1s(index, x)
  GLuint index;
  GLshort x;
ALIAS:
  glVertexAttrib1sARB = 1
  glVertexAttrib1sNV = 2
CODE:
  OGLM_GLEWINIT
  OGLM_CHECK_ERR(glVertexAttrib1s, )
  OGLM_AVAIL_CHECK(__glewVertexAttrib1s, glVertexAttrib1s)
  glVertexAttrib1s(index, x);
  OGLM_CHECK_ERR(glVertexAttrib1s, )

void
glVertexAttrib1sv_c(index, v)
  GLuint index;
  const GLshort* v;
ALIAS:
  glVertexAttrib1svARB_c = 1
  glVertexAttrib1svNV_c = 2
CODE:
  OGLM_GLEWINIT
  OGLM_CHECK_ERR(glVertexAttrib1sv, )
  OGLM_AVAIL_CHECK(__glewVertexAttrib1sv, glVertexAttrib1sv)
  glVertexAttrib1sv(index, v);
  OGLM_CHECK_ERR(glVertexAttrib1sv, )

void
glVertexAttrib1sv_p(index, ...)
  GLuint index;
ALIAS:
  glVertexAttrib1svARB_p = 1
  glVertexAttrib1svNV_p = 2
CODE:
  OGLM_GLEWINIT
  OGLM_CHECK_ERR(glVertexAttrib1sv, )
  OGLM_AVAIL_CHECK(__glewVertexAttrib1sv, glVertexAttrib1sv)
  GLshort* v = OGLM_GET_VARARGS(v,1,GLshort,IV,1);
  glVertexAttrib1sv((GLuint )index, (const GLshort* )v);
  OGLM_CHECK_ERR(glVertexAttrib1sv, free(v);)
  free(v);

void
glVertexAttrib2d(index, x, y)
  GLuint index;
  GLdouble x;
  GLdouble y;
ALIAS:
  glVertexAttrib2dARB = 1
  glVertexAttrib2dNV = 2
CODE:
  OGLM_GLEWINIT
  OGLM_CHECK_ERR(glVertexAttrib2d, )
  OGLM_AVAIL_CHECK(__glewVertexAttrib2d, glVertexAttrib2d)
  glVertexAttrib2d(index, x, y);
  OGLM_CHECK_ERR(glVertexAttrib2d, )

void
glVertexAttrib2dv_c(index, v)
  GLuint index;
  const GLdouble* v;
ALIAS:
  glVertexAttrib2dvARB_c = 1
  glVertexAttrib2dvNV_c = 2
CODE:
  OGLM_GLEWINIT
  OGLM_CHECK_ERR(glVertexAttrib2dv, )
  OGLM_AVAIL_CHECK(__glewVertexAttrib2dv, glVertexAttrib2dv)
  glVertexAttrib2dv(index, v);
  OGLM_CHECK_ERR(glVertexAttrib2dv, )

void
glVertexAttrib2dv_p(index, ...)
  GLuint index;
ALIAS:
  glVertexAttrib2dvARB_p = 1
  glVertexAttrib2dvNV_p = 2
CODE:
  OGLM_GLEWINIT
  OGLM_CHECK_ERR(glVertexAttrib2dv, )
  OGLM_AVAIL_CHECK(__glewVertexAttrib2dv, glVertexAttrib2dv)
  GLdouble* v = OGLM_GET_VARARGS(v,1,GLdouble,NV,2);
  glVertexAttrib2dv((GLuint )index, (const GLdouble* )v);
  OGLM_CHECK_ERR(glVertexAttrib2dv, free(v);)
  free(v);

void
glVertexAttrib2f(index, x, y)
  GLuint index;
  GLfloat x;
  GLfloat y;
ALIAS:
  glVertexAttrib2fARB = 1
  glVertexAttrib2fNV = 2
CODE:
  OGLM_GLEWINIT
  OGLM_CHECK_ERR(glVertexAttrib2f, )
  OGLM_AVAIL_CHECK(__glewVertexAttrib2f, glVertexAttrib2f)
  glVertexAttrib2f(index, x, y);
  OGLM_CHECK_ERR(glVertexAttrib2f, )

void
glVertexAttrib2fv_c(index, v)
  GLuint index;
  const GLfloat* v;
ALIAS:
  glVertexAttrib2fvARB_c = 1
  glVertexAttrib2fvNV_c = 2
CODE:
  OGLM_GLEWINIT
  OGLM_CHECK_ERR(glVertexAttrib2fv, )
  OGLM_AVAIL_CHECK(__glewVertexAttrib2fv, glVertexAttrib2fv)
  glVertexAttrib2fv(index, v);
  OGLM_CHECK_ERR(glVertexAttrib2fv, )

void
glVertexAttrib2fv_p(index, ...)
  GLuint index;
ALIAS:
  glVertexAttrib2fvARB_p = 1
  glVertexAttrib2fvNV_p = 2
CODE:
  OGLM_GLEWINIT
  OGLM_CHECK_ERR(glVertexAttrib2fv, )
  OGLM_AVAIL_CHECK(__glewVertexAttrib2fv, glVertexAttrib2fv)
  GLfloat* v = OGLM_GET_VARARGS(v,1,GLfloat,NV,2);
  glVertexAttrib2fv((GLuint )index, (const GLfloat* )v);
  OGLM_CHECK_ERR(glVertexAttrib2fv, free(v);)
  free(v);

void
glVertexAttrib2hNV(index, x, y)
  GLuint index;
  GLhalf x;
  GLhalf y;
CODE:
  OGLM_GLEWINIT
  OGLM_CHECK_ERR(glVertexAttrib2hNV, )
  OGLM_AVAIL_CHECK(__glewVertexAttrib2hNV, glVertexAttrib2hNV)
  glVertexAttrib2hNV(index, x, y);
  OGLM_CHECK_ERR(glVertexAttrib2hNV, )

void
glVertexAttrib2hvNV_c(index, v)
  GLuint index;
  const GLhalf* v;
CODE:
  OGLM_GLEWINIT
  OGLM_CHECK_ERR(glVertexAttrib2hvNV, )
  OGLM_AVAIL_CHECK(__glewVertexAttrib2hvNV, glVertexAttrib2hvNV)
  glVertexAttrib2hvNV(index, v);
  OGLM_CHECK_ERR(glVertexAttrib2hvNV, )

void
glVertexAttrib2hvNV_p(index, ...)
  GLuint index;
CODE:
  OGLM_GLEWINIT
  OGLM_CHECK_ERR(glVertexAttrib2hvNV, )
  OGLM_AVAIL_CHECK(__glewVertexAttrib2hvNV, glVertexAttrib2hvNV)
  GLhalf* v = OGLM_GET_VARARGS(v,1,GLhalf,NV,2);
  glVertexAttrib2hvNV((GLuint )index, (const GLhalf* )v);
  OGLM_CHECK_ERR(glVertexAttrib2hvNV, free(v);)
  free(v);

void
glVertexAttrib2s(index, x, y)
  GLuint index;
  GLshort x;
  GLshort y;
ALIAS:
  glVertexAttrib2sARB = 1
  glVertexAttrib2sNV = 2
CODE:
  OGLM_GLEWINIT
  OGLM_CHECK_ERR(glVertexAttrib2s, )
  OGLM_AVAIL_CHECK(__glewVertexAttrib2s, glVertexAttrib2s)
  glVertexAttrib2s(index, x, y);
  OGLM_CHECK_ERR(glVertexAttrib2s, )

void
glVertexAttrib2sv_c(index, v)
  GLuint index;
  const GLshort* v;
ALIAS:
  glVertexAttrib2svARB_c = 1
  glVertexAttrib2svNV_c = 2
CODE:
  OGLM_GLEWINIT
  OGLM_CHECK_ERR(glVertexAttrib2sv, )
  OGLM_AVAIL_CHECK(__glewVertexAttrib2sv, glVertexAttrib2sv)
  glVertexAttrib2sv(index, v);
  OGLM_CHECK_ERR(glVertexAttrib2sv, )

void
glVertexAttrib2sv_p(index, ...)
  GLuint index;
ALIAS:
  glVertexAttrib2svARB_p = 1
  glVertexAttrib2svNV_p = 2
CODE:
  OGLM_GLEWINIT
  OGLM_CHECK_ERR(glVertexAttrib2sv, )
  OGLM_AVAIL_CHECK(__glewVertexAttrib2sv, glVertexAttrib2sv)
  GLshort* v = OGLM_GET_VARARGS(v,1,GLshort,IV,2);
  glVertexAttrib2sv((GLuint )index, (const GLshort* )v);
  OGLM_CHECK_ERR(glVertexAttrib2sv, free(v);)
  free(v);

void
glVertexAttrib3d(index, x, y, z)
  GLuint index;
  GLdouble x;
  GLdouble y;
  GLdouble z;
ALIAS:
  glVertexAttrib3dARB = 1
  glVertexAttrib3dNV = 2
CODE:
  OGLM_GLEWINIT
  OGLM_CHECK_ERR(glVertexAttrib3d, )
  OGLM_AVAIL_CHECK(__glewVertexAttrib3d, glVertexAttrib3d)
  glVertexAttrib3d(index, x, y, z);
  OGLM_CHECK_ERR(glVertexAttrib3d, )

void
glVertexAttrib3dv_c(index, v)
  GLuint index;
  const GLdouble* v;
ALIAS:
  glVertexAttrib3dvARB_c = 1
  glVertexAttrib3dvNV_c = 2
CODE:
  OGLM_GLEWINIT
  OGLM_CHECK_ERR(glVertexAttrib3dv, )
  OGLM_AVAIL_CHECK(__glewVertexAttrib3dv, glVertexAttrib3dv)
  glVertexAttrib3dv(index, v);
  OGLM_CHECK_ERR(glVertexAttrib3dv, )

void
glVertexAttrib3dv_p(index, ...)
  GLuint index;
ALIAS:
  glVertexAttrib3dvARB_p = 1
  glVertexAttrib3dvNV_p = 2
CODE:
  OGLM_GLEWINIT
  OGLM_CHECK_ERR(glVertexAttrib3dv, )
  OGLM_AVAIL_CHECK(__glewVertexAttrib3dv, glVertexAttrib3dv)
  GLdouble* v = OGLM_GET_VARARGS(v,1,GLdouble,NV,3);
  glVertexAttrib3dv((GLuint )index, (const GLdouble* )v);
  OGLM_CHECK_ERR(glVertexAttrib3dv, free(v);)
  free(v);

void
glVertexAttrib3f(index, x, y, z)
  GLuint index;
  GLfloat x;
  GLfloat y;
  GLfloat z;
ALIAS:
  glVertexAttrib3fARB = 1
  glVertexAttrib3fNV = 2
CODE:
  OGLM_GLEWINIT
  OGLM_CHECK_ERR(glVertexAttrib3f, )
  OGLM_AVAIL_CHECK(__glewVertexAttrib3f, glVertexAttrib3f)
  glVertexAttrib3f(index, x, y, z);
  OGLM_CHECK_ERR(glVertexAttrib3f, )

void
glVertexAttrib3fv_c(index, v)
  GLuint index;
  const GLfloat* v;
ALIAS:
  glVertexAttrib3fvARB_c = 1
  glVertexAttrib3fvNV_c = 2
CODE:
  OGLM_GLEWINIT
  OGLM_CHECK_ERR(glVertexAttrib3fv, )
  OGLM_AVAIL_CHECK(__glewVertexAttrib3fv, glVertexAttrib3fv)
  glVertexAttrib3fv(index, v);
  OGLM_CHECK_ERR(glVertexAttrib3fv, )

void
glVertexAttrib3fv_p(index, ...)
  GLuint index;
ALIAS:
  glVertexAttrib3fvARB_p = 1
  glVertexAttrib3fvNV_p = 2
CODE:
  OGLM_GLEWINIT
  OGLM_CHECK_ERR(glVertexAttrib3fv, )
  OGLM_AVAIL_CHECK(__glewVertexAttrib3fv, glVertexAttrib3fv)
  GLfloat* v = OGLM_GET_VARARGS(v,1,GLfloat,NV,3);
  glVertexAttrib3fv((GLuint )index, (const GLfloat* )v);
  OGLM_CHECK_ERR(glVertexAttrib3fv, free(v);)
  free(v);

void
glVertexAttrib3hNV(index, x, y, z)
  GLuint index;
  GLhalf x;
  GLhalf y;
  GLhalf z;
CODE:
  OGLM_GLEWINIT
  OGLM_CHECK_ERR(glVertexAttrib3hNV, )
  OGLM_AVAIL_CHECK(__glewVertexAttrib3hNV, glVertexAttrib3hNV)
  glVertexAttrib3hNV(index, x, y, z);
  OGLM_CHECK_ERR(glVertexAttrib3hNV, )

void
glVertexAttrib3hvNV_c(index, v)
  GLuint index;
  const GLhalf* v;
CODE:
  OGLM_GLEWINIT
  OGLM_CHECK_ERR(glVertexAttrib3hvNV, )
  OGLM_AVAIL_CHECK(__glewVertexAttrib3hvNV, glVertexAttrib3hvNV)
  glVertexAttrib3hvNV(index, v);
  OGLM_CHECK_ERR(glVertexAttrib3hvNV, )

void
glVertexAttrib3hvNV_p(index, ...)
  GLuint index;
CODE:
  OGLM_GLEWINIT
  OGLM_CHECK_ERR(glVertexAttrib3hvNV, )
  OGLM_AVAIL_CHECK(__glewVertexAttrib3hvNV, glVertexAttrib3hvNV)
  GLhalf* v = OGLM_GET_VARARGS(v,1,GLhalf,NV,3);
  glVertexAttrib3hvNV((GLuint )index, (const GLhalf* )v);
  OGLM_CHECK_ERR(glVertexAttrib3hvNV, free(v);)
  free(v);

void
glVertexAttrib3s(index, x, y, z)
  GLuint index;
  GLshort x;
  GLshort y;
  GLshort z;
ALIAS:
  glVertexAttrib3sARB = 1
  glVertexAttrib3sNV = 2
CODE:
  OGLM_GLEWINIT
  OGLM_CHECK_ERR(glVertexAttrib3s, )
  OGLM_AVAIL_CHECK(__glewVertexAttrib3s, glVertexAttrib3s)
  glVertexAttrib3s(index, x, y, z);
  OGLM_CHECK_ERR(glVertexAttrib3s, )

void
glVertexAttrib3sv_c(index, v)
  GLuint index;
  const GLshort* v;
ALIAS:
  glVertexAttrib3svARB_c = 1
  glVertexAttrib3svNV_c = 2
CODE:
  OGLM_GLEWINIT
  OGLM_CHECK_ERR(glVertexAttrib3sv, )
  OGLM_AVAIL_CHECK(__glewVertexAttrib3sv, glVertexAttrib3sv)
  glVertexAttrib3sv(index, v);
  OGLM_CHECK_ERR(glVertexAttrib3sv, )

void
glVertexAttrib3sv_p(index, ...)
  GLuint index;
ALIAS:
  glVertexAttrib3svARB_p = 1
  glVertexAttrib3svNV_p = 2
CODE:
  OGLM_GLEWINIT
  OGLM_CHECK_ERR(glVertexAttrib3sv, )
  OGLM_AVAIL_CHECK(__glewVertexAttrib3sv, glVertexAttrib3sv)
  GLshort* v = OGLM_GET_VARARGS(v,1,GLshort,IV,3);
  glVertexAttrib3sv((GLuint )index, (const GLshort* )v);
  OGLM_CHECK_ERR(glVertexAttrib3sv, free(v);)
  free(v);

void
glVertexAttrib4Nbv_c(index, v)
  GLuint index;
  const GLbyte* v;
ALIAS:
  glVertexAttrib4NbvARB_c = 1
CODE:
  OGLM_GLEWINIT
  OGLM_CHECK_ERR(glVertexAttrib4Nbv, )
  OGLM_AVAIL_CHECK(__glewVertexAttrib4Nbv, glVertexAttrib4Nbv)
  glVertexAttrib4Nbv(index, v);
  OGLM_CHECK_ERR(glVertexAttrib4Nbv, )

void
glVertexAttrib4Nbv_p(index, ...)
  GLuint index;
ALIAS:
  glVertexAttrib4NbvARB_p = 1
CODE:
  OGLM_GLEWINIT
  OGLM_CHECK_ERR(glVertexAttrib4Nbv, )
  OGLM_AVAIL_CHECK(__glewVertexAttrib4Nbv, glVertexAttrib4Nbv)
  GLbyte* v = OGLM_GET_VARARGS(v,1,GLbyte,IV,4);
  glVertexAttrib4Nbv((GLuint )index, (const GLbyte* )v);
  OGLM_CHECK_ERR(glVertexAttrib4Nbv, free(v);)
  free(v);

void
glVertexAttrib4Niv_c(index, v)
  GLuint index;
  const GLint* v;
ALIAS:
  glVertexAttrib4NivARB_c = 1
CODE:
  OGLM_GLEWINIT
  OGLM_CHECK_ERR(glVertexAttrib4Niv, )
  OGLM_AVAIL_CHECK(__glewVertexAttrib4Niv, glVertexAttrib4Niv)
  glVertexAttrib4Niv(index, v);
  OGLM_CHECK_ERR(glVertexAttrib4Niv, )

void
glVertexAttrib4Niv_p(index, ...)
  GLuint index;
ALIAS:
  glVertexAttrib4NivARB_p = 1
CODE:
  OGLM_GLEWINIT
  OGLM_CHECK_ERR(glVertexAttrib4Niv, )
  OGLM_AVAIL_CHECK(__glewVertexAttrib4Niv, glVertexAttrib4Niv)
  GLint* v = OGLM_GET_VARARGS(v,1,GLint,IV,4);
  glVertexAttrib4Niv((GLuint )index, (const GLint* )v);
  OGLM_CHECK_ERR(glVertexAttrib4Niv, free(v);)
  free(v);

void
glVertexAttrib4Nsv_c(index, v)
  GLuint index;
  const GLshort* v;
ALIAS:
  glVertexAttrib4NsvARB_c = 1
CODE:
  OGLM_GLEWINIT
  OGLM_CHECK_ERR(glVertexAttrib4Nsv, )
  OGLM_AVAIL_CHECK(__glewVertexAttrib4Nsv, glVertexAttrib4Nsv)
  glVertexAttrib4Nsv(index, v);
  OGLM_CHECK_ERR(glVertexAttrib4Nsv, )

void
glVertexAttrib4Nsv_p(index, ...)
  GLuint index;
ALIAS:
  glVertexAttrib4NsvARB_p = 1
CODE:
  OGLM_GLEWINIT
  OGLM_CHECK_ERR(glVertexAttrib4Nsv, )
  OGLM_AVAIL_CHECK(__glewVertexAttrib4Nsv, glVertexAttrib4Nsv)
  GLshort* v = OGLM_GET_VARARGS(v,1,GLshort,IV,4);
  glVertexAttrib4Nsv((GLuint )index, (const GLshort* )v);
  OGLM_CHECK_ERR(glVertexAttrib4Nsv, free(v);)
  free(v);

void
glVertexAttrib4Nub(index, x, y, z, w)
  GLuint index;
  GLubyte x;
  GLubyte y;
  GLubyte z;
  GLubyte w;
ALIAS:
  glVertexAttrib4NubARB = 1
  glVertexAttrib4ubNV = 2
CODE:
  OGLM_GLEWINIT
  OGLM_CHECK_ERR(glVertexAttrib4Nub, )
  OGLM_AVAIL_CHECK(__glewVertexAttrib4Nub, glVertexAttrib4Nub)
  glVertexAttrib4Nub(index, x, y, z, w);
  OGLM_CHECK_ERR(glVertexAttrib4Nub, )

void
glVertexAttrib4Nubv_c(index, v)
  GLuint index;
  const GLubyte* v;
ALIAS:
  glVertexAttrib4NubvARB_c = 1
  glVertexAttrib4ubvNV_c = 2
CODE:
  OGLM_GLEWINIT
  OGLM_CHECK_ERR(glVertexAttrib4Nubv, )
  OGLM_AVAIL_CHECK(__glewVertexAttrib4Nubv, glVertexAttrib4Nubv)
  glVertexAttrib4Nubv(index, v);
  OGLM_CHECK_ERR(glVertexAttrib4Nubv, )

void
glVertexAttrib4Nubv_p(index, ...)
  GLuint index;
ALIAS:
  glVertexAttrib4NubvARB_p = 1
  glVertexAttrib4ubvNV_p = 2
CODE:
  OGLM_GLEWINIT
  OGLM_CHECK_ERR(glVertexAttrib4Nubv, )
  OGLM_AVAIL_CHECK(__glewVertexAttrib4Nubv, glVertexAttrib4Nubv)
  GLubyte* v = OGLM_GET_VARARGS(v,1,GLubyte,UV,4);
  glVertexAttrib4Nubv((GLuint )index, (const GLubyte* )v);
  OGLM_CHECK_ERR(glVertexAttrib4Nubv, free(v);)
  free(v);

void
glVertexAttrib4Nuiv_c(index, v)
  GLuint index;
  const GLuint* v;
ALIAS:
  glVertexAttrib4NuivARB_c = 1
CODE:
  OGLM_GLEWINIT
  OGLM_CHECK_ERR(glVertexAttrib4Nuiv, )
  OGLM_AVAIL_CHECK(__glewVertexAttrib4Nuiv, glVertexAttrib4Nuiv)
  glVertexAttrib4Nuiv(index, v);
  OGLM_CHECK_ERR(glVertexAttrib4Nuiv, )

void
glVertexAttrib4Nuiv_p(index, ...)
  GLuint index;
ALIAS:
  glVertexAttrib4NuivARB_p = 1
CODE:
  OGLM_GLEWINIT
  OGLM_CHECK_ERR(glVertexAttrib4Nuiv, )
  OGLM_AVAIL_CHECK(__glewVertexAttrib4Nuiv, glVertexAttrib4Nuiv)
  GLuint* v = OGLM_GET_VARARGS(v,1,GLuint,UV,4);
  glVertexAttrib4Nuiv((GLuint )index, (const GLuint* )v);
  OGLM_CHECK_ERR(glVertexAttrib4Nuiv, free(v);)
  free(v);

void
glVertexAttrib4Nusv_c(index, v)
  GLuint index;
  const GLushort* v;
ALIAS:
  glVertexAttrib4NusvARB_c = 1
CODE:
  OGLM_GLEWINIT
  OGLM_CHECK_ERR(glVertexAttrib4Nusv, )
  OGLM_AVAIL_CHECK(__glewVertexAttrib4Nusv, glVertexAttrib4Nusv)
  glVertexAttrib4Nusv(index, v);
  OGLM_CHECK_ERR(glVertexAttrib4Nusv, )

void
glVertexAttrib4Nusv_p(index, ...)
  GLuint index;
ALIAS:
  glVertexAttrib4NusvARB_p = 1
CODE:
  OGLM_GLEWINIT
  OGLM_CHECK_ERR(glVertexAttrib4Nusv, )
  OGLM_AVAIL_CHECK(__glewVertexAttrib4Nusv, glVertexAttrib4Nusv)
  GLushort* v = OGLM_GET_VARARGS(v,1,GLushort,UV,4);
  glVertexAttrib4Nusv((GLuint )index, (const GLushort* )v);
  OGLM_CHECK_ERR(glVertexAttrib4Nusv, free(v);)
  free(v);

void
glVertexAttrib4bv_c(index, v)
  GLuint index;
  const GLbyte* v;
ALIAS:
  glVertexAttrib4bvARB_c = 1
CODE:
  OGLM_GLEWINIT
  OGLM_CHECK_ERR(glVertexAttrib4bv, )
  OGLM_AVAIL_CHECK(__glewVertexAttrib4bv, glVertexAttrib4bv)
  glVertexAttrib4bv(index, v);
  OGLM_CHECK_ERR(glVertexAttrib4bv, )

void
glVertexAttrib4bv_p(index, ...)
  GLuint index;
ALIAS:
  glVertexAttrib4bvARB_p = 1
CODE:
  OGLM_GLEWINIT
  OGLM_CHECK_ERR(glVertexAttrib4bv, )
  OGLM_AVAIL_CHECK(__glewVertexAttrib4bv, glVertexAttrib4bv)
  GLbyte* v = OGLM_GET_VARARGS(v,1,GLbyte,IV,4);
  glVertexAttrib4bv((GLuint )index, (const GLbyte* )v);
  OGLM_CHECK_ERR(glVertexAttrib4bv, free(v);)
  free(v);

void
glVertexAttrib4d(index, x, y, z, w)
  GLuint index;
  GLdouble x;
  GLdouble y;
  GLdouble z;
  GLdouble w;
ALIAS:
  glVertexAttrib4dARB = 1
  glVertexAttrib4dNV = 2
CODE:
  OGLM_GLEWINIT
  OGLM_CHECK_ERR(glVertexAttrib4d, )
  OGLM_AVAIL_CHECK(__glewVertexAttrib4d, glVertexAttrib4d)
  glVertexAttrib4d(index, x, y, z, w);
  OGLM_CHECK_ERR(glVertexAttrib4d, )

void
glVertexAttrib4dv_c(index, v)
  GLuint index;
  const GLdouble* v;
ALIAS:
  glVertexAttrib4dvARB_c = 1
  glVertexAttrib4dvNV_c = 2
CODE:
  OGLM_GLEWINIT
  OGLM_CHECK_ERR(glVertexAttrib4dv, )
  OGLM_AVAIL_CHECK(__glewVertexAttrib4dv, glVertexAttrib4dv)
  glVertexAttrib4dv(index, v);
  OGLM_CHECK_ERR(glVertexAttrib4dv, )

void
glVertexAttrib4dv_p(index, ...)
  GLuint index;
ALIAS:
  glVertexAttrib4dvARB_p = 1
  glVertexAttrib4dvNV_p = 2
CODE:
  OGLM_GLEWINIT
  OGLM_CHECK_ERR(glVertexAttrib4dv, )
  OGLM_AVAIL_CHECK(__glewVertexAttrib4dv, glVertexAttrib4dv)
  GLdouble* v = OGLM_GET_VARARGS(v,1,GLdouble,NV,4);
  glVertexAttrib4dv((GLuint )index, (const GLdouble* )v);
  OGLM_CHECK_ERR(glVertexAttrib4dv, free(v);)
  free(v);

void
glVertexAttrib4f(index, x, y, z, w)
  GLuint index;
  GLfloat x;
  GLfloat y;
  GLfloat z;
  GLfloat w;
ALIAS:
  glVertexAttrib4fARB = 1
  glVertexAttrib4fNV = 2
CODE:
  OGLM_GLEWINIT
  OGLM_CHECK_ERR(glVertexAttrib4f, )
  OGLM_AVAIL_CHECK(__glewVertexAttrib4f, glVertexAttrib4f)
  glVertexAttrib4f(index, x, y, z, w);
  OGLM_CHECK_ERR(glVertexAttrib4f, )

void
glVertexAttrib4fv_c(index, v)
  GLuint index;
  const GLfloat* v;
ALIAS:
  glVertexAttrib4fvARB_c = 1
  glVertexAttrib4fvNV_c = 2
CODE:
  OGLM_GLEWINIT
  OGLM_CHECK_ERR(glVertexAttrib4fv, )
  OGLM_AVAIL_CHECK(__glewVertexAttrib4fv, glVertexAttrib4fv)
  glVertexAttrib4fv(index, v);
  OGLM_CHECK_ERR(glVertexAttrib4fv, )

void
glVertexAttrib4fv_p(index, ...)
  GLuint index;
ALIAS:
  glVertexAttrib4fvARB_p = 1
  glVertexAttrib4fvNV_p = 2
CODE:
  OGLM_GLEWINIT
  OGLM_CHECK_ERR(glVertexAttrib4fv, )
  OGLM_AVAIL_CHECK(__glewVertexAttrib4fv, glVertexAttrib4fv)
  GLfloat* v = OGLM_GET_VARARGS(v,1,GLfloat,NV,4);
  glVertexAttrib4fv((GLuint )index, (const GLfloat* )v);
  OGLM_CHECK_ERR(glVertexAttrib4fv, free(v);)
  free(v);

void
glVertexAttrib4hNV(index, x, y, z, w)
  GLuint index;
  GLhalf x;
  GLhalf y;
  GLhalf z;
  GLhalf w;
CODE:
  OGLM_GLEWINIT
  OGLM_CHECK_ERR(glVertexAttrib4hNV, )
  OGLM_AVAIL_CHECK(__glewVertexAttrib4hNV, glVertexAttrib4hNV)
  glVertexAttrib4hNV(index, x, y, z, w);
  OGLM_CHECK_ERR(glVertexAttrib4hNV, )

void
glVertexAttrib4hvNV_c(index, v)
  GLuint index;
  const GLhalf* v;
CODE:
  OGLM_GLEWINIT
  OGLM_CHECK_ERR(glVertexAttrib4hvNV, )
  OGLM_AVAIL_CHECK(__glewVertexAttrib4hvNV, glVertexAttrib4hvNV)
  glVertexAttrib4hvNV(index, v);
  OGLM_CHECK_ERR(glVertexAttrib4hvNV, )

void
glVertexAttrib4hvNV_p(index, ...)
  GLuint index;
CODE:
  OGLM_GLEWINIT
  OGLM_CHECK_ERR(glVertexAttrib4hvNV, )
  OGLM_AVAIL_CHECK(__glewVertexAttrib4hvNV, glVertexAttrib4hvNV)
  GLhalf* v = OGLM_GET_VARARGS(v,1,GLhalf,NV,4);
  glVertexAttrib4hvNV((GLuint )index, (const GLhalf* )v);
  OGLM_CHECK_ERR(glVertexAttrib4hvNV, free(v);)
  free(v);

void
glVertexAttrib4iv_c(index, v)
  GLuint index;
  const GLint* v;
ALIAS:
  glVertexAttrib4ivARB_c = 1
CODE:
  OGLM_GLEWINIT
  OGLM_CHECK_ERR(glVertexAttrib4iv, )
  OGLM_AVAIL_CHECK(__glewVertexAttrib4iv, glVertexAttrib4iv)
  glVertexAttrib4iv(index, v);
  OGLM_CHECK_ERR(glVertexAttrib4iv, )

void
glVertexAttrib4iv_p(index, ...)
  GLuint index;
ALIAS:
  glVertexAttrib4ivARB_p = 1
CODE:
  OGLM_GLEWINIT
  OGLM_CHECK_ERR(glVertexAttrib4iv, )
  OGLM_AVAIL_CHECK(__glewVertexAttrib4iv, glVertexAttrib4iv)
  GLint* v = OGLM_GET_VARARGS(v,1,GLint,IV,4);
  glVertexAttrib4iv((GLuint )index, (const GLint* )v);
  OGLM_CHECK_ERR(glVertexAttrib4iv, free(v);)
  free(v);

void
glVertexAttrib4s(index, x, y, z, w)
  GLuint index;
  GLshort x;
  GLshort y;
  GLshort z;
  GLshort w;
ALIAS:
  glVertexAttrib4sARB = 1
  glVertexAttrib4sNV = 2
CODE:
  OGLM_GLEWINIT
  OGLM_CHECK_ERR(glVertexAttrib4s, )
  OGLM_AVAIL_CHECK(__glewVertexAttrib4s, glVertexAttrib4s)
  glVertexAttrib4s(index, x, y, z, w);
  OGLM_CHECK_ERR(glVertexAttrib4s, )

void
glVertexAttrib4sv_c(index, v)
  GLuint index;
  const GLshort* v;
ALIAS:
  glVertexAttrib4svARB_c = 1
  glVertexAttrib4svNV_c = 2
CODE:
  OGLM_GLEWINIT
  OGLM_CHECK_ERR(glVertexAttrib4sv, )
  OGLM_AVAIL_CHECK(__glewVertexAttrib4sv, glVertexAttrib4sv)
  glVertexAttrib4sv(index, v);
  OGLM_CHECK_ERR(glVertexAttrib4sv, )

void
glVertexAttrib4sv_p(index, ...)
  GLuint index;
ALIAS:
  glVertexAttrib4svARB_p = 1
  glVertexAttrib4svNV_p = 2
CODE:
  OGLM_GLEWINIT
  OGLM_CHECK_ERR(glVertexAttrib4sv, )
  OGLM_AVAIL_CHECK(__glewVertexAttrib4sv, glVertexAttrib4sv)
  GLshort* v = OGLM_GET_VARARGS(v,1,GLshort,IV,4);
  glVertexAttrib4sv((GLuint )index, (const GLshort* )v);
  OGLM_CHECK_ERR(glVertexAttrib4sv, free(v);)
  free(v);

void
glVertexAttrib4ubv_c(index, v)
  GLuint index;
  const GLubyte* v;
ALIAS:
  glVertexAttrib4ubvARB_c = 1
CODE:
  OGLM_GLEWINIT
  OGLM_CHECK_ERR(glVertexAttrib4ubv, )
  OGLM_AVAIL_CHECK(__glewVertexAttrib4ubv, glVertexAttrib4ubv)
  glVertexAttrib4ubv(index, v);
  OGLM_CHECK_ERR(glVertexAttrib4ubv, )

void
glVertexAttrib4ubv_p(index, ...)
  GLuint index;
ALIAS:
  glVertexAttrib4ubvARB_p = 1
CODE:
  OGLM_GLEWINIT
  OGLM_CHECK_ERR(glVertexAttrib4ubv, )
  OGLM_AVAIL_CHECK(__glewVertexAttrib4ubv, glVertexAttrib4ubv)
  GLubyte* v = OGLM_GET_VARARGS(v,1,GLubyte,UV,4);
  glVertexAttrib4ubv((GLuint )index, (const GLubyte* )v);
  OGLM_CHECK_ERR(glVertexAttrib4ubv, free(v);)
  free(v);

void
glVertexAttrib4uiv_c(index, v)
  GLuint index;
  const GLuint* v;
ALIAS:
  glVertexAttrib4uivARB_c = 1
CODE:
  OGLM_GLEWINIT
  OGLM_CHECK_ERR(glVertexAttrib4uiv, )
  OGLM_AVAIL_CHECK(__glewVertexAttrib4uiv, glVertexAttrib4uiv)
  glVertexAttrib4uiv(index, v);
  OGLM_CHECK_ERR(glVertexAttrib4uiv, )

void
glVertexAttrib4uiv_p(index, ...)
  GLuint index;
ALIAS:
  glVertexAttrib4uivARB_p = 1
CODE:
  OGLM_GLEWINIT
  OGLM_CHECK_ERR(glVertexAttrib4uiv, )
  OGLM_AVAIL_CHECK(__glewVertexAttrib4uiv, glVertexAttrib4uiv)
  GLuint* v = OGLM_GET_VARARGS(v,1,GLuint,UV,4);
  glVertexAttrib4uiv((GLuint )index, (const GLuint* )v);
  OGLM_CHECK_ERR(glVertexAttrib4uiv, free(v);)
  free(v);

void
glVertexAttrib4usv_c(index, v)
  GLuint index;
  const GLushort* v;
ALIAS:
  glVertexAttrib4usvARB_c = 1
CODE:
  OGLM_GLEWINIT
  OGLM_CHECK_ERR(glVertexAttrib4usv, )
  OGLM_AVAIL_CHECK(__glewVertexAttrib4usv, glVertexAttrib4usv)
  glVertexAttrib4usv(index, v);
  OGLM_CHECK_ERR(glVertexAttrib4usv, )

void
glVertexAttrib4usv_p(index, ...)
  GLuint index;
ALIAS:
  glVertexAttrib4usvARB_p = 1
CODE:
  OGLM_GLEWINIT
  OGLM_CHECK_ERR(glVertexAttrib4usv, )
  OGLM_AVAIL_CHECK(__glewVertexAttrib4usv, glVertexAttrib4usv)
  GLushort* v = OGLM_GET_VARARGS(v,1,GLushort,UV,4);
  glVertexAttrib4usv((GLuint )index, (const GLushort* )v);
  OGLM_CHECK_ERR(glVertexAttrib4usv, free(v);)
  free(v);

void
glVertexAttribArrayObjectATI(index, size, type, normalized, stride, buffer, offset)
  GLuint index;
  GLint size;
  GLenum type;
  GLboolean normalized;
  GLsizei stride;
  GLuint buffer;
  GLuint offset;
CODE:
  OGLM_GLEWINIT
  OGLM_CHECK_ERR(glVertexAttribArrayObjectATI, )
  OGLM_AVAIL_CHECK(__glewVertexAttribArrayObjectATI, glVertexAttribArrayObjectATI)
  glVertexAttribArrayObjectATI(index, size, type, normalized, stride, buffer, offset);
  OGLM_CHECK_ERR(glVertexAttribArrayObjectATI, )

void
glVertexAttribBinding(attribindex, bindingindex)
  GLuint attribindex;
  GLuint bindingindex;
CODE:
  OGLM_GLEWINIT
  OGLM_CHECK_ERR(glVertexAttribBinding, )
  OGLM_AVAIL_CHECK(__glewVertexAttribBinding, glVertexAttribBinding)
  glVertexAttribBinding(attribindex, bindingindex);
  OGLM_CHECK_ERR(glVertexAttribBinding, )

void
glVertexAttribDivisor(index, divisor)
  GLuint index;
  GLuint divisor;
ALIAS:
  glVertexAttribDivisorANGLE = 1
  glVertexAttribDivisorARB = 2
  glVertexAttribDivisorEXT = 3
  glVertexAttribDivisorNV = 4
CODE:
  OGLM_GLEWINIT
  OGLM_CHECK_ERR(glVertexAttribDivisor, )
  OGLM_AVAIL_CHECK(__glewVertexAttribDivisor, glVertexAttribDivisor)
  glVertexAttribDivisor(index, divisor);
  OGLM_CHECK_ERR(glVertexAttribDivisor, )

void
glVertexAttribFormat(attribindex, size, type, normalized, relativeoffset)
  GLuint attribindex;
  GLint size;
  GLenum type;
  GLboolean normalized;
  GLuint relativeoffset;
CODE:
  OGLM_GLEWINIT
  OGLM_CHECK_ERR(glVertexAttribFormat, )
  OGLM_AVAIL_CHECK(__glewVertexAttribFormat, glVertexAttribFormat)
  glVertexAttribFormat(attribindex, size, type, normalized, relativeoffset);
  OGLM_CHECK_ERR(glVertexAttribFormat, )

void
glVertexAttribFormatNV(index, size, type, normalized, stride)
  GLuint index;
  GLint size;
  GLenum type;
  GLboolean normalized;
  GLsizei stride;
CODE:
  OGLM_GLEWINIT
  OGLM_CHECK_ERR(glVertexAttribFormatNV, )
  OGLM_AVAIL_CHECK(__glewVertexAttribFormatNV, glVertexAttribFormatNV)
  glVertexAttribFormatNV(index, size, type, normalized, stride);
  OGLM_CHECK_ERR(glVertexAttribFormatNV, )

void
glVertexAttribI1i(index, v0)
  GLuint index;
  GLint v0;
ALIAS:
  glVertexAttribI1iEXT = 1
CODE:
  OGLM_GLEWINIT
  OGLM_CHECK_ERR(glVertexAttribI1i, )
  OGLM_AVAIL_CHECK(__glewVertexAttribI1i, glVertexAttribI1i)
  glVertexAttribI1i(index, v0);
  OGLM_CHECK_ERR(glVertexAttribI1i, )

void
glVertexAttribI1iv_c(index, v)
  GLuint index;
  const GLint* v;
ALIAS:
  glVertexAttribI1ivEXT_c = 1
CODE:
  OGLM_GLEWINIT
  OGLM_CHECK_ERR(glVertexAttribI1iv, )
  OGLM_AVAIL_CHECK(__glewVertexAttribI1iv, glVertexAttribI1iv)
  glVertexAttribI1iv(index, v);
  OGLM_CHECK_ERR(glVertexAttribI1iv, )

void
glVertexAttribI1iv_p(index, ...)
  GLuint index;
ALIAS:
  glVertexAttribI1ivEXT_p = 1
CODE:
  OGLM_GLEWINIT
  OGLM_CHECK_ERR(glVertexAttribI1iv, )
  OGLM_AVAIL_CHECK(__glewVertexAttribI1iv, glVertexAttribI1iv)
  GLint* v = OGLM_GET_VARARGS(v,1,GLint,IV,1);
  glVertexAttribI1iv((GLuint )index, (const GLint* )v);
  OGLM_CHECK_ERR(glVertexAttribI1iv, free(v);)
  free(v);

void
glVertexAttribI1ui(index, v0)
  GLuint index;
  GLuint v0;
ALIAS:
  glVertexAttribI1uiEXT = 1
CODE:
  OGLM_GLEWINIT
  OGLM_CHECK_ERR(glVertexAttribI1ui, )
  OGLM_AVAIL_CHECK(__glewVertexAttribI1ui, glVertexAttribI1ui)
  glVertexAttribI1ui(index, v0);
  OGLM_CHECK_ERR(glVertexAttribI1ui, )

void
glVertexAttribI1uiv_c(index, v)
  GLuint index;
  const GLuint* v;
ALIAS:
  glVertexAttribI1uivEXT_c = 1
CODE:
  OGLM_GLEWINIT
  OGLM_CHECK_ERR(glVertexAttribI1uiv, )
  OGLM_AVAIL_CHECK(__glewVertexAttribI1uiv, glVertexAttribI1uiv)
  glVertexAttribI1uiv(index, v);
  OGLM_CHECK_ERR(glVertexAttribI1uiv, )

void
glVertexAttribI1uiv_p(index, ...)
  GLuint index;
ALIAS:
  glVertexAttribI1uivEXT_p = 1
CODE:
  OGLM_GLEWINIT
  OGLM_CHECK_ERR(glVertexAttribI1uiv, )
  OGLM_AVAIL_CHECK(__glewVertexAttribI1uiv, glVertexAttribI1uiv)
  GLuint* v = OGLM_GET_VARARGS(v,1,GLuint,UV,1);
  glVertexAttribI1uiv((GLuint )index, (const GLuint* )v);
  OGLM_CHECK_ERR(glVertexAttribI1uiv, free(v);)
  free(v);

void
glVertexAttribI2i(index, v0, v1)
  GLuint index;
  GLint v0;
  GLint v1;
ALIAS:
  glVertexAttribI2iEXT = 1
CODE:
  OGLM_GLEWINIT
  OGLM_CHECK_ERR(glVertexAttribI2i, )
  OGLM_AVAIL_CHECK(__glewVertexAttribI2i, glVertexAttribI2i)
  glVertexAttribI2i(index, v0, v1);
  OGLM_CHECK_ERR(glVertexAttribI2i, )

void
glVertexAttribI2iv_c(index, v)
  GLuint index;
  const GLint* v;
ALIAS:
  glVertexAttribI2ivEXT_c = 1
CODE:
  OGLM_GLEWINIT
  OGLM_CHECK_ERR(glVertexAttribI2iv, )
  OGLM_AVAIL_CHECK(__glewVertexAttribI2iv, glVertexAttribI2iv)
  glVertexAttribI2iv(index, v);
  OGLM_CHECK_ERR(glVertexAttribI2iv, )

void
glVertexAttribI2iv_p(index, ...)
  GLuint index;
ALIAS:
  glVertexAttribI2ivEXT_p = 1
CODE:
  OGLM_GLEWINIT
  OGLM_CHECK_ERR(glVertexAttribI2iv, )
  OGLM_AVAIL_CHECK(__glewVertexAttribI2iv, glVertexAttribI2iv)
  GLint* v = OGLM_GET_VARARGS(v,1,GLint,IV,2);
  glVertexAttribI2iv((GLuint )index, (const GLint* )v);
  OGLM_CHECK_ERR(glVertexAttribI2iv, free(v);)
  free(v);

void
glVertexAttribI2ui(index, v0, v1)
  GLuint index;
  GLuint v0;
  GLuint v1;
ALIAS:
  glVertexAttribI2uiEXT = 1
CODE:
  OGLM_GLEWINIT
  OGLM_CHECK_ERR(glVertexAttribI2ui, )
  OGLM_AVAIL_CHECK(__glewVertexAttribI2ui, glVertexAttribI2ui)
  glVertexAttribI2ui(index, v0, v1);
  OGLM_CHECK_ERR(glVertexAttribI2ui, )

void
glVertexAttribI2uiv_c(index, v)
  GLuint index;
  const GLuint* v;
ALIAS:
  glVertexAttribI2uivEXT_c = 1
CODE:
  OGLM_GLEWINIT
  OGLM_CHECK_ERR(glVertexAttribI2uiv, )
  OGLM_AVAIL_CHECK(__glewVertexAttribI2uiv, glVertexAttribI2uiv)
  glVertexAttribI2uiv(index, v);
  OGLM_CHECK_ERR(glVertexAttribI2uiv, )

void
glVertexAttribI2uiv_p(index, ...)
  GLuint index;
ALIAS:
  glVertexAttribI2uivEXT_p = 1
CODE:
  OGLM_GLEWINIT
  OGLM_CHECK_ERR(glVertexAttribI2uiv, )
  OGLM_AVAIL_CHECK(__glewVertexAttribI2uiv, glVertexAttribI2uiv)
  GLuint* v = OGLM_GET_VARARGS(v,1,GLuint,UV,2);
  glVertexAttribI2uiv((GLuint )index, (const GLuint* )v);
  OGLM_CHECK_ERR(glVertexAttribI2uiv, free(v);)
  free(v);

void
glVertexAttribI3i(index, v0, v1, v2)
  GLuint index;
  GLint v0;
  GLint v1;
  GLint v2;
ALIAS:
  glVertexAttribI3iEXT = 1
CODE:
  OGLM_GLEWINIT
  OGLM_CHECK_ERR(glVertexAttribI3i, )
  OGLM_AVAIL_CHECK(__glewVertexAttribI3i, glVertexAttribI3i)
  glVertexAttribI3i(index, v0, v1, v2);
  OGLM_CHECK_ERR(glVertexAttribI3i, )

void
glVertexAttribI3iv_c(index, v)
  GLuint index;
  const GLint* v;
ALIAS:
  glVertexAttribI3ivEXT_c = 1
CODE:
  OGLM_GLEWINIT
  OGLM_CHECK_ERR(glVertexAttribI3iv, )
  OGLM_AVAIL_CHECK(__glewVertexAttribI3iv, glVertexAttribI3iv)
  glVertexAttribI3iv(index, v);
  OGLM_CHECK_ERR(glVertexAttribI3iv, )

void
glVertexAttribI3iv_p(index, ...)
  GLuint index;
ALIAS:
  glVertexAttribI3ivEXT_p = 1
CODE:
  OGLM_GLEWINIT
  OGLM_CHECK_ERR(glVertexAttribI3iv, )
  OGLM_AVAIL_CHECK(__glewVertexAttribI3iv, glVertexAttribI3iv)
  GLint* v = OGLM_GET_VARARGS(v,1,GLint,IV,3);
  glVertexAttribI3iv((GLuint )index, (const GLint* )v);
  OGLM_CHECK_ERR(glVertexAttribI3iv, free(v);)
  free(v);

void
glVertexAttribI3ui(index, v0, v1, v2)
  GLuint index;
  GLuint v0;
  GLuint v1;
  GLuint v2;
ALIAS:
  glVertexAttribI3uiEXT = 1
CODE:
  OGLM_GLEWINIT
  OGLM_CHECK_ERR(glVertexAttribI3ui, )
  OGLM_AVAIL_CHECK(__glewVertexAttribI3ui, glVertexAttribI3ui)
  glVertexAttribI3ui(index, v0, v1, v2);
  OGLM_CHECK_ERR(glVertexAttribI3ui, )

void
glVertexAttribI3uiv_c(index, v)
  GLuint index;
  const GLuint* v;
ALIAS:
  glVertexAttribI3uivEXT_c = 1
CODE:
  OGLM_GLEWINIT
  OGLM_CHECK_ERR(glVertexAttribI3uiv, )
  OGLM_AVAIL_CHECK(__glewVertexAttribI3uiv, glVertexAttribI3uiv)
  glVertexAttribI3uiv(index, v);
  OGLM_CHECK_ERR(glVertexAttribI3uiv, )

void
glVertexAttribI3uiv_p(index, ...)
  GLuint index;
ALIAS:
  glVertexAttribI3uivEXT_p = 1
CODE:
  OGLM_GLEWINIT
  OGLM_CHECK_ERR(glVertexAttribI3uiv, )
  OGLM_AVAIL_CHECK(__glewVertexAttribI3uiv, glVertexAttribI3uiv)
  GLuint* v = OGLM_GET_VARARGS(v,1,GLuint,UV,3);
  glVertexAttribI3uiv((GLuint )index, (const GLuint* )v);
  OGLM_CHECK_ERR(glVertexAttribI3uiv, free(v);)
  free(v);

void
glVertexAttribI4bv_c(index, v)
  GLuint index;
  const GLbyte* v;
ALIAS:
  glVertexAttribI4bvEXT_c = 1
CODE:
  OGLM_GLEWINIT
  OGLM_CHECK_ERR(glVertexAttribI4bv, )
  OGLM_AVAIL_CHECK(__glewVertexAttribI4bv, glVertexAttribI4bv)
  glVertexAttribI4bv(index, v);
  OGLM_CHECK_ERR(glVertexAttribI4bv, )

void
glVertexAttribI4bv_p(index, ...)
  GLuint index;
ALIAS:
  glVertexAttribI4bvEXT_p = 1
CODE:
  OGLM_GLEWINIT
  OGLM_CHECK_ERR(glVertexAttribI4bv, )
  OGLM_AVAIL_CHECK(__glewVertexAttribI4bv, glVertexAttribI4bv)
  GLbyte* v = OGLM_GET_VARARGS(v,1,GLbyte,IV,4);
  glVertexAttribI4bv((GLuint )index, (const GLbyte* )v);
  OGLM_CHECK_ERR(glVertexAttribI4bv, free(v);)
  free(v);

void
glVertexAttribI4i(index, v0, v1, v2, v3)
  GLuint index;
  GLint v0;
  GLint v1;
  GLint v2;
  GLint v3;
ALIAS:
  glVertexAttribI4iEXT = 1
CODE:
  OGLM_GLEWINIT
  OGLM_CHECK_ERR(glVertexAttribI4i, )
  OGLM_AVAIL_CHECK(__glewVertexAttribI4i, glVertexAttribI4i)
  glVertexAttribI4i(index, v0, v1, v2, v3);
  OGLM_CHECK_ERR(glVertexAttribI4i, )

void
glVertexAttribI4iv_c(index, v)
  GLuint index;
  const GLint* v;
ALIAS:
  glVertexAttribI4ivEXT_c = 1
CODE:
  OGLM_GLEWINIT
  OGLM_CHECK_ERR(glVertexAttribI4iv, )
  OGLM_AVAIL_CHECK(__glewVertexAttribI4iv, glVertexAttribI4iv)
  glVertexAttribI4iv(index, v);
  OGLM_CHECK_ERR(glVertexAttribI4iv, )

void
glVertexAttribI4iv_p(index, ...)
  GLuint index;
ALIAS:
  glVertexAttribI4ivEXT_p = 1
CODE:
  OGLM_GLEWINIT
  OGLM_CHECK_ERR(glVertexAttribI4iv, )
  OGLM_AVAIL_CHECK(__glewVertexAttribI4iv, glVertexAttribI4iv)
  GLint* v = OGLM_GET_VARARGS(v,1,GLint,IV,4);
  glVertexAttribI4iv((GLuint )index, (const GLint* )v);
  OGLM_CHECK_ERR(glVertexAttribI4iv, free(v);)
  free(v);

void
glVertexAttribI4sv_c(index, v)
  GLuint index;
  const GLshort* v;
ALIAS:
  glVertexAttribI4svEXT_c = 1
CODE:
  OGLM_GLEWINIT
  OGLM_CHECK_ERR(glVertexAttribI4sv, )
  OGLM_AVAIL_CHECK(__glewVertexAttribI4sv, glVertexAttribI4sv)
  glVertexAttribI4sv(index, v);
  OGLM_CHECK_ERR(glVertexAttribI4sv, )

void
glVertexAttribI4sv_p(index, ...)
  GLuint index;
ALIAS:
  glVertexAttribI4svEXT_p = 1
CODE:
  OGLM_GLEWINIT
  OGLM_CHECK_ERR(glVertexAttribI4sv, )
  OGLM_AVAIL_CHECK(__glewVertexAttribI4sv, glVertexAttribI4sv)
  GLshort* v = OGLM_GET_VARARGS(v,1,GLshort,IV,4);
  glVertexAttribI4sv((GLuint )index, (const GLshort* )v);
  OGLM_CHECK_ERR(glVertexAttribI4sv, free(v);)
  free(v);

void
glVertexAttribI4ubv_c(index, v)
  GLuint index;
  const GLubyte* v;
ALIAS:
  glVertexAttribI4ubvEXT_c = 1
CODE:
  OGLM_GLEWINIT
  OGLM_CHECK_ERR(glVertexAttribI4ubv, )
  OGLM_AVAIL_CHECK(__glewVertexAttribI4ubv, glVertexAttribI4ubv)
  glVertexAttribI4ubv(index, v);
  OGLM_CHECK_ERR(glVertexAttribI4ubv, )

void
glVertexAttribI4ubv_p(index, ...)
  GLuint index;
ALIAS:
  glVertexAttribI4ubvEXT_p = 1
CODE:
  OGLM_GLEWINIT
  OGLM_CHECK_ERR(glVertexAttribI4ubv, )
  OGLM_AVAIL_CHECK(__glewVertexAttribI4ubv, glVertexAttribI4ubv)
  GLubyte* v = OGLM_GET_VARARGS(v,1,GLubyte,UV,4);
  glVertexAttribI4ubv((GLuint )index, (const GLubyte* )v);
  OGLM_CHECK_ERR(glVertexAttribI4ubv, free(v);)
  free(v);

void
glVertexAttribI4ui(index, v0, v1, v2, v3)
  GLuint index;
  GLuint v0;
  GLuint v1;
  GLuint v2;
  GLuint v3;
ALIAS:
  glVertexAttribI4uiEXT = 1
CODE:
  OGLM_GLEWINIT
  OGLM_CHECK_ERR(glVertexAttribI4ui, )
  OGLM_AVAIL_CHECK(__glewVertexAttribI4ui, glVertexAttribI4ui)
  glVertexAttribI4ui(index, v0, v1, v2, v3);
  OGLM_CHECK_ERR(glVertexAttribI4ui, )

void
glVertexAttribI4uiv_c(index, v)
  GLuint index;
  const GLuint* v;
ALIAS:
  glVertexAttribI4uivEXT_c = 1
CODE:
  OGLM_GLEWINIT
  OGLM_CHECK_ERR(glVertexAttribI4uiv, )
  OGLM_AVAIL_CHECK(__glewVertexAttribI4uiv, glVertexAttribI4uiv)
  glVertexAttribI4uiv(index, v);
  OGLM_CHECK_ERR(glVertexAttribI4uiv, )

void
glVertexAttribI4uiv_p(index, ...)
  GLuint index;
ALIAS:
  glVertexAttribI4uivEXT_p = 1
CODE:
  OGLM_GLEWINIT
  OGLM_CHECK_ERR(glVertexAttribI4uiv, )
  OGLM_AVAIL_CHECK(__glewVertexAttribI4uiv, glVertexAttribI4uiv)
  GLuint* v = OGLM_GET_VARARGS(v,1,GLuint,UV,4);
  glVertexAttribI4uiv((GLuint )index, (const GLuint* )v);
  OGLM_CHECK_ERR(glVertexAttribI4uiv, free(v);)
  free(v);

void
glVertexAttribI4usv_c(index, v)
  GLuint index;
  const GLushort* v;
ALIAS:
  glVertexAttribI4usvEXT_c = 1
CODE:
  OGLM_GLEWINIT
  OGLM_CHECK_ERR(glVertexAttribI4usv, )
  OGLM_AVAIL_CHECK(__glewVertexAttribI4usv, glVertexAttribI4usv)
  glVertexAttribI4usv(index, v);
  OGLM_CHECK_ERR(glVertexAttribI4usv, )

void
glVertexAttribI4usv_p(index, ...)
  GLuint index;
ALIAS:
  glVertexAttribI4usvEXT_p = 1
CODE:
  OGLM_GLEWINIT
  OGLM_CHECK_ERR(glVertexAttribI4usv, )
  OGLM_AVAIL_CHECK(__glewVertexAttribI4usv, glVertexAttribI4usv)
  GLushort* v = OGLM_GET_VARARGS(v,1,GLushort,UV,4);
  glVertexAttribI4usv((GLuint )index, (const GLushort* )v);
  OGLM_CHECK_ERR(glVertexAttribI4usv, free(v);)
  free(v);

void
glVertexAttribIFormat(attribindex, size, type, relativeoffset)
  GLuint attribindex;
  GLint size;
  GLenum type;
  GLuint relativeoffset;
CODE:
  OGLM_GLEWINIT
  OGLM_CHECK_ERR(glVertexAttribIFormat, )
  OGLM_AVAIL_CHECK(__glewVertexAttribIFormat, glVertexAttribIFormat)
  glVertexAttribIFormat(attribindex, size, type, relativeoffset);
  OGLM_CHECK_ERR(glVertexAttribIFormat, )

void
glVertexAttribIFormatNV(index, size, type, stride)
  GLuint index;
  GLint size;
  GLenum type;
  GLsizei stride;
CODE:
  OGLM_GLEWINIT
  OGLM_CHECK_ERR(glVertexAttribIFormatNV, )
  OGLM_AVAIL_CHECK(__glewVertexAttribIFormatNV, glVertexAttribIFormatNV)
  glVertexAttribIFormatNV(index, size, type, stride);
  OGLM_CHECK_ERR(glVertexAttribIFormatNV, )

void
glVertexAttribIPointer_c(index, size, type, stride, pointer)
  GLuint index;
  GLint size;
  GLenum type;
  GLsizei stride;
  const void*pointer;
ALIAS:
  glVertexAttribIPointerEXT_c = 1
CODE:
  OGLM_GLEWINIT
  OGLM_CHECK_ERR(glVertexAttribIPointer, )
  OGLM_AVAIL_CHECK(__glewVertexAttribIPointer, glVertexAttribIPointer)
  glVertexAttribIPointer(index, size, type, stride, pointer);
  OGLM_CHECK_ERR(glVertexAttribIPointer, )

void
glVertexAttribL1d(index, x)
  GLuint index;
  GLdouble x;
ALIAS:
  glVertexAttribL1dEXT = 1
CODE:
  OGLM_GLEWINIT
  OGLM_CHECK_ERR(glVertexAttribL1d, )
  OGLM_AVAIL_CHECK(__glewVertexAttribL1d, glVertexAttribL1d)
  glVertexAttribL1d(index, x);
  OGLM_CHECK_ERR(glVertexAttribL1d, )

void
glVertexAttribL1dv_c(index, v)
  GLuint index;
  const GLdouble* v;
ALIAS:
  glVertexAttribL1dvEXT_c = 1
CODE:
  OGLM_GLEWINIT
  OGLM_CHECK_ERR(glVertexAttribL1dv, )
  OGLM_AVAIL_CHECK(__glewVertexAttribL1dv, glVertexAttribL1dv)
  glVertexAttribL1dv(index, v);
  OGLM_CHECK_ERR(glVertexAttribL1dv, )

void
glVertexAttribL1dv_p(index, ...)
  GLuint index;
ALIAS:
  glVertexAttribL1dvEXT_p = 1
CODE:
  OGLM_GLEWINIT
  OGLM_CHECK_ERR(glVertexAttribL1dv, )
  OGLM_AVAIL_CHECK(__glewVertexAttribL1dv, glVertexAttribL1dv)
  GLdouble* v = OGLM_GET_VARARGS(v,1,GLdouble,NV,1);
  glVertexAttribL1dv((GLuint )index, (const GLdouble* )v);
  OGLM_CHECK_ERR(glVertexAttribL1dv, free(v);)
  free(v);

void
glVertexAttribL1i64NV(index, x)
  GLuint index;
  GLint64EXT x;
CODE:
  OGLM_GLEWINIT
  OGLM_CHECK_ERR(glVertexAttribL1i64NV, )
  OGLM_AVAIL_CHECK(__glewVertexAttribL1i64NV, glVertexAttribL1i64NV)
  glVertexAttribL1i64NV(index, x);
  OGLM_CHECK_ERR(glVertexAttribL1i64NV, )

void
glVertexAttribL1i64vNV_c(index, v)
  GLuint index;
  const GLint64EXT* v;
CODE:
  OGLM_GLEWINIT
  OGLM_CHECK_ERR(glVertexAttribL1i64vNV, )
  OGLM_AVAIL_CHECK(__glewVertexAttribL1i64vNV, glVertexAttribL1i64vNV)
  glVertexAttribL1i64vNV(index, v);
  OGLM_CHECK_ERR(glVertexAttribL1i64vNV, )

void
glVertexAttribL1i64vNV_p(index, ...)
  GLuint index;
CODE:
  OGLM_GLEWINIT
  OGLM_CHECK_ERR(glVertexAttribL1i64vNV, )
  OGLM_AVAIL_CHECK(__glewVertexAttribL1i64vNV, glVertexAttribL1i64vNV)
  GLint64EXT* v = OGLM_GET_VARARGS(v,1,GLint64EXT,IV,1);
  glVertexAttribL1i64vNV((GLuint )index, (const GLint64EXT* )v);
  OGLM_CHECK_ERR(glVertexAttribL1i64vNV, free(v);)
  free(v);

void
glVertexAttribL1ui64ARB(index, x)
  GLuint index;
  GLuint64EXT x;
CODE:
  OGLM_GLEWINIT
  OGLM_CHECK_ERR(glVertexAttribL1ui64ARB, )
  OGLM_AVAIL_CHECK(__glewVertexAttribL1ui64ARB, glVertexAttribL1ui64ARB)
  glVertexAttribL1ui64ARB(index, x);
  OGLM_CHECK_ERR(glVertexAttribL1ui64ARB, )

void
glVertexAttribL1ui64NV(index, x)
  GLuint index;
  GLuint64EXT x;
CODE:
  OGLM_GLEWINIT
  OGLM_CHECK_ERR(glVertexAttribL1ui64NV, )
  OGLM_AVAIL_CHECK(__glewVertexAttribL1ui64NV, glVertexAttribL1ui64NV)
  glVertexAttribL1ui64NV(index, x);
  OGLM_CHECK_ERR(glVertexAttribL1ui64NV, )

void
glVertexAttribL1ui64vARB_c(index, v)
  GLuint index;
  const GLuint64EXT* v;
CODE:
  OGLM_GLEWINIT
  OGLM_CHECK_ERR(glVertexAttribL1ui64vARB, )
  OGLM_AVAIL_CHECK(__glewVertexAttribL1ui64vARB, glVertexAttribL1ui64vARB)
  glVertexAttribL1ui64vARB(index, v);
  OGLM_CHECK_ERR(glVertexAttribL1ui64vARB, )

void
glVertexAttribL1ui64vNV_c(index, v)
  GLuint index;
  const GLuint64EXT* v;
CODE:
  OGLM_GLEWINIT
  OGLM_CHECK_ERR(glVertexAttribL1ui64vNV, )
  OGLM_AVAIL_CHECK(__glewVertexAttribL1ui64vNV, glVertexAttribL1ui64vNV)
  glVertexAttribL1ui64vNV(index, v);
  OGLM_CHECK_ERR(glVertexAttribL1ui64vNV, )

void
glVertexAttribL1ui64vNV_p(index, ...)
  GLuint index;
CODE:
  OGLM_GLEWINIT
  OGLM_CHECK_ERR(glVertexAttribL1ui64vNV, )
  OGLM_AVAIL_CHECK(__glewVertexAttribL1ui64vNV, glVertexAttribL1ui64vNV)
  GLuint64EXT* v = OGLM_GET_VARARGS(v,1,GLuint64EXT,UV,1);
  glVertexAttribL1ui64vNV((GLuint )index, (const GLuint64EXT* )v);
  OGLM_CHECK_ERR(glVertexAttribL1ui64vNV, free(v);)
  free(v);

void
glVertexAttribL2d(index, x, y)
  GLuint index;
  GLdouble x;
  GLdouble y;
ALIAS:
  glVertexAttribL2dEXT = 1
CODE:
  OGLM_GLEWINIT
  OGLM_CHECK_ERR(glVertexAttribL2d, )
  OGLM_AVAIL_CHECK(__glewVertexAttribL2d, glVertexAttribL2d)
  glVertexAttribL2d(index, x, y);
  OGLM_CHECK_ERR(glVertexAttribL2d, )

void
glVertexAttribL2dv_c(index, v)
  GLuint index;
  const GLdouble* v;
ALIAS:
  glVertexAttribL2dvEXT_c = 1
CODE:
  OGLM_GLEWINIT
  OGLM_CHECK_ERR(glVertexAttribL2dv, )
  OGLM_AVAIL_CHECK(__glewVertexAttribL2dv, glVertexAttribL2dv)
  glVertexAttribL2dv(index, v);
  OGLM_CHECK_ERR(glVertexAttribL2dv, )

void
glVertexAttribL2dv_p(index, ...)
  GLuint index;
ALIAS:
  glVertexAttribL2dvEXT_p = 1
CODE:
  OGLM_GLEWINIT
  OGLM_CHECK_ERR(glVertexAttribL2dv, )
  OGLM_AVAIL_CHECK(__glewVertexAttribL2dv, glVertexAttribL2dv)
  GLdouble* v = OGLM_GET_VARARGS(v,1,GLdouble,NV,2);
  glVertexAttribL2dv((GLuint )index, (const GLdouble* )v);
  OGLM_CHECK_ERR(glVertexAttribL2dv, free(v);)
  free(v);

void
glVertexAttribL2i64NV(index, x, y)
  GLuint index;
  GLint64EXT x;
  GLint64EXT y;
CODE:
  OGLM_GLEWINIT
  OGLM_CHECK_ERR(glVertexAttribL2i64NV, )
  OGLM_AVAIL_CHECK(__glewVertexAttribL2i64NV, glVertexAttribL2i64NV)
  glVertexAttribL2i64NV(index, x, y);
  OGLM_CHECK_ERR(glVertexAttribL2i64NV, )

void
glVertexAttribL2i64vNV_c(index, v)
  GLuint index;
  const GLint64EXT* v;
CODE:
  OGLM_GLEWINIT
  OGLM_CHECK_ERR(glVertexAttribL2i64vNV, )
  OGLM_AVAIL_CHECK(__glewVertexAttribL2i64vNV, glVertexAttribL2i64vNV)
  glVertexAttribL2i64vNV(index, v);
  OGLM_CHECK_ERR(glVertexAttribL2i64vNV, )

void
glVertexAttribL2i64vNV_p(index, ...)
  GLuint index;
CODE:
  OGLM_GLEWINIT
  OGLM_CHECK_ERR(glVertexAttribL2i64vNV, )
  OGLM_AVAIL_CHECK(__glewVertexAttribL2i64vNV, glVertexAttribL2i64vNV)
  GLint64EXT* v = OGLM_GET_VARARGS(v,1,GLint64EXT,IV,2);
  glVertexAttribL2i64vNV((GLuint )index, (const GLint64EXT* )v);
  OGLM_CHECK_ERR(glVertexAttribL2i64vNV, free(v);)
  free(v);

void
glVertexAttribL2ui64NV(index, x, y)
  GLuint index;
  GLuint64EXT x;
  GLuint64EXT y;
CODE:
  OGLM_GLEWINIT
  OGLM_CHECK_ERR(glVertexAttribL2ui64NV, )
  OGLM_AVAIL_CHECK(__glewVertexAttribL2ui64NV, glVertexAttribL2ui64NV)
  glVertexAttribL2ui64NV(index, x, y);
  OGLM_CHECK_ERR(glVertexAttribL2ui64NV, )

void
glVertexAttribL2ui64vNV_c(index, v)
  GLuint index;
  const GLuint64EXT* v;
CODE:
  OGLM_GLEWINIT
  OGLM_CHECK_ERR(glVertexAttribL2ui64vNV, )
  OGLM_AVAIL_CHECK(__glewVertexAttribL2ui64vNV, glVertexAttribL2ui64vNV)
  glVertexAttribL2ui64vNV(index, v);
  OGLM_CHECK_ERR(glVertexAttribL2ui64vNV, )

void
glVertexAttribL2ui64vNV_p(index, ...)
  GLuint index;
CODE:
  OGLM_GLEWINIT
  OGLM_CHECK_ERR(glVertexAttribL2ui64vNV, )
  OGLM_AVAIL_CHECK(__glewVertexAttribL2ui64vNV, glVertexAttribL2ui64vNV)
  GLuint64EXT* v = OGLM_GET_VARARGS(v,1,GLuint64EXT,UV,2);
  glVertexAttribL2ui64vNV((GLuint )index, (const GLuint64EXT* )v);
  OGLM_CHECK_ERR(glVertexAttribL2ui64vNV, free(v);)
  free(v);

void
glVertexAttribL3d(index, x, y, z)
  GLuint index;
  GLdouble x;
  GLdouble y;
  GLdouble z;
ALIAS:
  glVertexAttribL3dEXT = 1
CODE:
  OGLM_GLEWINIT
  OGLM_CHECK_ERR(glVertexAttribL3d, )
  OGLM_AVAIL_CHECK(__glewVertexAttribL3d, glVertexAttribL3d)
  glVertexAttribL3d(index, x, y, z);
  OGLM_CHECK_ERR(glVertexAttribL3d, )

void
glVertexAttribL3dv_c(index, v)
  GLuint index;
  const GLdouble* v;
ALIAS:
  glVertexAttribL3dvEXT_c = 1
CODE:
  OGLM_GLEWINIT
  OGLM_CHECK_ERR(glVertexAttribL3dv, )
  OGLM_AVAIL_CHECK(__glewVertexAttribL3dv, glVertexAttribL3dv)
  glVertexAttribL3dv(index, v);
  OGLM_CHECK_ERR(glVertexAttribL3dv, )

void
glVertexAttribL3dv_p(index, ...)
  GLuint index;
ALIAS:
  glVertexAttribL3dvEXT_p = 1
CODE:
  OGLM_GLEWINIT
  OGLM_CHECK_ERR(glVertexAttribL3dv, )
  OGLM_AVAIL_CHECK(__glewVertexAttribL3dv, glVertexAttribL3dv)
  GLdouble* v = OGLM_GET_VARARGS(v,1,GLdouble,NV,3);
  glVertexAttribL3dv((GLuint )index, (const GLdouble* )v);
  OGLM_CHECK_ERR(glVertexAttribL3dv, free(v);)
  free(v);

void
glVertexAttribL3i64NV(index, x, y, z)
  GLuint index;
  GLint64EXT x;
  GLint64EXT y;
  GLint64EXT z;
CODE:
  OGLM_GLEWINIT
  OGLM_CHECK_ERR(glVertexAttribL3i64NV, )
  OGLM_AVAIL_CHECK(__glewVertexAttribL3i64NV, glVertexAttribL3i64NV)
  glVertexAttribL3i64NV(index, x, y, z);
  OGLM_CHECK_ERR(glVertexAttribL3i64NV, )

void
glVertexAttribL3i64vNV_c(index, v)
  GLuint index;
  const GLint64EXT* v;
CODE:
  OGLM_GLEWINIT
  OGLM_CHECK_ERR(glVertexAttribL3i64vNV, )
  OGLM_AVAIL_CHECK(__glewVertexAttribL3i64vNV, glVertexAttribL3i64vNV)
  glVertexAttribL3i64vNV(index, v);
  OGLM_CHECK_ERR(glVertexAttribL3i64vNV, )

void
glVertexAttribL3i64vNV_p(index, ...)
  GLuint index;
CODE:
  OGLM_GLEWINIT
  OGLM_CHECK_ERR(glVertexAttribL3i64vNV, )
  OGLM_AVAIL_CHECK(__glewVertexAttribL3i64vNV, glVertexAttribL3i64vNV)
  GLint64EXT* v = OGLM_GET_VARARGS(v,1,GLint64EXT,IV,3);
  glVertexAttribL3i64vNV((GLuint )index, (const GLint64EXT* )v);
  OGLM_CHECK_ERR(glVertexAttribL3i64vNV, free(v);)
  free(v);

void
glVertexAttribL3ui64NV(index, x, y, z)
  GLuint index;
  GLuint64EXT x;
  GLuint64EXT y;
  GLuint64EXT z;
CODE:
  OGLM_GLEWINIT
  OGLM_CHECK_ERR(glVertexAttribL3ui64NV, )
  OGLM_AVAIL_CHECK(__glewVertexAttribL3ui64NV, glVertexAttribL3ui64NV)
  glVertexAttribL3ui64NV(index, x, y, z);
  OGLM_CHECK_ERR(glVertexAttribL3ui64NV, )

void
glVertexAttribL3ui64vNV_c(index, v)
  GLuint index;
  const GLuint64EXT* v;
CODE:
  OGLM_GLEWINIT
  OGLM_CHECK_ERR(glVertexAttribL3ui64vNV, )
  OGLM_AVAIL_CHECK(__glewVertexAttribL3ui64vNV, glVertexAttribL3ui64vNV)
  glVertexAttribL3ui64vNV(index, v);
  OGLM_CHECK_ERR(glVertexAttribL3ui64vNV, )

void
glVertexAttribL3ui64vNV_p(index, ...)
  GLuint index;
CODE:
  OGLM_GLEWINIT
  OGLM_CHECK_ERR(glVertexAttribL3ui64vNV, )
  OGLM_AVAIL_CHECK(__glewVertexAttribL3ui64vNV, glVertexAttribL3ui64vNV)
  GLuint64EXT* v = OGLM_GET_VARARGS(v,1,GLuint64EXT,UV,3);
  glVertexAttribL3ui64vNV((GLuint )index, (const GLuint64EXT* )v);
  OGLM_CHECK_ERR(glVertexAttribL3ui64vNV, free(v);)
  free(v);

void
glVertexAttribL4d(index, x, y, z, w)
  GLuint index;
  GLdouble x;
  GLdouble y;
  GLdouble z;
  GLdouble w;
ALIAS:
  glVertexAttribL4dEXT = 1
CODE:
  OGLM_GLEWINIT
  OGLM_CHECK_ERR(glVertexAttribL4d, )
  OGLM_AVAIL_CHECK(__glewVertexAttribL4d, glVertexAttribL4d)
  glVertexAttribL4d(index, x, y, z, w);
  OGLM_CHECK_ERR(glVertexAttribL4d, )

void
glVertexAttribL4dv_c(index, v)
  GLuint index;
  const GLdouble* v;
ALIAS:
  glVertexAttribL4dvEXT_c = 1
CODE:
  OGLM_GLEWINIT
  OGLM_CHECK_ERR(glVertexAttribL4dv, )
  OGLM_AVAIL_CHECK(__glewVertexAttribL4dv, glVertexAttribL4dv)
  glVertexAttribL4dv(index, v);
  OGLM_CHECK_ERR(glVertexAttribL4dv, )

void
glVertexAttribL4dv_p(index, ...)
  GLuint index;
ALIAS:
  glVertexAttribL4dvEXT_p = 1
CODE:
  OGLM_GLEWINIT
  OGLM_CHECK_ERR(glVertexAttribL4dv, )
  OGLM_AVAIL_CHECK(__glewVertexAttribL4dv, glVertexAttribL4dv)
  GLdouble* v = OGLM_GET_VARARGS(v,1,GLdouble,NV,4);
  glVertexAttribL4dv((GLuint )index, (const GLdouble* )v);
  OGLM_CHECK_ERR(glVertexAttribL4dv, free(v);)
  free(v);

void
glVertexAttribL4i64NV(index, x, y, z, w)
  GLuint index;
  GLint64EXT x;
  GLint64EXT y;
  GLint64EXT z;
  GLint64EXT w;
CODE:
  OGLM_GLEWINIT
  OGLM_CHECK_ERR(glVertexAttribL4i64NV, )
  OGLM_AVAIL_CHECK(__glewVertexAttribL4i64NV, glVertexAttribL4i64NV)
  glVertexAttribL4i64NV(index, x, y, z, w);
  OGLM_CHECK_ERR(glVertexAttribL4i64NV, )

void
glVertexAttribL4i64vNV_c(index, v)
  GLuint index;
  const GLint64EXT* v;
CODE:
  OGLM_GLEWINIT
  OGLM_CHECK_ERR(glVertexAttribL4i64vNV, )
  OGLM_AVAIL_CHECK(__glewVertexAttribL4i64vNV, glVertexAttribL4i64vNV)
  glVertexAttribL4i64vNV(index, v);
  OGLM_CHECK_ERR(glVertexAttribL4i64vNV, )

void
glVertexAttribL4i64vNV_p(index, ...)
  GLuint index;
CODE:
  OGLM_GLEWINIT
  OGLM_CHECK_ERR(glVertexAttribL4i64vNV, )
  OGLM_AVAIL_CHECK(__glewVertexAttribL4i64vNV, glVertexAttribL4i64vNV)
  GLint64EXT* v = OGLM_GET_VARARGS(v,1,GLint64EXT,IV,4);
  glVertexAttribL4i64vNV((GLuint )index, (const GLint64EXT* )v);
  OGLM_CHECK_ERR(glVertexAttribL4i64vNV, free(v);)
  free(v);

void
glVertexAttribL4ui64NV(index, x, y, z, w)
  GLuint index;
  GLuint64EXT x;
  GLuint64EXT y;
  GLuint64EXT z;
  GLuint64EXT w;
CODE:
  OGLM_GLEWINIT
  OGLM_CHECK_ERR(glVertexAttribL4ui64NV, )
  OGLM_AVAIL_CHECK(__glewVertexAttribL4ui64NV, glVertexAttribL4ui64NV)
  glVertexAttribL4ui64NV(index, x, y, z, w);
  OGLM_CHECK_ERR(glVertexAttribL4ui64NV, )

void
glVertexAttribL4ui64vNV_c(index, v)
  GLuint index;
  const GLuint64EXT* v;
CODE:
  OGLM_GLEWINIT
  OGLM_CHECK_ERR(glVertexAttribL4ui64vNV, )
  OGLM_AVAIL_CHECK(__glewVertexAttribL4ui64vNV, glVertexAttribL4ui64vNV)
  glVertexAttribL4ui64vNV(index, v);
  OGLM_CHECK_ERR(glVertexAttribL4ui64vNV, )

void
glVertexAttribL4ui64vNV_p(index, ...)
  GLuint index;
CODE:
  OGLM_GLEWINIT
  OGLM_CHECK_ERR(glVertexAttribL4ui64vNV, )
  OGLM_AVAIL_CHECK(__glewVertexAttribL4ui64vNV, glVertexAttribL4ui64vNV)
  GLuint64EXT* v = OGLM_GET_VARARGS(v,1,GLuint64EXT,UV,4);
  glVertexAttribL4ui64vNV((GLuint )index, (const GLuint64EXT* )v);
  OGLM_CHECK_ERR(glVertexAttribL4ui64vNV, free(v);)
  free(v);

void
glVertexAttribLFormat(attribindex, size, type, relativeoffset)
  GLuint attribindex;
  GLint size;
  GLenum type;
  GLuint relativeoffset;
CODE:
  OGLM_GLEWINIT
  OGLM_CHECK_ERR(glVertexAttribLFormat, )
  OGLM_AVAIL_CHECK(__glewVertexAttribLFormat, glVertexAttribLFormat)
  glVertexAttribLFormat(attribindex, size, type, relativeoffset);
  OGLM_CHECK_ERR(glVertexAttribLFormat, )

void
glVertexAttribLFormatNV(index, size, type, stride)
  GLuint index;
  GLint size;
  GLenum type;
  GLsizei stride;
CODE:
  OGLM_GLEWINIT
  OGLM_CHECK_ERR(glVertexAttribLFormatNV, )
  OGLM_AVAIL_CHECK(__glewVertexAttribLFormatNV, glVertexAttribLFormatNV)
  glVertexAttribLFormatNV(index, size, type, stride);
  OGLM_CHECK_ERR(glVertexAttribLFormatNV, )

void
glVertexAttribLPointer_c(index, size, type, stride, pointer)
  GLuint index;
  GLint size;
  GLenum type;
  GLsizei stride;
  const void* pointer;
ALIAS:
  glVertexAttribLPointerEXT_c = 1
CODE:
  OGLM_GLEWINIT
  OGLM_CHECK_ERR(glVertexAttribLPointer, )
  OGLM_AVAIL_CHECK(__glewVertexAttribLPointer, glVertexAttribLPointer)
  glVertexAttribLPointer(index, size, type, stride, pointer);
  OGLM_CHECK_ERR(glVertexAttribLPointer, )

void
glVertexAttribP1ui(index, type, normalized, value)
  GLuint index;
  GLenum type;
  GLboolean normalized;
  GLuint value;
CODE:
  OGLM_GLEWINIT
  OGLM_CHECK_ERR(glVertexAttribP1ui, )
  OGLM_AVAIL_CHECK(__glewVertexAttribP1ui, glVertexAttribP1ui)
  glVertexAttribP1ui(index, type, normalized, value);
  OGLM_CHECK_ERR(glVertexAttribP1ui, )

void
glVertexAttribP1uiv_c(index, type, normalized, value)
  GLuint index;
  GLenum type;
  GLboolean normalized;
  const GLuint* value;
CODE:
  OGLM_GLEWINIT
  OGLM_CHECK_ERR(glVertexAttribP1uiv, )
  OGLM_AVAIL_CHECK(__glewVertexAttribP1uiv, glVertexAttribP1uiv)
  glVertexAttribP1uiv(index, type, normalized, value);
  OGLM_CHECK_ERR(glVertexAttribP1uiv, )

void
glVertexAttribP1uiv_p(index, type, normalized, ...)
  GLuint index;
  GLenum type;
  GLboolean normalized;
CODE:
  OGLM_GLEWINIT
  OGLM_CHECK_ERR(glVertexAttribP1uiv, )
  OGLM_AVAIL_CHECK(__glewVertexAttribP1uiv, glVertexAttribP1uiv)
  GLuint* value = OGLM_GET_VARARGS(value,3,GLuint,UV,1);
  glVertexAttribP1uiv((GLuint )index, (GLenum )type, (GLboolean )normalized, (const GLuint* )value);
  OGLM_CHECK_ERR(glVertexAttribP1uiv, free(value);)
  free(value);

void
glVertexAttribP2ui(index, type, normalized, value)
  GLuint index;
  GLenum type;
  GLboolean normalized;
  GLuint value;
CODE:
  OGLM_GLEWINIT
  OGLM_CHECK_ERR(glVertexAttribP2ui, )
  OGLM_AVAIL_CHECK(__glewVertexAttribP2ui, glVertexAttribP2ui)
  glVertexAttribP2ui(index, type, normalized, value);
  OGLM_CHECK_ERR(glVertexAttribP2ui, )

void
glVertexAttribP2uiv_c(index, type, normalized, value)
  GLuint index;
  GLenum type;
  GLboolean normalized;
  const GLuint* value;
CODE:
  OGLM_GLEWINIT
  OGLM_CHECK_ERR(glVertexAttribP2uiv, )
  OGLM_AVAIL_CHECK(__glewVertexAttribP2uiv, glVertexAttribP2uiv)
  glVertexAttribP2uiv(index, type, normalized, value);
  OGLM_CHECK_ERR(glVertexAttribP2uiv, )

void
glVertexAttribP2uiv_p(index, type, normalized, ...)
  GLuint index;
  GLenum type;
  GLboolean normalized;
CODE:
  OGLM_GLEWINIT
  OGLM_CHECK_ERR(glVertexAttribP2uiv, )
  OGLM_AVAIL_CHECK(__glewVertexAttribP2uiv, glVertexAttribP2uiv)
  GLuint* value = OGLM_GET_VARARGS(value,3,GLuint,UV,1);
  glVertexAttribP2uiv((GLuint )index, (GLenum )type, (GLboolean )normalized, (const GLuint* )value);
  OGLM_CHECK_ERR(glVertexAttribP2uiv, free(value);)
  free(value);

void
glVertexAttribP3ui(index, type, normalized, value)
  GLuint index;
  GLenum type;
  GLboolean normalized;
  GLuint value;
CODE:
  OGLM_GLEWINIT
  OGLM_CHECK_ERR(glVertexAttribP3ui, )
  OGLM_AVAIL_CHECK(__glewVertexAttribP3ui, glVertexAttribP3ui)
  glVertexAttribP3ui(index, type, normalized, value);
  OGLM_CHECK_ERR(glVertexAttribP3ui, )

void
glVertexAttribP3uiv_c(index, type, normalized, value)
  GLuint index;
  GLenum type;
  GLboolean normalized;
  const GLuint* value;
CODE:
  OGLM_GLEWINIT
  OGLM_CHECK_ERR(glVertexAttribP3uiv, )
  OGLM_AVAIL_CHECK(__glewVertexAttribP3uiv, glVertexAttribP3uiv)
  glVertexAttribP3uiv(index, type, normalized, value);
  OGLM_CHECK_ERR(glVertexAttribP3uiv, )

void
glVertexAttribP3uiv_p(index, type, normalized, ...)
  GLuint index;
  GLenum type;
  GLboolean normalized;
CODE:
  OGLM_GLEWINIT
  OGLM_CHECK_ERR(glVertexAttribP3uiv, )
  OGLM_AVAIL_CHECK(__glewVertexAttribP3uiv, glVertexAttribP3uiv)
  GLuint* value = OGLM_GET_VARARGS(value,3,GLuint,UV,1);
  glVertexAttribP3uiv((GLuint )index, (GLenum )type, (GLboolean )normalized, (const GLuint* )value);
  OGLM_CHECK_ERR(glVertexAttribP3uiv, free(value);)
  free(value);

void
glVertexAttribP4ui(index, type, normalized, value)
  GLuint index;
  GLenum type;
  GLboolean normalized;
  GLuint value;
CODE:
  OGLM_GLEWINIT
  OGLM_CHECK_ERR(glVertexAttribP4ui, )
  OGLM_AVAIL_CHECK(__glewVertexAttribP4ui, glVertexAttribP4ui)
  glVertexAttribP4ui(index, type, normalized, value);
  OGLM_CHECK_ERR(glVertexAttribP4ui, )

void
glVertexAttribP4uiv_c(index, type, normalized, value)
  GLuint index;
  GLenum type;
  GLboolean normalized;
  const GLuint* value;
CODE:
  OGLM_GLEWINIT
  OGLM_CHECK_ERR(glVertexAttribP4uiv, )
  OGLM_AVAIL_CHECK(__glewVertexAttribP4uiv, glVertexAttribP4uiv)
  glVertexAttribP4uiv(index, type, normalized, value);
  OGLM_CHECK_ERR(glVertexAttribP4uiv, )

void
glVertexAttribP4uiv_p(index, type, normalized, ...)
  GLuint index;
  GLenum type;
  GLboolean normalized;
CODE:
  OGLM_GLEWINIT
  OGLM_CHECK_ERR(glVertexAttribP4uiv, )
  OGLM_AVAIL_CHECK(__glewVertexAttribP4uiv, glVertexAttribP4uiv)
  GLuint* value = OGLM_GET_VARARGS(value,3,GLuint,UV,1);
  glVertexAttribP4uiv((GLuint )index, (GLenum )type, (GLboolean )normalized, (const GLuint* )value);
  OGLM_CHECK_ERR(glVertexAttribP4uiv, free(value);)
  free(value);

void
glVertexAttribParameteriAMD(index, pname, param)
  GLuint index;
  GLenum pname;
  GLint param;
CODE:
  OGLM_GLEWINIT
  OGLM_CHECK_ERR(glVertexAttribParameteriAMD, )
  OGLM_AVAIL_CHECK(__glewVertexAttribParameteriAMD, glVertexAttribParameteriAMD)
  glVertexAttribParameteriAMD(index, pname, param);
  OGLM_CHECK_ERR(glVertexAttribParameteriAMD, )

void
glVertexAttribPointer_c(index, size, type, normalized, stride, pointer)
  GLuint index;
  GLint size;
  GLenum type;
  GLboolean normalized;
  GLsizei stride;
  const void* pointer;
ALIAS:
  glVertexAttribPointerARB_c = 1
CODE:
  OGLM_GLEWINIT
  OGLM_CHECK_ERR(glVertexAttribPointer, )
  OGLM_AVAIL_CHECK(__glewVertexAttribPointer, glVertexAttribPointer)
  glVertexAttribPointer(index, size, type, normalized, stride, pointer);
  OGLM_CHECK_ERR(glVertexAttribPointer, )

void
glVertexAttribPointerNV_c(index, fsize, type, stride, pointer)
  GLuint index;
  GLint fsize;
  GLenum type;
  GLsizei stride;
  const void *pointer;
CODE:
  OGLM_GLEWINIT
  OGLM_CHECK_ERR(glVertexAttribPointerNV, )
  OGLM_AVAIL_CHECK(__glewVertexAttribPointerNV, glVertexAttribPointerNV)
  glVertexAttribPointerNV(index, fsize, type, stride, pointer);
  OGLM_CHECK_ERR(glVertexAttribPointerNV, )

void
glVertexAttribs1dvNV_c(index, count, v)
  GLuint index;
  GLsizei count;
  const GLdouble* v;
CODE:
  OGLM_GLEWINIT
  OGLM_CHECK_ERR(glVertexAttribs1dvNV, )
  OGLM_AVAIL_CHECK(__glewVertexAttribs1dvNV, glVertexAttribs1dvNV)
  glVertexAttribs1dvNV(index, count, v);
  OGLM_CHECK_ERR(glVertexAttribs1dvNV, )

void
glVertexAttribs1dvNV_p(index, ...)
  GLuint index;
CODE:
  OGLM_GLEWINIT
  OGLM_CHECK_ERR(glVertexAttribs1dvNV, )
  OGLM_AVAIL_CHECK(__glewVertexAttribs1dvNV, glVertexAttribs1dvNV)
  GLsizei count = items-1;
  GLdouble* v = OGLM_GET_VARARGS(v,1,GLdouble,NV,count);
  glVertexAttribs1dvNV((GLuint )index, (GLsizei )count, (const GLdouble* )v);
  OGLM_CHECK_ERR(glVertexAttribs1dvNV, free(v);)
  free(v);

void
glVertexAttribs1fvNV_c(index, count, v)
  GLuint index;
  GLsizei count;
  const GLfloat* v;
CODE:
  OGLM_GLEWINIT
  OGLM_CHECK_ERR(glVertexAttribs1fvNV, )
  OGLM_AVAIL_CHECK(__glewVertexAttribs1fvNV, glVertexAttribs1fvNV)
  glVertexAttribs1fvNV(index, count, v);
  OGLM_CHECK_ERR(glVertexAttribs1fvNV, )

void
glVertexAttribs1fvNV_p(index, ...)
  GLuint index;
CODE:
  OGLM_GLEWINIT
  OGLM_CHECK_ERR(glVertexAttribs1fvNV, )
  OGLM_AVAIL_CHECK(__glewVertexAttribs1fvNV, glVertexAttribs1fvNV)
  GLsizei count = items-1;
  GLfloat* v = OGLM_GET_VARARGS(v,1,GLfloat,NV,count);
  glVertexAttribs1fvNV((GLuint )index, (GLsizei )count, (const GLfloat* )v);
  OGLM_CHECK_ERR(glVertexAttribs1fvNV, free(v);)
  free(v);

void
glVertexAttribs1hvNV_c(index, n, v)
  GLuint index;
  GLsizei n;
  const GLhalf* v;
CODE:
  OGLM_GLEWINIT
  OGLM_CHECK_ERR(glVertexAttribs1hvNV, )
  OGLM_AVAIL_CHECK(__glewVertexAttribs1hvNV, glVertexAttribs1hvNV)
  glVertexAttribs1hvNV(index, n, v);
  OGLM_CHECK_ERR(glVertexAttribs1hvNV, )

void
glVertexAttribs1hvNV_p(index, ...)
  GLuint index;
CODE:
  OGLM_GLEWINIT
  OGLM_CHECK_ERR(glVertexAttribs1hvNV, )
  OGLM_AVAIL_CHECK(__glewVertexAttribs1hvNV, glVertexAttribs1hvNV)
  GLsizei n = items-1;
  GLhalf* v = OGLM_GET_VARARGS(v,1,GLhalf,NV,n);
  glVertexAttribs1hvNV((GLuint )index, (GLsizei )n, (const GLhalf* )v);
  OGLM_CHECK_ERR(glVertexAttribs1hvNV, free(v);)
  free(v);

void
glVertexAttribs1svNV_c(index, count, v)
  GLuint index;
  GLsizei count;
  const GLshort* v;
CODE:
  OGLM_GLEWINIT
  OGLM_CHECK_ERR(glVertexAttribs1svNV, )
  OGLM_AVAIL_CHECK(__glewVertexAttribs1svNV, glVertexAttribs1svNV)
  glVertexAttribs1svNV(index, count, v);
  OGLM_CHECK_ERR(glVertexAttribs1svNV, )

void
glVertexAttribs1svNV_p(index, ...)
  GLuint index;
CODE:
  OGLM_GLEWINIT
  OGLM_CHECK_ERR(glVertexAttribs1svNV, )
  OGLM_AVAIL_CHECK(__glewVertexAttribs1svNV, glVertexAttribs1svNV)
  GLsizei count = items-1;
  GLshort* v = OGLM_GET_VARARGS(v,1,GLshort,IV,count);
  glVertexAttribs1svNV((GLuint )index, (GLsizei )count, (const GLshort* )v);
  OGLM_CHECK_ERR(glVertexAttribs1svNV, free(v);)
  free(v);

void
glVertexAttribs2dvNV_c(index, count, v)
  GLuint index;
  GLsizei count;
  const GLdouble* v;
CODE:
  OGLM_GLEWINIT
  OGLM_CHECK_ERR(glVertexAttribs2dvNV, )
  OGLM_AVAIL_CHECK(__glewVertexAttribs2dvNV, glVertexAttribs2dvNV)
  glVertexAttribs2dvNV(index, count, v);
  OGLM_CHECK_ERR(glVertexAttribs2dvNV, )

void
glVertexAttribs2dvNV_p(index, count, ...)
  GLuint index;
  GLsizei count;
CODE:
  OGLM_GLEWINIT
  OGLM_CHECK_ERR(glVertexAttribs2dvNV, )
  OGLM_AVAIL_CHECK(__glewVertexAttribs2dvNV, glVertexAttribs2dvNV)
  GLdouble* v = OGLM_GET_VARARGS(v,2,GLdouble,NV,count*2);
  glVertexAttribs2dvNV((GLuint )index, (GLsizei )count, (const GLdouble* )v);
  OGLM_CHECK_ERR(glVertexAttribs2dvNV, free(v);)
  free(v);

void
glVertexAttribs2fvNV_c(index, count, v)
  GLuint index;
  GLsizei count;
  const GLfloat* v;
CODE:
  OGLM_GLEWINIT
  OGLM_CHECK_ERR(glVertexAttribs2fvNV, )
  OGLM_AVAIL_CHECK(__glewVertexAttribs2fvNV, glVertexAttribs2fvNV)
  glVertexAttribs2fvNV(index, count, v);
  OGLM_CHECK_ERR(glVertexAttribs2fvNV, )

void
glVertexAttribs2fvNV_p(index, count, ...)
  GLuint index;
  GLsizei count;
CODE:
  OGLM_GLEWINIT
  OGLM_CHECK_ERR(glVertexAttribs2fvNV, )
  OGLM_AVAIL_CHECK(__glewVertexAttribs2fvNV, glVertexAttribs2fvNV)
  GLfloat* v = OGLM_GET_VARARGS(v,2,GLfloat,NV,count*2);
  glVertexAttribs2fvNV((GLuint )index, (GLsizei )count, (const GLfloat* )v);
  OGLM_CHECK_ERR(glVertexAttribs2fvNV, free(v);)
  free(v);

void
glVertexAttribs2hvNV_c(index, n, v)
  GLuint index;
  GLsizei n;
  const GLhalf* v;
CODE:
  OGLM_GLEWINIT
  OGLM_CHECK_ERR(glVertexAttribs2hvNV, )
  OGLM_AVAIL_CHECK(__glewVertexAttribs2hvNV, glVertexAttribs2hvNV)
  glVertexAttribs2hvNV(index, n, v);
  OGLM_CHECK_ERR(glVertexAttribs2hvNV, )

void
glVertexAttribs2hvNV_p(index, ...)
  GLuint index;
CODE:
  OGLM_GLEWINIT
  OGLM_CHECK_ERR(glVertexAttribs2hvNV, )
  OGLM_AVAIL_CHECK(__glewVertexAttribs2hvNV, glVertexAttribs2hvNV)
  GLsizei n = items-1;
  GLhalf* v = OGLM_GET_VARARGS(v,1,GLhalf,NV,n);
  glVertexAttribs2hvNV((GLuint )index, (GLsizei )n, (const GLhalf* )v);
  OGLM_CHECK_ERR(glVertexAttribs2hvNV, free(v);)
  free(v);

void
glVertexAttribs2svNV_c(index, count, v)
  GLuint index;
  GLsizei count;
  const GLshort* v;
CODE:
  OGLM_GLEWINIT
  OGLM_CHECK_ERR(glVertexAttribs2svNV, )
  OGLM_AVAIL_CHECK(__glewVertexAttribs2svNV, glVertexAttribs2svNV)
  glVertexAttribs2svNV(index, count, v);
  OGLM_CHECK_ERR(glVertexAttribs2svNV, )

void
glVertexAttribs2svNV_p(index, count, ...)
  GLuint index;
  GLsizei count;
CODE:
  OGLM_GLEWINIT
  OGLM_CHECK_ERR(glVertexAttribs2svNV, )
  OGLM_AVAIL_CHECK(__glewVertexAttribs2svNV, glVertexAttribs2svNV)
  GLshort* v = OGLM_GET_VARARGS(v,2,GLshort,IV,count*2);
  glVertexAttribs2svNV((GLuint )index, (GLsizei )count, (const GLshort* )v);
  OGLM_CHECK_ERR(glVertexAttribs2svNV, free(v);)
  free(v);

void
glVertexAttribs3dvNV_c(index, count, v)
  GLuint index;
  GLsizei count;
  const GLdouble* v;
CODE:
  OGLM_GLEWINIT
  OGLM_CHECK_ERR(glVertexAttribs3dvNV, )
  OGLM_AVAIL_CHECK(__glewVertexAttribs3dvNV, glVertexAttribs3dvNV)
  glVertexAttribs3dvNV(index, count, v);
  OGLM_CHECK_ERR(glVertexAttribs3dvNV, )

void
glVertexAttribs3dvNV_p(index, count, ...)
  GLuint index;
  GLsizei count;
CODE:
  OGLM_GLEWINIT
  OGLM_CHECK_ERR(glVertexAttribs3dvNV, )
  OGLM_AVAIL_CHECK(__glewVertexAttribs3dvNV, glVertexAttribs3dvNV)
  GLdouble* v = OGLM_GET_VARARGS(v,2,GLdouble,NV,count*3);
  glVertexAttribs3dvNV((GLuint )index, (GLsizei )count, (const GLdouble* )v);
  OGLM_CHECK_ERR(glVertexAttribs3dvNV, free(v);)
  free(v);

void
glVertexAttribs3fvNV_c(index, count, v)
  GLuint index;
  GLsizei count;
  const GLfloat* v;
CODE:
  OGLM_GLEWINIT
  OGLM_CHECK_ERR(glVertexAttribs3fvNV, )
  OGLM_AVAIL_CHECK(__glewVertexAttribs3fvNV, glVertexAttribs3fvNV)
  glVertexAttribs3fvNV(index, count, v);
  OGLM_CHECK_ERR(glVertexAttribs3fvNV, )

void
glVertexAttribs3fvNV_p(index, count, ...)
  GLuint index;
  GLsizei count;
CODE:
  OGLM_GLEWINIT
  OGLM_CHECK_ERR(glVertexAttribs3fvNV, )
  OGLM_AVAIL_CHECK(__glewVertexAttribs3fvNV, glVertexAttribs3fvNV)
  GLfloat* v = OGLM_GET_VARARGS(v,2,GLfloat,NV,count*3);
  glVertexAttribs3fvNV((GLuint )index, (GLsizei )count, (const GLfloat* )v);
  OGLM_CHECK_ERR(glVertexAttribs3fvNV, free(v);)
  free(v);

void
glVertexAttribs3hvNV_c(index, n, v)
  GLuint index;
  GLsizei n;
  const GLhalf* v;
CODE:
  OGLM_GLEWINIT
  OGLM_CHECK_ERR(glVertexAttribs3hvNV, )
  OGLM_AVAIL_CHECK(__glewVertexAttribs3hvNV, glVertexAttribs3hvNV)
  glVertexAttribs3hvNV(index, n, v);
  OGLM_CHECK_ERR(glVertexAttribs3hvNV, )

void
glVertexAttribs3hvNV_p(index, ...)
  GLuint index;
CODE:
  OGLM_GLEWINIT
  OGLM_CHECK_ERR(glVertexAttribs3hvNV, )
  OGLM_AVAIL_CHECK(__glewVertexAttribs3hvNV, glVertexAttribs3hvNV)
  GLsizei n = items-1;
  GLhalf* v = OGLM_GET_VARARGS(v,1,GLhalf,NV,n);
  glVertexAttribs3hvNV((GLuint )index, (GLsizei )n, (const GLhalf* )v);
  OGLM_CHECK_ERR(glVertexAttribs3hvNV, free(v);)
  free(v);

void
glVertexAttribs3svNV_c(index, count, v)
  GLuint index;
  GLsizei count;
  const GLshort* v;
CODE:
  OGLM_GLEWINIT
  OGLM_CHECK_ERR(glVertexAttribs3svNV, )
  OGLM_AVAIL_CHECK(__glewVertexAttribs3svNV, glVertexAttribs3svNV)
  glVertexAttribs3svNV(index, count, v);
  OGLM_CHECK_ERR(glVertexAttribs3svNV, )

void
glVertexAttribs3svNV_p(index, count, ...)
  GLuint index;
  GLsizei count;
CODE:
  OGLM_GLEWINIT
  OGLM_CHECK_ERR(glVertexAttribs3svNV, )
  OGLM_AVAIL_CHECK(__glewVertexAttribs3svNV, glVertexAttribs3svNV)
  GLshort* v = OGLM_GET_VARARGS(v,2,GLshort,IV,count*3);
  glVertexAttribs3svNV((GLuint )index, (GLsizei )count, (const GLshort* )v);
  OGLM_CHECK_ERR(glVertexAttribs3svNV, free(v);)
  free(v);

void
glVertexAttribs4dvNV_c(index, count, v)
  GLuint index;
  GLsizei count;
  const GLdouble* v;
CODE:
  OGLM_GLEWINIT
  OGLM_CHECK_ERR(glVertexAttribs4dvNV, )
  OGLM_AVAIL_CHECK(__glewVertexAttribs4dvNV, glVertexAttribs4dvNV)
  glVertexAttribs4dvNV(index, count, v);
  OGLM_CHECK_ERR(glVertexAttribs4dvNV, )

void
glVertexAttribs4dvNV_p(index, count, ...)
  GLuint index;
  GLsizei count;
CODE:
  OGLM_GLEWINIT
  OGLM_CHECK_ERR(glVertexAttribs4dvNV, )
  OGLM_AVAIL_CHECK(__glewVertexAttribs4dvNV, glVertexAttribs4dvNV)
  GLdouble* v = OGLM_GET_VARARGS(v,2,GLdouble,NV,count*4);
  glVertexAttribs4dvNV((GLuint )index, (GLsizei )count, (const GLdouble* )v);
  OGLM_CHECK_ERR(glVertexAttribs4dvNV, free(v);)
  free(v);

void
glVertexAttribs4fvNV_c(index, count, v)
  GLuint index;
  GLsizei count;
  const GLfloat* v;
CODE:
  OGLM_GLEWINIT
  OGLM_CHECK_ERR(glVertexAttribs4fvNV, )
  OGLM_AVAIL_CHECK(__glewVertexAttribs4fvNV, glVertexAttribs4fvNV)
  glVertexAttribs4fvNV(index, count, v);
  OGLM_CHECK_ERR(glVertexAttribs4fvNV, )

void
glVertexAttribs4fvNV_p(index, count, ...)
  GLuint index;
  GLsizei count;
CODE:
  OGLM_GLEWINIT
  OGLM_CHECK_ERR(glVertexAttribs4fvNV, )
  OGLM_AVAIL_CHECK(__glewVertexAttribs4fvNV, glVertexAttribs4fvNV)
  GLfloat* v = OGLM_GET_VARARGS(v,2,GLfloat,NV,count*4);
  glVertexAttribs4fvNV((GLuint )index, (GLsizei )count, (const GLfloat* )v);
  OGLM_CHECK_ERR(glVertexAttribs4fvNV, free(v);)
  free(v);

void
glVertexAttribs4hvNV_c(index, n, v)
  GLuint index;
  GLsizei n;
  const GLhalf* v;
CODE:
  OGLM_GLEWINIT
  OGLM_CHECK_ERR(glVertexAttribs4hvNV, )
  OGLM_AVAIL_CHECK(__glewVertexAttribs4hvNV, glVertexAttribs4hvNV)
  glVertexAttribs4hvNV(index, n, v);
  OGLM_CHECK_ERR(glVertexAttribs4hvNV, )

void
glVertexAttribs4hvNV_p(index, ...)
  GLuint index;
CODE:
  OGLM_GLEWINIT
  OGLM_CHECK_ERR(glVertexAttribs4hvNV, )
  OGLM_AVAIL_CHECK(__glewVertexAttribs4hvNV, glVertexAttribs4hvNV)
  GLsizei n = items-1;
  GLhalf* v = OGLM_GET_VARARGS(v,1,GLhalf,NV,n);
  glVertexAttribs4hvNV((GLuint )index, (GLsizei )n, (const GLhalf* )v);
  OGLM_CHECK_ERR(glVertexAttribs4hvNV, free(v);)
  free(v);

void
glVertexAttribs4svNV_c(index, count, v)
  GLuint index;
  GLsizei count;
  const GLshort* v;
CODE:
  OGLM_GLEWINIT
  OGLM_CHECK_ERR(glVertexAttribs4svNV, )
  OGLM_AVAIL_CHECK(__glewVertexAttribs4svNV, glVertexAttribs4svNV)
  glVertexAttribs4svNV(index, count, v);
  OGLM_CHECK_ERR(glVertexAttribs4svNV, )

void
glVertexAttribs4svNV_p(index, count, ...)
  GLuint index;
  GLsizei count;
CODE:
  OGLM_GLEWINIT
  OGLM_CHECK_ERR(glVertexAttribs4svNV, )
  OGLM_AVAIL_CHECK(__glewVertexAttribs4svNV, glVertexAttribs4svNV)
  GLshort* v = OGLM_GET_VARARGS(v,2,GLshort,IV,count*4);
  glVertexAttribs4svNV((GLuint )index, (GLsizei )count, (const GLshort* )v);
  OGLM_CHECK_ERR(glVertexAttribs4svNV, free(v);)
  free(v);

void
glVertexAttribs4ubvNV_c(index, count, v)
  GLuint index;
  GLsizei count;
  const GLubyte* v;
CODE:
  OGLM_GLEWINIT
  OGLM_CHECK_ERR(glVertexAttribs4ubvNV, )
  OGLM_AVAIL_CHECK(__glewVertexAttribs4ubvNV, glVertexAttribs4ubvNV)
  glVertexAttribs4ubvNV(index, count, v);
  OGLM_CHECK_ERR(glVertexAttribs4ubvNV, )

void
glVertexAttribs4ubvNV_p(index, count, ...)
  GLuint index;
  GLsizei count;
CODE:
  OGLM_GLEWINIT
  OGLM_CHECK_ERR(glVertexAttribs4ubvNV, )
  OGLM_AVAIL_CHECK(__glewVertexAttribs4ubvNV, glVertexAttribs4ubvNV)
  GLubyte* v = OGLM_GET_VARARGS(v,2,GLubyte,UV,count*4);
  glVertexAttribs4ubvNV((GLuint )index, (GLsizei )count, (const GLubyte* )v);
  OGLM_CHECK_ERR(glVertexAttribs4ubvNV, free(v);)
  free(v);

void
glVertexBindingDivisor(bindingindex, divisor)
  GLuint bindingindex;
  GLuint divisor;
CODE:
  OGLM_GLEWINIT
  OGLM_CHECK_ERR(glVertexBindingDivisor, )
  OGLM_AVAIL_CHECK(__glewVertexBindingDivisor, glVertexBindingDivisor)
  glVertexBindingDivisor(bindingindex, divisor);
  OGLM_CHECK_ERR(glVertexBindingDivisor, )

void
glVertexBlendARB(count)
  GLint count;
CODE:
  OGLM_GLEWINIT
  OGLM_CHECK_ERR(glVertexBlendARB, )
  OGLM_AVAIL_CHECK(__glewVertexBlendARB, glVertexBlendARB)
  glVertexBlendARB(count);
  OGLM_CHECK_ERR(glVertexBlendARB, )

void
glVertexBlendEnvfATI(pname, param)
  GLenum pname;
  GLfloat param;
CODE:
  OGLM_GLEWINIT
  OGLM_CHECK_ERR(glVertexBlendEnvfATI, )
  OGLM_AVAIL_CHECK(__glewVertexBlendEnvfATI, glVertexBlendEnvfATI)
  glVertexBlendEnvfATI(pname, param);
  OGLM_CHECK_ERR(glVertexBlendEnvfATI, )

void
glVertexBlendEnviATI(pname, param)
  GLenum pname;
  GLint param;
CODE:
  OGLM_GLEWINIT
  OGLM_CHECK_ERR(glVertexBlendEnviATI, )
  OGLM_AVAIL_CHECK(__glewVertexBlendEnviATI, glVertexBlendEnviATI)
  glVertexBlendEnviATI(pname, param);
  OGLM_CHECK_ERR(glVertexBlendEnviATI, )

void
glVertexFormatNV(size, type, stride)
  GLint size;
  GLenum type;
  GLsizei stride;
CODE:
  OGLM_GLEWINIT
  OGLM_CHECK_ERR(glVertexFormatNV, )
  OGLM_AVAIL_CHECK(__glewVertexFormatNV, glVertexFormatNV)
  glVertexFormatNV(size, type, stride);
  OGLM_CHECK_ERR(glVertexFormatNV, )

void
glVertexP2ui(type, value)
  GLenum type;
  GLuint value;
CODE:
  OGLM_GLEWINIT
  OGLM_CHECK_ERR(glVertexP2ui, )
  OGLM_AVAIL_CHECK(__glewVertexP2ui, glVertexP2ui)
  glVertexP2ui(type, value);
  OGLM_CHECK_ERR(glVertexP2ui, )

void
glVertexP2uiv_c(type, value)
  GLenum type;
  const GLuint* value;
CODE:
  OGLM_GLEWINIT
  OGLM_CHECK_ERR(glVertexP2uiv, )
  OGLM_AVAIL_CHECK(__glewVertexP2uiv, glVertexP2uiv)
  glVertexP2uiv(type, value);
  OGLM_CHECK_ERR(glVertexP2uiv, )

void
glVertexP2uiv_p(type, ...)
  GLenum type;
CODE:
  OGLM_GLEWINIT
  OGLM_CHECK_ERR(glVertexP2uiv, )
  OGLM_AVAIL_CHECK(__glewVertexP2uiv, glVertexP2uiv)
  GLuint* value = OGLM_GET_VARARGS(value,1,GLuint,UV,1);
  glVertexP2uiv((GLenum )type, (const GLuint* )value);
  OGLM_CHECK_ERR(glVertexP2uiv, free(value);)
  free(value);

void
glVertexP3ui(type, value)
  GLenum type;
  GLuint value;
CODE:
  OGLM_GLEWINIT
  OGLM_CHECK_ERR(glVertexP3ui, )
  OGLM_AVAIL_CHECK(__glewVertexP3ui, glVertexP3ui)
  glVertexP3ui(type, value);
  OGLM_CHECK_ERR(glVertexP3ui, )

void
glVertexP3uiv_c(type, value)
  GLenum type;
  const GLuint* value;
CODE:
  OGLM_GLEWINIT
  OGLM_CHECK_ERR(glVertexP3uiv, )
  OGLM_AVAIL_CHECK(__glewVertexP3uiv, glVertexP3uiv)
  glVertexP3uiv(type, value);
  OGLM_CHECK_ERR(glVertexP3uiv, )

void
glVertexP3uiv_p(type, ...)
  GLenum type;
CODE:
  OGLM_GLEWINIT
  OGLM_CHECK_ERR(glVertexP3uiv, )
  OGLM_AVAIL_CHECK(__glewVertexP3uiv, glVertexP3uiv)
  GLuint* value = OGLM_GET_VARARGS(value,1,GLuint,UV,1);
  glVertexP3uiv((GLenum )type, (const GLuint* )value);
  OGLM_CHECK_ERR(glVertexP3uiv, free(value);)
  free(value);

void
glVertexP4ui(type, value)
  GLenum type;
  GLuint value;
CODE:
  OGLM_GLEWINIT
  OGLM_CHECK_ERR(glVertexP4ui, )
  OGLM_AVAIL_CHECK(__glewVertexP4ui, glVertexP4ui)
  glVertexP4ui(type, value);
  OGLM_CHECK_ERR(glVertexP4ui, )

void
glVertexP4uiv_c(type, value)
  GLenum type;
  const GLuint* value;
CODE:
  OGLM_GLEWINIT
  OGLM_CHECK_ERR(glVertexP4uiv, )
  OGLM_AVAIL_CHECK(__glewVertexP4uiv, glVertexP4uiv)
  glVertexP4uiv(type, value);
  OGLM_CHECK_ERR(glVertexP4uiv, )

void
glVertexP4uiv_p(type, ...)
  GLenum type;
CODE:
  OGLM_GLEWINIT
  OGLM_CHECK_ERR(glVertexP4uiv, )
  OGLM_AVAIL_CHECK(__glewVertexP4uiv, glVertexP4uiv)
  GLuint* value = OGLM_GET_VARARGS(value,1,GLuint,UV,1);
  glVertexP4uiv((GLenum )type, (const GLuint* )value);
  OGLM_CHECK_ERR(glVertexP4uiv, free(value);)
  free(value);

void
glVertexPointer_c(size, type, stride, pointer)
  GLint size;
  GLenum type;
  GLsizei stride;
  const void *pointer;
CODE:
  OGLM_GLEWINIT
  OGLM_CHECK_ERR(glVertexPointer, )
  glVertexPointer(size, type, stride, pointer);
  OGLM_CHECK_ERR(glVertexPointer, )

void
glVertexPointerEXT_c(size, type, stride, count, pointer)
  GLint size;
  GLenum type;
  GLsizei stride;
  GLsizei count;
  const void *pointer;
CODE:
  OGLM_GLEWINIT
  OGLM_CHECK_ERR(glVertexPointerEXT, )
  OGLM_AVAIL_CHECK(__glewVertexPointerEXT, glVertexPointerEXT)
  glVertexPointerEXT(size, type, stride, count, pointer);
  OGLM_CHECK_ERR(glVertexPointerEXT, )

void
glVertexPointerListIBM_c(size, type, stride, pointer, ptrstride)
  GLint size;
  GLenum type;
  GLint stride;
  const void** pointer;
  GLint ptrstride;
CODE:
  OGLM_GLEWINIT
  OGLM_CHECK_ERR(glVertexPointerListIBM, )
  OGLM_AVAIL_CHECK(__glewVertexPointerListIBM, glVertexPointerListIBM)
  glVertexPointerListIBM(size, type, stride, pointer, ptrstride);
  OGLM_CHECK_ERR(glVertexPointerListIBM, )

void
glVertexPointervINTEL_c(size, type, pointer)
  GLint size;
  GLenum type;
  const void** pointer;
CODE:
  OGLM_GLEWINIT
  OGLM_CHECK_ERR(glVertexPointervINTEL, )
  OGLM_AVAIL_CHECK(__glewVertexPointervINTEL, glVertexPointervINTEL)
  glVertexPointervINTEL(size, type, pointer);
  OGLM_CHECK_ERR(glVertexPointervINTEL, )

void
glVertexStream1dATI(stream, x)
  GLenum stream;
  GLdouble x;
CODE:
  OGLM_GLEWINIT
  OGLM_CHECK_ERR(glVertexStream1dATI, )
  OGLM_AVAIL_CHECK(__glewVertexStream1dATI, glVertexStream1dATI)
  glVertexStream1dATI(stream, x);
  OGLM_CHECK_ERR(glVertexStream1dATI, )

void
glVertexStream1dvATI_c(stream, coords)
  GLenum stream;
  const GLdouble *coords;
CODE:
  OGLM_GLEWINIT
  OGLM_CHECK_ERR(glVertexStream1dvATI, )
  OGLM_AVAIL_CHECK(__glewVertexStream1dvATI, glVertexStream1dvATI)
  glVertexStream1dvATI(stream, coords);
  OGLM_CHECK_ERR(glVertexStream1dvATI, )

void
glVertexStream1dvATI_p(stream, ...)
  GLenum stream;
CODE:
  OGLM_GLEWINIT
  OGLM_CHECK_ERR(glVertexStream1dvATI, )
  OGLM_AVAIL_CHECK(__glewVertexStream1dvATI, glVertexStream1dvATI)
  GLdouble *coords = OGLM_GET_VARARGS(coords,1,GLdouble,NV,1);
  glVertexStream1dvATI((GLenum )stream, (const GLdouble *)coords);
  OGLM_CHECK_ERR(glVertexStream1dvATI, free(coords);)
  free(coords);

void
glVertexStream1fATI(stream, x)
  GLenum stream;
  GLfloat x;
CODE:
  OGLM_GLEWINIT
  OGLM_CHECK_ERR(glVertexStream1fATI, )
  OGLM_AVAIL_CHECK(__glewVertexStream1fATI, glVertexStream1fATI)
  glVertexStream1fATI(stream, x);
  OGLM_CHECK_ERR(glVertexStream1fATI, )

void
glVertexStream1fvATI_c(stream, coords)
  GLenum stream;
  const GLfloat *coords;
CODE:
  OGLM_GLEWINIT
  OGLM_CHECK_ERR(glVertexStream1fvATI, )
  OGLM_AVAIL_CHECK(__glewVertexStream1fvATI, glVertexStream1fvATI)
  glVertexStream1fvATI(stream, coords);
  OGLM_CHECK_ERR(glVertexStream1fvATI, )

void
glVertexStream1fvATI_p(stream, ...)
  GLenum stream;
CODE:
  OGLM_GLEWINIT
  OGLM_CHECK_ERR(glVertexStream1fvATI, )
  OGLM_AVAIL_CHECK(__glewVertexStream1fvATI, glVertexStream1fvATI)
  GLfloat *coords = OGLM_GET_VARARGS(coords,1,GLfloat,NV,1);
  glVertexStream1fvATI((GLenum )stream, (const GLfloat *)coords);
  OGLM_CHECK_ERR(glVertexStream1fvATI, free(coords);)
  free(coords);

void
glVertexStream1iATI(stream, x)
  GLenum stream;
  GLint x;
CODE:
  OGLM_GLEWINIT
  OGLM_CHECK_ERR(glVertexStream1iATI, )
  OGLM_AVAIL_CHECK(__glewVertexStream1iATI, glVertexStream1iATI)
  glVertexStream1iATI(stream, x);
  OGLM_CHECK_ERR(glVertexStream1iATI, )

void
glVertexStream1ivATI_c(stream, coords)
  GLenum stream;
  const GLint *coords;
CODE:
  OGLM_GLEWINIT
  OGLM_CHECK_ERR(glVertexStream1ivATI, )
  OGLM_AVAIL_CHECK(__glewVertexStream1ivATI, glVertexStream1ivATI)
  glVertexStream1ivATI(stream, coords);
  OGLM_CHECK_ERR(glVertexStream1ivATI, )

void
glVertexStream1ivATI_p(stream, ...)
  GLenum stream;
CODE:
  OGLM_GLEWINIT
  OGLM_CHECK_ERR(glVertexStream1ivATI, )
  OGLM_AVAIL_CHECK(__glewVertexStream1ivATI, glVertexStream1ivATI)
  GLint *coords = OGLM_GET_VARARGS(coords,1,GLint,IV,1);
  glVertexStream1ivATI((GLenum )stream, (const GLint *)coords);
  OGLM_CHECK_ERR(glVertexStream1ivATI, free(coords);)
  free(coords);

void
glVertexStream1sATI(stream, x)
  GLenum stream;
  GLshort x;
CODE:
  OGLM_GLEWINIT
  OGLM_CHECK_ERR(glVertexStream1sATI, )
  OGLM_AVAIL_CHECK(__glewVertexStream1sATI, glVertexStream1sATI)
  glVertexStream1sATI(stream, x);
  OGLM_CHECK_ERR(glVertexStream1sATI, )

void
glVertexStream1svATI_c(stream, coords)
  GLenum stream;
  const GLshort *coords;
CODE:
  OGLM_GLEWINIT
  OGLM_CHECK_ERR(glVertexStream1svATI, )
  OGLM_AVAIL_CHECK(__glewVertexStream1svATI, glVertexStream1svATI)
  glVertexStream1svATI(stream, coords);
  OGLM_CHECK_ERR(glVertexStream1svATI, )

void
glVertexStream1svATI_p(stream, ...)
  GLenum stream;
CODE:
  OGLM_GLEWINIT
  OGLM_CHECK_ERR(glVertexStream1svATI, )
  OGLM_AVAIL_CHECK(__glewVertexStream1svATI, glVertexStream1svATI)
  GLshort *coords = OGLM_GET_VARARGS(coords,1,GLshort,IV,1);
  glVertexStream1svATI((GLenum )stream, (const GLshort *)coords);
  OGLM_CHECK_ERR(glVertexStream1svATI, free(coords);)
  free(coords);

void
glVertexStream2dATI(stream, x, y)
  GLenum stream;
  GLdouble x;
  GLdouble y;
CODE:
  OGLM_GLEWINIT
  OGLM_CHECK_ERR(glVertexStream2dATI, )
  OGLM_AVAIL_CHECK(__glewVertexStream2dATI, glVertexStream2dATI)
  glVertexStream2dATI(stream, x, y);
  OGLM_CHECK_ERR(glVertexStream2dATI, )

void
glVertexStream2dvATI_c(stream, coords)
  GLenum stream;
  const GLdouble *coords;
CODE:
  OGLM_GLEWINIT
  OGLM_CHECK_ERR(glVertexStream2dvATI, )
  OGLM_AVAIL_CHECK(__glewVertexStream2dvATI, glVertexStream2dvATI)
  glVertexStream2dvATI(stream, coords);
  OGLM_CHECK_ERR(glVertexStream2dvATI, )

void
glVertexStream2dvATI_p(stream, ...)
  GLenum stream;
CODE:
  OGLM_GLEWINIT
  OGLM_CHECK_ERR(glVertexStream2dvATI, )
  OGLM_AVAIL_CHECK(__glewVertexStream2dvATI, glVertexStream2dvATI)
  GLdouble *coords = OGLM_GET_VARARGS(coords,1,GLdouble,NV,2);
  glVertexStream2dvATI((GLenum )stream, (const GLdouble *)coords);
  OGLM_CHECK_ERR(glVertexStream2dvATI, free(coords);)
  free(coords);

void
glVertexStream2fATI(stream, x, y)
  GLenum stream;
  GLfloat x;
  GLfloat y;
CODE:
  OGLM_GLEWINIT
  OGLM_CHECK_ERR(glVertexStream2fATI, )
  OGLM_AVAIL_CHECK(__glewVertexStream2fATI, glVertexStream2fATI)
  glVertexStream2fATI(stream, x, y);
  OGLM_CHECK_ERR(glVertexStream2fATI, )

void
glVertexStream2fvATI_c(stream, coords)
  GLenum stream;
  const GLfloat *coords;
CODE:
  OGLM_GLEWINIT
  OGLM_CHECK_ERR(glVertexStream2fvATI, )
  OGLM_AVAIL_CHECK(__glewVertexStream2fvATI, glVertexStream2fvATI)
  glVertexStream2fvATI(stream, coords);
  OGLM_CHECK_ERR(glVertexStream2fvATI, )

void
glVertexStream2fvATI_p(stream, ...)
  GLenum stream;
CODE:
  OGLM_GLEWINIT
  OGLM_CHECK_ERR(glVertexStream2fvATI, )
  OGLM_AVAIL_CHECK(__glewVertexStream2fvATI, glVertexStream2fvATI)
  GLfloat *coords = OGLM_GET_VARARGS(coords,1,GLfloat,NV,2);
  glVertexStream2fvATI((GLenum )stream, (const GLfloat *)coords);
  OGLM_CHECK_ERR(glVertexStream2fvATI, free(coords);)
  free(coords);

void
glVertexStream2iATI(stream, x, y)
  GLenum stream;
  GLint x;
  GLint y;
CODE:
  OGLM_GLEWINIT
  OGLM_CHECK_ERR(glVertexStream2iATI, )
  OGLM_AVAIL_CHECK(__glewVertexStream2iATI, glVertexStream2iATI)
  glVertexStream2iATI(stream, x, y);
  OGLM_CHECK_ERR(glVertexStream2iATI, )

void
glVertexStream2ivATI_c(stream, coords)
  GLenum stream;
  const GLint *coords;
CODE:
  OGLM_GLEWINIT
  OGLM_CHECK_ERR(glVertexStream2ivATI, )
  OGLM_AVAIL_CHECK(__glewVertexStream2ivATI, glVertexStream2ivATI)
  glVertexStream2ivATI(stream, coords);
  OGLM_CHECK_ERR(glVertexStream2ivATI, )

void
glVertexStream2ivATI_p(stream, ...)
  GLenum stream;
CODE:
  OGLM_GLEWINIT
  OGLM_CHECK_ERR(glVertexStream2ivATI, )
  OGLM_AVAIL_CHECK(__glewVertexStream2ivATI, glVertexStream2ivATI)
  GLint *coords = OGLM_GET_VARARGS(coords,1,GLint,IV,2);
  glVertexStream2ivATI((GLenum )stream, (const GLint *)coords);
  OGLM_CHECK_ERR(glVertexStream2ivATI, free(coords);)
  free(coords);

void
glVertexStream2sATI(stream, x, y)
  GLenum stream;
  GLshort x;
  GLshort y;
CODE:
  OGLM_GLEWINIT
  OGLM_CHECK_ERR(glVertexStream2sATI, )
  OGLM_AVAIL_CHECK(__glewVertexStream2sATI, glVertexStream2sATI)
  glVertexStream2sATI(stream, x, y);
  OGLM_CHECK_ERR(glVertexStream2sATI, )

void
glVertexStream2svATI_c(stream, coords)
  GLenum stream;
  const GLshort *coords;
CODE:
  OGLM_GLEWINIT
  OGLM_CHECK_ERR(glVertexStream2svATI, )
  OGLM_AVAIL_CHECK(__glewVertexStream2svATI, glVertexStream2svATI)
  glVertexStream2svATI(stream, coords);
  OGLM_CHECK_ERR(glVertexStream2svATI, )

void
glVertexStream2svATI_p(stream, ...)
  GLenum stream;
CODE:
  OGLM_GLEWINIT
  OGLM_CHECK_ERR(glVertexStream2svATI, )
  OGLM_AVAIL_CHECK(__glewVertexStream2svATI, glVertexStream2svATI)
  GLshort *coords = OGLM_GET_VARARGS(coords,1,GLshort,IV,2);
  glVertexStream2svATI((GLenum )stream, (const GLshort *)coords);
  OGLM_CHECK_ERR(glVertexStream2svATI, free(coords);)
  free(coords);

void
glVertexStream3dATI(stream, x, y, z)
  GLenum stream;
  GLdouble x;
  GLdouble y;
  GLdouble z;
CODE:
  OGLM_GLEWINIT
  OGLM_CHECK_ERR(glVertexStream3dATI, )
  OGLM_AVAIL_CHECK(__glewVertexStream3dATI, glVertexStream3dATI)
  glVertexStream3dATI(stream, x, y, z);
  OGLM_CHECK_ERR(glVertexStream3dATI, )

void
glVertexStream3dvATI_c(stream, coords)
  GLenum stream;
  const GLdouble *coords;
CODE:
  OGLM_GLEWINIT
  OGLM_CHECK_ERR(glVertexStream3dvATI, )
  OGLM_AVAIL_CHECK(__glewVertexStream3dvATI, glVertexStream3dvATI)
  glVertexStream3dvATI(stream, coords);
  OGLM_CHECK_ERR(glVertexStream3dvATI, )

void
glVertexStream3dvATI_p(stream, ...)
  GLenum stream;
CODE:
  OGLM_GLEWINIT
  OGLM_CHECK_ERR(glVertexStream3dvATI, )
  OGLM_AVAIL_CHECK(__glewVertexStream3dvATI, glVertexStream3dvATI)
  GLdouble *coords = OGLM_GET_VARARGS(coords,1,GLdouble,NV,3);
  glVertexStream3dvATI((GLenum )stream, (const GLdouble *)coords);
  OGLM_CHECK_ERR(glVertexStream3dvATI, free(coords);)
  free(coords);

void
glVertexStream3fATI(stream, x, y, z)
  GLenum stream;
  GLfloat x;
  GLfloat y;
  GLfloat z;
CODE:
  OGLM_GLEWINIT
  OGLM_CHECK_ERR(glVertexStream3fATI, )
  OGLM_AVAIL_CHECK(__glewVertexStream3fATI, glVertexStream3fATI)
  glVertexStream3fATI(stream, x, y, z);
  OGLM_CHECK_ERR(glVertexStream3fATI, )

void
glVertexStream3fvATI_c(stream, coords)
  GLenum stream;
  const GLfloat *coords;
CODE:
  OGLM_GLEWINIT
  OGLM_CHECK_ERR(glVertexStream3fvATI, )
  OGLM_AVAIL_CHECK(__glewVertexStream3fvATI, glVertexStream3fvATI)
  glVertexStream3fvATI(stream, coords);
  OGLM_CHECK_ERR(glVertexStream3fvATI, )

void
glVertexStream3fvATI_p(stream, ...)
  GLenum stream;
CODE:
  OGLM_GLEWINIT
  OGLM_CHECK_ERR(glVertexStream3fvATI, )
  OGLM_AVAIL_CHECK(__glewVertexStream3fvATI, glVertexStream3fvATI)
  GLfloat *coords = OGLM_GET_VARARGS(coords,1,GLfloat,NV,3);
  glVertexStream3fvATI((GLenum )stream, (const GLfloat *)coords);
  OGLM_CHECK_ERR(glVertexStream3fvATI, free(coords);)
  free(coords);

void
glVertexStream3iATI(stream, x, y, z)
  GLenum stream;
  GLint x;
  GLint y;
  GLint z;
CODE:
  OGLM_GLEWINIT
  OGLM_CHECK_ERR(glVertexStream3iATI, )
  OGLM_AVAIL_CHECK(__glewVertexStream3iATI, glVertexStream3iATI)
  glVertexStream3iATI(stream, x, y, z);
  OGLM_CHECK_ERR(glVertexStream3iATI, )

void
glVertexStream3ivATI_c(stream, coords)
  GLenum stream;
  const GLint *coords;
CODE:
  OGLM_GLEWINIT
  OGLM_CHECK_ERR(glVertexStream3ivATI, )
  OGLM_AVAIL_CHECK(__glewVertexStream3ivATI, glVertexStream3ivATI)
  glVertexStream3ivATI(stream, coords);
  OGLM_CHECK_ERR(glVertexStream3ivATI, )

void
glVertexStream3ivATI_p(stream, ...)
  GLenum stream;
CODE:
  OGLM_GLEWINIT
  OGLM_CHECK_ERR(glVertexStream3ivATI, )
  OGLM_AVAIL_CHECK(__glewVertexStream3ivATI, glVertexStream3ivATI)
  GLint *coords = OGLM_GET_VARARGS(coords,1,GLint,IV,3);
  glVertexStream3ivATI((GLenum )stream, (const GLint *)coords);
  OGLM_CHECK_ERR(glVertexStream3ivATI, free(coords);)
  free(coords);

void
glVertexStream3sATI(stream, x, y, z)
  GLenum stream;
  GLshort x;
  GLshort y;
  GLshort z;
CODE:
  OGLM_GLEWINIT
  OGLM_CHECK_ERR(glVertexStream3sATI, )
  OGLM_AVAIL_CHECK(__glewVertexStream3sATI, glVertexStream3sATI)
  glVertexStream3sATI(stream, x, y, z);
  OGLM_CHECK_ERR(glVertexStream3sATI, )

void
glVertexStream3svATI_c(stream, coords)
  GLenum stream;
  const GLshort *coords;
CODE:
  OGLM_GLEWINIT
  OGLM_CHECK_ERR(glVertexStream3svATI, )
  OGLM_AVAIL_CHECK(__glewVertexStream3svATI, glVertexStream3svATI)
  glVertexStream3svATI(stream, coords);
  OGLM_CHECK_ERR(glVertexStream3svATI, )

void
glVertexStream3svATI_p(stream, ...)
  GLenum stream;
CODE:
  OGLM_GLEWINIT
  OGLM_CHECK_ERR(glVertexStream3svATI, )
  OGLM_AVAIL_CHECK(__glewVertexStream3svATI, glVertexStream3svATI)
  GLshort *coords = OGLM_GET_VARARGS(coords,1,GLshort,IV,3);
  glVertexStream3svATI((GLenum )stream, (const GLshort *)coords);
  OGLM_CHECK_ERR(glVertexStream3svATI, free(coords);)
  free(coords);

void
glVertexStream4dATI(stream, x, y, z, w)
  GLenum stream;
  GLdouble x;
  GLdouble y;
  GLdouble z;
  GLdouble w;
CODE:
  OGLM_GLEWINIT
  OGLM_CHECK_ERR(glVertexStream4dATI, )
  OGLM_AVAIL_CHECK(__glewVertexStream4dATI, glVertexStream4dATI)
  glVertexStream4dATI(stream, x, y, z, w);
  OGLM_CHECK_ERR(glVertexStream4dATI, )

void
glVertexStream4dvATI_c(stream, coords)
  GLenum stream;
  const GLdouble *coords;
CODE:
  OGLM_GLEWINIT
  OGLM_CHECK_ERR(glVertexStream4dvATI, )
  OGLM_AVAIL_CHECK(__glewVertexStream4dvATI, glVertexStream4dvATI)
  glVertexStream4dvATI(stream, coords);
  OGLM_CHECK_ERR(glVertexStream4dvATI, )

void
glVertexStream4dvATI_p(stream, ...)
  GLenum stream;
CODE:
  OGLM_GLEWINIT
  OGLM_CHECK_ERR(glVertexStream4dvATI, )
  OGLM_AVAIL_CHECK(__glewVertexStream4dvATI, glVertexStream4dvATI)
  GLdouble *coords = OGLM_GET_VARARGS(coords,1,GLdouble,NV,4);
  glVertexStream4dvATI((GLenum )stream, (const GLdouble *)coords);
  OGLM_CHECK_ERR(glVertexStream4dvATI, free(coords);)
  free(coords);

void
glVertexStream4fATI(stream, x, y, z, w)
  GLenum stream;
  GLfloat x;
  GLfloat y;
  GLfloat z;
  GLfloat w;
CODE:
  OGLM_GLEWINIT
  OGLM_CHECK_ERR(glVertexStream4fATI, )
  OGLM_AVAIL_CHECK(__glewVertexStream4fATI, glVertexStream4fATI)
  glVertexStream4fATI(stream, x, y, z, w);
  OGLM_CHECK_ERR(glVertexStream4fATI, )

void
glVertexStream4fvATI_c(stream, coords)
  GLenum stream;
  const GLfloat *coords;
CODE:
  OGLM_GLEWINIT
  OGLM_CHECK_ERR(glVertexStream4fvATI, )
  OGLM_AVAIL_CHECK(__glewVertexStream4fvATI, glVertexStream4fvATI)
  glVertexStream4fvATI(stream, coords);
  OGLM_CHECK_ERR(glVertexStream4fvATI, )

void
glVertexStream4fvATI_p(stream, ...)
  GLenum stream;
CODE:
  OGLM_GLEWINIT
  OGLM_CHECK_ERR(glVertexStream4fvATI, )
  OGLM_AVAIL_CHECK(__glewVertexStream4fvATI, glVertexStream4fvATI)
  GLfloat *coords = OGLM_GET_VARARGS(coords,1,GLfloat,NV,4);
  glVertexStream4fvATI((GLenum )stream, (const GLfloat *)coords);
  OGLM_CHECK_ERR(glVertexStream4fvATI, free(coords);)
  free(coords);

void
glVertexStream4iATI(stream, x, y, z, w)
  GLenum stream;
  GLint x;
  GLint y;
  GLint z;
  GLint w;
CODE:
  OGLM_GLEWINIT
  OGLM_CHECK_ERR(glVertexStream4iATI, )
  OGLM_AVAIL_CHECK(__glewVertexStream4iATI, glVertexStream4iATI)
  glVertexStream4iATI(stream, x, y, z, w);
  OGLM_CHECK_ERR(glVertexStream4iATI, )

void
glVertexStream4ivATI_c(stream, coords)
  GLenum stream;
  const GLint *coords;
CODE:
  OGLM_GLEWINIT
  OGLM_CHECK_ERR(glVertexStream4ivATI, )
  OGLM_AVAIL_CHECK(__glewVertexStream4ivATI, glVertexStream4ivATI)
  glVertexStream4ivATI(stream, coords);
  OGLM_CHECK_ERR(glVertexStream4ivATI, )

void
glVertexStream4ivATI_p(stream, ...)
  GLenum stream;
CODE:
  OGLM_GLEWINIT
  OGLM_CHECK_ERR(glVertexStream4ivATI, )
  OGLM_AVAIL_CHECK(__glewVertexStream4ivATI, glVertexStream4ivATI)
  GLint *coords = OGLM_GET_VARARGS(coords,1,GLint,IV,4);
  glVertexStream4ivATI((GLenum )stream, (const GLint *)coords);
  OGLM_CHECK_ERR(glVertexStream4ivATI, free(coords);)
  free(coords);

void
glVertexStream4sATI(stream, x, y, z, w)
  GLenum stream;
  GLshort x;
  GLshort y;
  GLshort z;
  GLshort w;
CODE:
  OGLM_GLEWINIT
  OGLM_CHECK_ERR(glVertexStream4sATI, )
  OGLM_AVAIL_CHECK(__glewVertexStream4sATI, glVertexStream4sATI)
  glVertexStream4sATI(stream, x, y, z, w);
  OGLM_CHECK_ERR(glVertexStream4sATI, )

void
glVertexStream4svATI_c(stream, coords)
  GLenum stream;
  const GLshort *coords;
CODE:
  OGLM_GLEWINIT
  OGLM_CHECK_ERR(glVertexStream4svATI, )
  OGLM_AVAIL_CHECK(__glewVertexStream4svATI, glVertexStream4svATI)
  glVertexStream4svATI(stream, coords);
  OGLM_CHECK_ERR(glVertexStream4svATI, )

void
glVertexStream4svATI_p(stream, ...)
  GLenum stream;
CODE:
  OGLM_GLEWINIT
  OGLM_CHECK_ERR(glVertexStream4svATI, )
  OGLM_AVAIL_CHECK(__glewVertexStream4svATI, glVertexStream4svATI)
  GLshort *coords = OGLM_GET_VARARGS(coords,1,GLshort,IV,4);
  glVertexStream4svATI((GLenum )stream, (const GLshort *)coords);
  OGLM_CHECK_ERR(glVertexStream4svATI, free(coords);)
  free(coords);

void
glVertexWeightPointerEXT_c(size, type, stride, pointer)
  GLint size;
  GLenum type;
  GLsizei stride;
  void *pointer;
CODE:
  OGLM_GLEWINIT
  OGLM_CHECK_ERR(glVertexWeightPointerEXT, )
  OGLM_AVAIL_CHECK(__glewVertexWeightPointerEXT, glVertexWeightPointerEXT)
  glVertexWeightPointerEXT(size, type, stride, pointer);
  OGLM_CHECK_ERR(glVertexWeightPointerEXT, )

void
glVertexWeightfEXT(weight)
  GLfloat weight;
CODE:
  OGLM_GLEWINIT
  OGLM_CHECK_ERR(glVertexWeightfEXT, )
  OGLM_AVAIL_CHECK(__glewVertexWeightfEXT, glVertexWeightfEXT)
  glVertexWeightfEXT(weight);
  OGLM_CHECK_ERR(glVertexWeightfEXT, )

void
glVertexWeightfvEXT_c(weight)
  GLfloat* weight;
CODE:
  OGLM_GLEWINIT
  OGLM_CHECK_ERR(glVertexWeightfvEXT, )
  OGLM_AVAIL_CHECK(__glewVertexWeightfvEXT, glVertexWeightfvEXT)
  glVertexWeightfvEXT(weight);
  OGLM_CHECK_ERR(glVertexWeightfvEXT, )

GLfloat
glVertexWeightfvEXT_p()
CODE:
  OGLM_GLEWINIT
  OGLM_CHECK_ERR(glVertexWeightfvEXT, )
  OGLM_AVAIL_CHECK(__glewVertexWeightfvEXT, glVertexWeightfvEXT)
  GLfloat weight[1];
  glVertexWeightfvEXT(weight);
  OGLM_CHECK_ERR(glVertexWeightfvEXT, )
  RETVAL = weight[0];
OUTPUT:
  RETVAL

void
glVertexWeighthNV(weight)
  GLhalf weight;
CODE:
  OGLM_GLEWINIT
  OGLM_CHECK_ERR(glVertexWeighthNV, )
  OGLM_AVAIL_CHECK(__glewVertexWeighthNV, glVertexWeighthNV)
  glVertexWeighthNV(weight);
  OGLM_CHECK_ERR(glVertexWeighthNV, )

void
glVertexWeighthvNV_c(weight)
  const GLhalf* weight;
CODE:
  OGLM_GLEWINIT
  OGLM_CHECK_ERR(glVertexWeighthvNV, )
  OGLM_AVAIL_CHECK(__glewVertexWeighthvNV, glVertexWeighthvNV)
  glVertexWeighthvNV(weight);
  OGLM_CHECK_ERR(glVertexWeighthvNV, )

void
glVertexWeighthvNV_p(...)
CODE:
  OGLM_GLEWINIT
  OGLM_CHECK_ERR(glVertexWeighthvNV, )
  OGLM_AVAIL_CHECK(__glewVertexWeighthvNV, glVertexWeighthvNV)
  GLhalf* weight = OGLM_GET_VARARGS(weight,0,GLhalf,NV,1);
  glVertexWeighthvNV((const GLhalf* )weight);
  OGLM_CHECK_ERR(glVertexWeighthvNV, free(weight);)
  free(weight);

GLenum
glVideoCaptureNV_c(video_capture_slot, sequence_num, capture_time)
  GLuint video_capture_slot;
  GLuint* sequence_num;
  GLuint64EXT *capture_time;
CODE:
  OGLM_GLEWINIT
  OGLM_CHECK_ERR(glVideoCaptureNV, )
  OGLM_AVAIL_CHECK(__glewVideoCaptureNV, glVideoCaptureNV)
  RETVAL = glVideoCaptureNV(video_capture_slot, sequence_num, capture_time);
  OGLM_CHECK_ERR(glVideoCaptureNV, )
OUTPUT:
  RETVAL

void
glVideoCaptureStreamParameterdvNV_c(video_capture_slot, stream, pname, params)
  GLuint video_capture_slot;
  GLuint stream;
  GLenum pname;
  const GLdouble* params;
CODE:
  OGLM_GLEWINIT
  OGLM_CHECK_ERR(glVideoCaptureStreamParameterdvNV, )
  OGLM_AVAIL_CHECK(__glewVideoCaptureStreamParameterdvNV, glVideoCaptureStreamParameterdvNV)
  glVideoCaptureStreamParameterdvNV(video_capture_slot, stream, pname, params);
  OGLM_CHECK_ERR(glVideoCaptureStreamParameterdvNV, )

void
glVideoCaptureStreamParameterfvNV_c(video_capture_slot, stream, pname, params)
  GLuint video_capture_slot;
  GLuint stream;
  GLenum pname;
  const GLfloat* params;
CODE:
  OGLM_GLEWINIT
  OGLM_CHECK_ERR(glVideoCaptureStreamParameterfvNV, )
  OGLM_AVAIL_CHECK(__glewVideoCaptureStreamParameterfvNV, glVideoCaptureStreamParameterfvNV)
  glVideoCaptureStreamParameterfvNV(video_capture_slot, stream, pname, params);
  OGLM_CHECK_ERR(glVideoCaptureStreamParameterfvNV, )

void
glVideoCaptureStreamParameterivNV_c(video_capture_slot, stream, pname, params)
  GLuint video_capture_slot;
  GLuint stream;
  GLenum pname;
  const GLint* params;
CODE:
  OGLM_GLEWINIT
  OGLM_CHECK_ERR(glVideoCaptureStreamParameterivNV, )
  OGLM_AVAIL_CHECK(__glewVideoCaptureStreamParameterivNV, glVideoCaptureStreamParameterivNV)
  glVideoCaptureStreamParameterivNV(video_capture_slot, stream, pname, params);
  OGLM_CHECK_ERR(glVideoCaptureStreamParameterivNV, )

void
glViewport(x, y, width, height)
  GLint x;
  GLint y;
  GLsizei width;
  GLsizei height;
CODE:
  OGLM_GLEWINIT
  OGLM_CHECK_ERR(glViewport, )
  glViewport(x, y, width, height);
  OGLM_CHECK_ERR(glViewport, )

void
glViewportArrayv_c(first, count, v)
  GLuint first;
  GLsizei count;
  const GLfloat * v;
ALIAS:
  glViewportArrayvNV_c = 1
CODE:
  OGLM_GLEWINIT
  OGLM_CHECK_ERR(glViewportArrayv, )
  OGLM_AVAIL_CHECK(__glewViewportArrayv, glViewportArrayv)
  glViewportArrayv(first, count, v);
  OGLM_CHECK_ERR(glViewportArrayv, )

void
glViewportArrayv_p(first, ...)
  GLuint first;
ALIAS:
  glViewportArrayvNV_p = 1
CODE:
  OGLM_GLEWINIT
  OGLM_CHECK_ERR(glViewportArrayv, )
  OGLM_AVAIL_CHECK(__glewViewportArrayv, glViewportArrayv)
  GLsizei count = items-1;
  GLfloat * v = OGLM_GET_VARARGS(v,1,GLfloat,NV,count);
  glViewportArrayv((GLuint )first, (GLsizei )count, (const GLfloat * )v);
  OGLM_CHECK_ERR(glViewportArrayv, free(v);)
  free(v);

void
glViewportIndexedf(index, x, y, w, h)
  GLuint index;
  GLfloat x;
  GLfloat y;
  GLfloat w;
  GLfloat h;
ALIAS:
  glViewportIndexedfNV = 1
CODE:
  OGLM_GLEWINIT
  OGLM_CHECK_ERR(glViewportIndexedf, )
  OGLM_AVAIL_CHECK(__glewViewportIndexedf, glViewportIndexedf)
  glViewportIndexedf(index, x, y, w, h);
  OGLM_CHECK_ERR(glViewportIndexedf, )

void
glViewportIndexedfv_c(index, v)
  GLuint index;
  const GLfloat * v;
ALIAS:
  glViewportIndexedfvNV_c = 1
CODE:
  OGLM_GLEWINIT
  OGLM_CHECK_ERR(glViewportIndexedfv, )
  OGLM_AVAIL_CHECK(__glewViewportIndexedfv, glViewportIndexedfv)
  glViewportIndexedfv(index, v);
  OGLM_CHECK_ERR(glViewportIndexedfv, )

void
glViewportIndexedfv_p(index, ...)
  GLuint index;
ALIAS:
  glViewportIndexedfvNV_p = 1
CODE:
  OGLM_GLEWINIT
  OGLM_CHECK_ERR(glViewportIndexedfv, )
  OGLM_AVAIL_CHECK(__glewViewportIndexedfv, glViewportIndexedfv)
  GLfloat * v = OGLM_GET_VARARGS(v,1,GLfloat,NV,4);
  glViewportIndexedfv((GLuint )index, (const GLfloat * )v);
  OGLM_CHECK_ERR(glViewportIndexedfv, free(v);)
  free(v);

void
glViewportPositionWScaleNV(index, xcoeff, ycoeff)
  GLuint index;
  GLfloat xcoeff;
  GLfloat ycoeff;
CODE:
  OGLM_GLEWINIT
  OGLM_CHECK_ERR(glViewportPositionWScaleNV, )
  OGLM_AVAIL_CHECK(__glewViewportPositionWScaleNV, glViewportPositionWScaleNV)
  glViewportPositionWScaleNV(index, xcoeff, ycoeff);
  OGLM_CHECK_ERR(glViewportPositionWScaleNV, )

void
glViewportSwizzleNV(index, swizzlex, swizzley, swizzlez, swizzlew)
  GLuint index;
  GLenum swizzlex;
  GLenum swizzley;
  GLenum swizzlez;
  GLenum swizzlew;
CODE:
  OGLM_GLEWINIT
  OGLM_CHECK_ERR(glViewportSwizzleNV, )
  OGLM_AVAIL_CHECK(__glewViewportSwizzleNV, glViewportSwizzleNV)
  glViewportSwizzleNV(index, swizzlex, swizzley, swizzlez, swizzlew);
  OGLM_CHECK_ERR(glViewportSwizzleNV, )

void
glWaitSemaphoreEXT_c(semaphore, numBufferBarriers, buffers, numTextureBarriers, textures, srcLayouts)
  GLuint semaphore;
  GLuint numBufferBarriers;
  const GLuint* buffers;
  GLuint numTextureBarriers;
  const GLuint *textures;
  const GLenum *srcLayouts;
CODE:
  OGLM_GLEWINIT
  OGLM_CHECK_ERR(glWaitSemaphoreEXT, )
  OGLM_AVAIL_CHECK(__glewWaitSemaphoreEXT, glWaitSemaphoreEXT)
  glWaitSemaphoreEXT(semaphore, numBufferBarriers, buffers, numTextureBarriers, textures, srcLayouts);
  OGLM_CHECK_ERR(glWaitSemaphoreEXT, )

void
glWaitSemaphoreui64NVX_c(waitGpu, fenceObjectCount, semaphoreArray, fenceValueArray)
  GLuint waitGpu;
  GLsizei fenceObjectCount;
  const GLuint* semaphoreArray;
  const GLuint64 *fenceValueArray;
CODE:
  OGLM_GLEWINIT
  OGLM_CHECK_ERR(glWaitSemaphoreui64NVX, )
  OGLM_AVAIL_CHECK(__glewWaitSemaphoreui64NVX, glWaitSemaphoreui64NVX)
  glWaitSemaphoreui64NVX(waitGpu, fenceObjectCount, semaphoreArray, fenceValueArray);
  OGLM_CHECK_ERR(glWaitSemaphoreui64NVX, )

void
glWaitSemaphoreui64NVX_p(waitGpu, semaphoreArraySV, fenceValueArraySV)
  GLuint waitGpu;
  SV *semaphoreArraySV;
  SV *fenceValueArraySV;
CODE:
  OGLM_GLEWINIT
  OGLM_CHECK_ERR(glWaitSemaphoreui64NVX, )
  OGLM_AVAIL_CHECK(__glewWaitSemaphoreui64NVX, glWaitSemaphoreui64NVX)
  GLsizei fenceObjectCount = OGLM_LEN_ARRAY(fenceObjectCount, semaphoreArray);
  GLuint64 *fenceValueArray = OGLM_GET_ARRAY(fenceValueArray, GLuint64, UV, fenceObjectCount);
  GLuint* semaphoreArray = OGLM_GET_ARRAY(semaphoreArray, GLuint, UV, fenceObjectCount);
  glWaitSemaphoreui64NVX((GLuint )waitGpu, (GLsizei )fenceObjectCount, (const GLuint* )semaphoreArray, (const GLuint64 *)fenceValueArray);
  OGLM_CHECK_ERR(glWaitSemaphoreui64NVX, free(fenceValueArray);free(semaphoreArray);)
  free(fenceValueArray);free(semaphoreArray);

void
glWaitSync(sync, flags, timeout)
  GLsync sync;
  GLbitfield flags;
  GLuint64 timeout;
ALIAS:
  glWaitSyncAPPLE = 1
CODE:
  OGLM_GLEWINIT
  OGLM_CHECK_ERR(glWaitSync, )
  OGLM_AVAIL_CHECK(__glewWaitSync, glWaitSync)
  glWaitSync(sync, flags, timeout);
  OGLM_CHECK_ERR(glWaitSync, )

void
glWaitVkSemaphoreNV(vkSemaphore)
  GLuint64 vkSemaphore;
CODE:
  OGLM_GLEWINIT
  OGLM_CHECK_ERR(glWaitVkSemaphoreNV, )
  OGLM_AVAIL_CHECK(__glewWaitVkSemaphoreNV, glWaitVkSemaphoreNV)
  glWaitVkSemaphoreNV(vkSemaphore);
  OGLM_CHECK_ERR(glWaitVkSemaphoreNV, )

void
glWeightPathsNV_c(resultPath, numPaths, paths, weights)
  GLuint resultPath;
  GLsizei numPaths;
  const GLuint * paths;
  const GLfloat * weights;
CODE:
  OGLM_GLEWINIT
  OGLM_CHECK_ERR(glWeightPathsNV, )
  OGLM_AVAIL_CHECK(__glewWeightPathsNV, glWeightPathsNV)
  glWeightPathsNV(resultPath, numPaths, paths, weights);
  OGLM_CHECK_ERR(glWeightPathsNV, )

void
glWeightPathsNV_p(resultPath, pathsSV, weightsSV)
  GLuint resultPath;
  SV *pathsSV;
  SV *weightsSV;
CODE:
  OGLM_GLEWINIT
  OGLM_CHECK_ERR(glWeightPathsNV, )
  OGLM_AVAIL_CHECK(__glewWeightPathsNV, glWeightPathsNV)
  GLsizei numPaths = OGLM_LEN_ARRAY(numPaths, paths);
  GLuint * paths = OGLM_GET_ARRAY(paths, GLuint, UV, numPaths);
  GLfloat * weights = OGLM_GET_ARRAY(weights, GLfloat, NV, numPaths);
  glWeightPathsNV((GLuint )resultPath, (GLsizei )numPaths, (const GLuint * )paths, (const GLfloat * )weights);
  OGLM_CHECK_ERR(glWeightPathsNV, free(paths);free(weights);)
  free(paths);free(weights);

void
glWeightPointerARB_c(size, type, stride, pointer)
  GLint size;
  GLenum type;
  GLsizei stride;
  void *pointer;
CODE:
  OGLM_GLEWINIT
  OGLM_CHECK_ERR(glWeightPointerARB, )
  OGLM_AVAIL_CHECK(__glewWeightPointerARB, glWeightPointerARB)
  glWeightPointerARB(size, type, stride, pointer);
  OGLM_CHECK_ERR(glWeightPointerARB, )

void
glWeightPointerOES_c(size, type, stride, pointer)
  GLint size;
  GLenum type;
  GLsizei stride;
  void *pointer;
CODE:
  OGLM_GLEWINIT
  OGLM_CHECK_ERR(glWeightPointerOES, )
  OGLM_AVAIL_CHECK(__glewWeightPointerOES, glWeightPointerOES)
  glWeightPointerOES(size, type, stride, pointer);
  OGLM_CHECK_ERR(glWeightPointerOES, )

void
glWeightbvARB_c(size, weights)
  GLint size;
  GLbyte *weights;
CODE:
  OGLM_GLEWINIT
  OGLM_CHECK_ERR(glWeightbvARB, )
  OGLM_AVAIL_CHECK(__glewWeightbvARB, glWeightbvARB)
  glWeightbvARB(size, weights);
  OGLM_CHECK_ERR(glWeightbvARB, )

void
glWeightbvARB_p(size)
  GLint size;
PPCODE:
  OGLM_GLEWINIT
  OGLM_CHECK_ERR(glWeightbvARB, )
  OGLM_AVAIL_CHECK(__glewWeightbvARB, glWeightbvARB)
  GLbyte *weights = OGLM_ALLOC(size,GLbyte,weights);
  glWeightbvARB(size, weights);
  OGLM_CHECK_ERR(glWeightbvARB, free(weights);)
  OGLM_OUT_FINISH(weights,size,newSViv)
  free(weights);

void
glWeightdvARB_c(size, weights)
  GLint size;
  GLdouble *weights;
CODE:
  OGLM_GLEWINIT
  OGLM_CHECK_ERR(glWeightdvARB, )
  OGLM_AVAIL_CHECK(__glewWeightdvARB, glWeightdvARB)
  glWeightdvARB(size, weights);
  OGLM_CHECK_ERR(glWeightdvARB, )

void
glWeightdvARB_p(size)
  GLint size;
PPCODE:
  OGLM_GLEWINIT
  OGLM_CHECK_ERR(glWeightdvARB, )
  OGLM_AVAIL_CHECK(__glewWeightdvARB, glWeightdvARB)
  GLdouble *weights = OGLM_ALLOC(size,GLdouble,weights);
  glWeightdvARB(size, weights);
  OGLM_CHECK_ERR(glWeightdvARB, free(weights);)
  OGLM_OUT_FINISH(weights,size,newSVnv)
  free(weights);

void
glWeightfvARB_c(size, weights)
  GLint size;
  GLfloat *weights;
CODE:
  OGLM_GLEWINIT
  OGLM_CHECK_ERR(glWeightfvARB, )
  OGLM_AVAIL_CHECK(__glewWeightfvARB, glWeightfvARB)
  glWeightfvARB(size, weights);
  OGLM_CHECK_ERR(glWeightfvARB, )

void
glWeightfvARB_p(size)
  GLint size;
PPCODE:
  OGLM_GLEWINIT
  OGLM_CHECK_ERR(glWeightfvARB, )
  OGLM_AVAIL_CHECK(__glewWeightfvARB, glWeightfvARB)
  GLfloat *weights = OGLM_ALLOC(size,GLfloat,weights);
  glWeightfvARB(size, weights);
  OGLM_CHECK_ERR(glWeightfvARB, free(weights);)
  OGLM_OUT_FINISH(weights,size,newSVnv)
  free(weights);

void
glWeightivARB_c(size, weights)
  GLint size;
  GLint *weights;
CODE:
  OGLM_GLEWINIT
  OGLM_CHECK_ERR(glWeightivARB, )
  OGLM_AVAIL_CHECK(__glewWeightivARB, glWeightivARB)
  glWeightivARB(size, weights);
  OGLM_CHECK_ERR(glWeightivARB, )

void
glWeightivARB_p(size)
  GLint size;
PPCODE:
  OGLM_GLEWINIT
  OGLM_CHECK_ERR(glWeightivARB, )
  OGLM_AVAIL_CHECK(__glewWeightivARB, glWeightivARB)
  GLint *weights = OGLM_ALLOC(size,GLint,weights);
  glWeightivARB(size, weights);
  OGLM_CHECK_ERR(glWeightivARB, free(weights);)
  OGLM_OUT_FINISH(weights,size,newSViv)
  free(weights);

void
glWeightsvARB_c(size, weights)
  GLint size;
  GLshort *weights;
CODE:
  OGLM_GLEWINIT
  OGLM_CHECK_ERR(glWeightsvARB, )
  OGLM_AVAIL_CHECK(__glewWeightsvARB, glWeightsvARB)
  glWeightsvARB(size, weights);
  OGLM_CHECK_ERR(glWeightsvARB, )

void
glWeightsvARB_p(size)
  GLint size;
PPCODE:
  OGLM_GLEWINIT
  OGLM_CHECK_ERR(glWeightsvARB, )
  OGLM_AVAIL_CHECK(__glewWeightsvARB, glWeightsvARB)
  GLshort *weights = OGLM_ALLOC(size,GLshort,weights);
  glWeightsvARB(size, weights);
  OGLM_CHECK_ERR(glWeightsvARB, free(weights);)
  OGLM_OUT_FINISH(weights,size,newSViv)
  free(weights);

void
glWeightubvARB_c(size, weights)
  GLint size;
  GLubyte *weights;
CODE:
  OGLM_GLEWINIT
  OGLM_CHECK_ERR(glWeightubvARB, )
  OGLM_AVAIL_CHECK(__glewWeightubvARB, glWeightubvARB)
  glWeightubvARB(size, weights);
  OGLM_CHECK_ERR(glWeightubvARB, )

void
glWeightubvARB_p(size)
  GLint size;
PPCODE:
  OGLM_GLEWINIT
  OGLM_CHECK_ERR(glWeightubvARB, )
  OGLM_AVAIL_CHECK(__glewWeightubvARB, glWeightubvARB)
  GLubyte *weights = OGLM_ALLOC(size,GLubyte,weights);
  glWeightubvARB(size, weights);
  OGLM_CHECK_ERR(glWeightubvARB, free(weights);)
  OGLM_OUT_FINISH(weights,size,newSVuv)
  free(weights);

void
glWeightuivARB_c(size, weights)
  GLint size;
  GLuint *weights;
CODE:
  OGLM_GLEWINIT
  OGLM_CHECK_ERR(glWeightuivARB, )
  OGLM_AVAIL_CHECK(__glewWeightuivARB, glWeightuivARB)
  glWeightuivARB(size, weights);
  OGLM_CHECK_ERR(glWeightuivARB, )

void
glWeightuivARB_p(size)
  GLint size;
PPCODE:
  OGLM_GLEWINIT
  OGLM_CHECK_ERR(glWeightuivARB, )
  OGLM_AVAIL_CHECK(__glewWeightuivARB, glWeightuivARB)
  GLuint *weights = OGLM_ALLOC(size,GLuint,weights);
  glWeightuivARB(size, weights);
  OGLM_CHECK_ERR(glWeightuivARB, free(weights);)
  OGLM_OUT_FINISH(weights,size,newSVuv)
  free(weights);

void
glWeightusvARB_c(size, weights)
  GLint size;
  GLushort *weights;
CODE:
  OGLM_GLEWINIT
  OGLM_CHECK_ERR(glWeightusvARB, )
  OGLM_AVAIL_CHECK(__glewWeightusvARB, glWeightusvARB)
  glWeightusvARB(size, weights);
  OGLM_CHECK_ERR(glWeightusvARB, )

void
glWeightusvARB_p(size)
  GLint size;
PPCODE:
  OGLM_GLEWINIT
  OGLM_CHECK_ERR(glWeightusvARB, )
  OGLM_AVAIL_CHECK(__glewWeightusvARB, glWeightusvARB)
  GLushort *weights = OGLM_ALLOC(size,GLushort,weights);
  glWeightusvARB(size, weights);
  OGLM_CHECK_ERR(glWeightusvARB, free(weights);)
  OGLM_OUT_FINISH(weights,size,newSVuv)
  free(weights);

void
glWindowPos2d(x, y)
  GLdouble x;
  GLdouble y;
ALIAS:
  glWindowPos2dARB = 1
  glWindowPos2dMESA = 2
CODE:
  OGLM_GLEWINIT
  OGLM_CHECK_ERR(glWindowPos2d, )
  OGLM_AVAIL_CHECK(__glewWindowPos2d, glWindowPos2d)
  glWindowPos2d(x, y);
  OGLM_CHECK_ERR(glWindowPos2d, )

void
glWindowPos2dv_c(v)
  const GLdouble *v;
ALIAS:
  glWindowPos2dvARB_c = 1
  glWindowPos2dvMESA_c = 2
CODE:
  OGLM_GLEWINIT
  OGLM_CHECK_ERR(glWindowPos2dv, )
  OGLM_AVAIL_CHECK(__glewWindowPos2dv, glWindowPos2dv)
  glWindowPos2dv(v);
  OGLM_CHECK_ERR(glWindowPos2dv, )

void
glWindowPos2dv_p(...)
ALIAS:
  glWindowPos2dvARB_p = 1
  glWindowPos2dvMESA_p = 2
CODE:
  OGLM_GLEWINIT
  OGLM_CHECK_ERR(glWindowPos2dv, )
  OGLM_AVAIL_CHECK(__glewWindowPos2dv, glWindowPos2dv)
  GLdouble *v = OGLM_GET_VARARGS(v,0,GLdouble,NV,2);
  glWindowPos2dv((const GLdouble *)v);
  OGLM_CHECK_ERR(glWindowPos2dv, free(v);)
  free(v);

void
glWindowPos2f(x, y)
  GLfloat x;
  GLfloat y;
ALIAS:
  glWindowPos2fARB = 1
  glWindowPos2fMESA = 2
CODE:
  OGLM_GLEWINIT
  OGLM_CHECK_ERR(glWindowPos2f, )
  OGLM_AVAIL_CHECK(__glewWindowPos2f, glWindowPos2f)
  glWindowPos2f(x, y);
  OGLM_CHECK_ERR(glWindowPos2f, )

void
glWindowPos2fv_c(v)
  const GLfloat *v;
ALIAS:
  glWindowPos2fvARB_c = 1
  glWindowPos2fvMESA_c = 2
CODE:
  OGLM_GLEWINIT
  OGLM_CHECK_ERR(glWindowPos2fv, )
  OGLM_AVAIL_CHECK(__glewWindowPos2fv, glWindowPos2fv)
  glWindowPos2fv(v);
  OGLM_CHECK_ERR(glWindowPos2fv, )

void
glWindowPos2fv_p(...)
ALIAS:
  glWindowPos2fvARB_p = 1
  glWindowPos2fvMESA_p = 2
CODE:
  OGLM_GLEWINIT
  OGLM_CHECK_ERR(glWindowPos2fv, )
  OGLM_AVAIL_CHECK(__glewWindowPos2fv, glWindowPos2fv)
  GLfloat *v = OGLM_GET_VARARGS(v,0,GLfloat,NV,2);
  glWindowPos2fv((const GLfloat *)v);
  OGLM_CHECK_ERR(glWindowPos2fv, free(v);)
  free(v);

void
glWindowPos2i(x, y)
  GLint x;
  GLint y;
ALIAS:
  glWindowPos2iARB = 1
  glWindowPos2iMESA = 2
CODE:
  OGLM_GLEWINIT
  OGLM_CHECK_ERR(glWindowPos2i, )
  OGLM_AVAIL_CHECK(__glewWindowPos2i, glWindowPos2i)
  glWindowPos2i(x, y);
  OGLM_CHECK_ERR(glWindowPos2i, )

void
glWindowPos2iv_c(v)
  const GLint *v;
ALIAS:
  glWindowPos2ivARB_c = 1
  glWindowPos2ivMESA_c = 2
CODE:
  OGLM_GLEWINIT
  OGLM_CHECK_ERR(glWindowPos2iv, )
  OGLM_AVAIL_CHECK(__glewWindowPos2iv, glWindowPos2iv)
  glWindowPos2iv(v);
  OGLM_CHECK_ERR(glWindowPos2iv, )

void
glWindowPos2iv_p(...)
ALIAS:
  glWindowPos2ivARB_p = 1
  glWindowPos2ivMESA_p = 2
CODE:
  OGLM_GLEWINIT
  OGLM_CHECK_ERR(glWindowPos2iv, )
  OGLM_AVAIL_CHECK(__glewWindowPos2iv, glWindowPos2iv)
  GLint *v = OGLM_GET_VARARGS(v,0,GLint,IV,2);
  glWindowPos2iv((const GLint *)v);
  OGLM_CHECK_ERR(glWindowPos2iv, free(v);)
  free(v);

void
glWindowPos2s(x, y)
  GLshort x;
  GLshort y;
ALIAS:
  glWindowPos2sARB = 1
  glWindowPos2sMESA = 2
CODE:
  OGLM_GLEWINIT
  OGLM_CHECK_ERR(glWindowPos2s, )
  OGLM_AVAIL_CHECK(__glewWindowPos2s, glWindowPos2s)
  glWindowPos2s(x, y);
  OGLM_CHECK_ERR(glWindowPos2s, )

void
glWindowPos2sv_c(v)
  const GLshort *v;
ALIAS:
  glWindowPos2svARB_c = 1
  glWindowPos2svMESA_c = 2
CODE:
  OGLM_GLEWINIT
  OGLM_CHECK_ERR(glWindowPos2sv, )
  OGLM_AVAIL_CHECK(__glewWindowPos2sv, glWindowPos2sv)
  glWindowPos2sv(v);
  OGLM_CHECK_ERR(glWindowPos2sv, )

void
glWindowPos2sv_p(...)
ALIAS:
  glWindowPos2svARB_p = 1
  glWindowPos2svMESA_p = 2
CODE:
  OGLM_GLEWINIT
  OGLM_CHECK_ERR(glWindowPos2sv, )
  OGLM_AVAIL_CHECK(__glewWindowPos2sv, glWindowPos2sv)
  GLshort *v = OGLM_GET_VARARGS(v,0,GLshort,IV,2);
  glWindowPos2sv((const GLshort *)v);
  OGLM_CHECK_ERR(glWindowPos2sv, free(v);)
  free(v);

void
glWindowPos3d(x, y, z)
  GLdouble x;
  GLdouble y;
  GLdouble z;
ALIAS:
  glWindowPos3dARB = 1
  glWindowPos3dMESA = 2
CODE:
  OGLM_GLEWINIT
  OGLM_CHECK_ERR(glWindowPos3d, )
  OGLM_AVAIL_CHECK(__glewWindowPos3d, glWindowPos3d)
  glWindowPos3d(x, y, z);
  OGLM_CHECK_ERR(glWindowPos3d, )

void
glWindowPos3dv_c(v)
  const GLdouble *v;
ALIAS:
  glWindowPos3dvARB_c = 1
  glWindowPos3dvMESA_c = 2
CODE:
  OGLM_GLEWINIT
  OGLM_CHECK_ERR(glWindowPos3dv, )
  OGLM_AVAIL_CHECK(__glewWindowPos3dv, glWindowPos3dv)
  glWindowPos3dv(v);
  OGLM_CHECK_ERR(glWindowPos3dv, )

void
glWindowPos3dv_p(...)
ALIAS:
  glWindowPos3dvARB_p = 1
  glWindowPos3dvMESA_p = 2
CODE:
  OGLM_GLEWINIT
  OGLM_CHECK_ERR(glWindowPos3dv, )
  OGLM_AVAIL_CHECK(__glewWindowPos3dv, glWindowPos3dv)
  GLdouble *v = OGLM_GET_VARARGS(v,0,GLdouble,NV,3);
  glWindowPos3dv((const GLdouble *)v);
  OGLM_CHECK_ERR(glWindowPos3dv, free(v);)
  free(v);

void
glWindowPos3f(x, y, z)
  GLfloat x;
  GLfloat y;
  GLfloat z;
ALIAS:
  glWindowPos3fARB = 1
  glWindowPos3fMESA = 2
CODE:
  OGLM_GLEWINIT
  OGLM_CHECK_ERR(glWindowPos3f, )
  OGLM_AVAIL_CHECK(__glewWindowPos3f, glWindowPos3f)
  glWindowPos3f(x, y, z);
  OGLM_CHECK_ERR(glWindowPos3f, )

void
glWindowPos3fv_c(v)
  const GLfloat *v;
ALIAS:
  glWindowPos3fvARB_c = 1
  glWindowPos3fvMESA_c = 2
CODE:
  OGLM_GLEWINIT
  OGLM_CHECK_ERR(glWindowPos3fv, )
  OGLM_AVAIL_CHECK(__glewWindowPos3fv, glWindowPos3fv)
  glWindowPos3fv(v);
  OGLM_CHECK_ERR(glWindowPos3fv, )

void
glWindowPos3fv_p(...)
ALIAS:
  glWindowPos3fvARB_p = 1
  glWindowPos3fvMESA_p = 2
CODE:
  OGLM_GLEWINIT
  OGLM_CHECK_ERR(glWindowPos3fv, )
  OGLM_AVAIL_CHECK(__glewWindowPos3fv, glWindowPos3fv)
  GLfloat *v = OGLM_GET_VARARGS(v,0,GLfloat,NV,3);
  glWindowPos3fv((const GLfloat *)v);
  OGLM_CHECK_ERR(glWindowPos3fv, free(v);)
  free(v);

void
glWindowPos3i(x, y, z)
  GLint x;
  GLint y;
  GLint z;
ALIAS:
  glWindowPos3iARB = 1
  glWindowPos3iMESA = 2
CODE:
  OGLM_GLEWINIT
  OGLM_CHECK_ERR(glWindowPos3i, )
  OGLM_AVAIL_CHECK(__glewWindowPos3i, glWindowPos3i)
  glWindowPos3i(x, y, z);
  OGLM_CHECK_ERR(glWindowPos3i, )

void
glWindowPos3iv_c(v)
  const GLint *v;
ALIAS:
  glWindowPos3ivARB_c = 1
  glWindowPos3ivMESA_c = 2
CODE:
  OGLM_GLEWINIT
  OGLM_CHECK_ERR(glWindowPos3iv, )
  OGLM_AVAIL_CHECK(__glewWindowPos3iv, glWindowPos3iv)
  glWindowPos3iv(v);
  OGLM_CHECK_ERR(glWindowPos3iv, )

void
glWindowPos3iv_p(...)
ALIAS:
  glWindowPos3ivARB_p = 1
  glWindowPos3ivMESA_p = 2
CODE:
  OGLM_GLEWINIT
  OGLM_CHECK_ERR(glWindowPos3iv, )
  OGLM_AVAIL_CHECK(__glewWindowPos3iv, glWindowPos3iv)
  GLint *v = OGLM_GET_VARARGS(v,0,GLint,IV,3);
  glWindowPos3iv((const GLint *)v);
  OGLM_CHECK_ERR(glWindowPos3iv, free(v);)
  free(v);

void
glWindowPos3s(x, y, z)
  GLshort x;
  GLshort y;
  GLshort z;
ALIAS:
  glWindowPos3sARB = 1
  glWindowPos3sMESA = 2
CODE:
  OGLM_GLEWINIT
  OGLM_CHECK_ERR(glWindowPos3s, )
  OGLM_AVAIL_CHECK(__glewWindowPos3s, glWindowPos3s)
  glWindowPos3s(x, y, z);
  OGLM_CHECK_ERR(glWindowPos3s, )

void
glWindowPos3sv_c(v)
  const GLshort *v;
ALIAS:
  glWindowPos3svARB_c = 1
  glWindowPos3svMESA_c = 2
CODE:
  OGLM_GLEWINIT
  OGLM_CHECK_ERR(glWindowPos3sv, )
  OGLM_AVAIL_CHECK(__glewWindowPos3sv, glWindowPos3sv)
  glWindowPos3sv(v);
  OGLM_CHECK_ERR(glWindowPos3sv, )

void
glWindowPos3sv_p(...)
ALIAS:
  glWindowPos3svARB_p = 1
  glWindowPos3svMESA_p = 2
CODE:
  OGLM_GLEWINIT
  OGLM_CHECK_ERR(glWindowPos3sv, )
  OGLM_AVAIL_CHECK(__glewWindowPos3sv, glWindowPos3sv)
  GLshort *v = OGLM_GET_VARARGS(v,0,GLshort,IV,3);
  glWindowPos3sv((const GLshort *)v);
  OGLM_CHECK_ERR(glWindowPos3sv, free(v);)
  free(v);

void
glWindowPos4dMESA(x, y, z, param4)
  GLdouble x;
  GLdouble y;
  GLdouble z;
  GLdouble param4;
CODE:
  OGLM_GLEWINIT
  OGLM_CHECK_ERR(glWindowPos4dMESA, )
  OGLM_AVAIL_CHECK(__glewWindowPos4dMESA, glWindowPos4dMESA)
  glWindowPos4dMESA(x, y, z, param4);
  OGLM_CHECK_ERR(glWindowPos4dMESA, )

void
glWindowPos4dvMESA_c(v)
  const GLdouble* v;
CODE:
  OGLM_GLEWINIT
  OGLM_CHECK_ERR(glWindowPos4dvMESA, )
  OGLM_AVAIL_CHECK(__glewWindowPos4dvMESA, glWindowPos4dvMESA)
  glWindowPos4dvMESA(v);
  OGLM_CHECK_ERR(glWindowPos4dvMESA, )

void
glWindowPos4dvMESA_p(...)
CODE:
  OGLM_GLEWINIT
  OGLM_CHECK_ERR(glWindowPos4dvMESA, )
  OGLM_AVAIL_CHECK(__glewWindowPos4dvMESA, glWindowPos4dvMESA)
  GLdouble* v = OGLM_GET_VARARGS(v,0,GLdouble,NV,4);
  glWindowPos4dvMESA((const GLdouble* )v);
  OGLM_CHECK_ERR(glWindowPos4dvMESA, free(v);)
  free(v);

void
glWindowPos4fMESA(x, y, z, w)
  GLfloat x;
  GLfloat y;
  GLfloat z;
  GLfloat w;
CODE:
  OGLM_GLEWINIT
  OGLM_CHECK_ERR(glWindowPos4fMESA, )
  OGLM_AVAIL_CHECK(__glewWindowPos4fMESA, glWindowPos4fMESA)
  glWindowPos4fMESA(x, y, z, w);
  OGLM_CHECK_ERR(glWindowPos4fMESA, )

void
glWindowPos4fvMESA_c(v)
  const GLfloat* v;
CODE:
  OGLM_GLEWINIT
  OGLM_CHECK_ERR(glWindowPos4fvMESA, )
  OGLM_AVAIL_CHECK(__glewWindowPos4fvMESA, glWindowPos4fvMESA)
  glWindowPos4fvMESA(v);
  OGLM_CHECK_ERR(glWindowPos4fvMESA, )

void
glWindowPos4fvMESA_p(...)
CODE:
  OGLM_GLEWINIT
  OGLM_CHECK_ERR(glWindowPos4fvMESA, )
  OGLM_AVAIL_CHECK(__glewWindowPos4fvMESA, glWindowPos4fvMESA)
  GLfloat* v = OGLM_GET_VARARGS(v,0,GLfloat,NV,4);
  glWindowPos4fvMESA((const GLfloat* )v);
  OGLM_CHECK_ERR(glWindowPos4fvMESA, free(v);)
  free(v);

void
glWindowPos4iMESA(x, y, z, w)
  GLint x;
  GLint y;
  GLint z;
  GLint w;
CODE:
  OGLM_GLEWINIT
  OGLM_CHECK_ERR(glWindowPos4iMESA, )
  OGLM_AVAIL_CHECK(__glewWindowPos4iMESA, glWindowPos4iMESA)
  glWindowPos4iMESA(x, y, z, w);
  OGLM_CHECK_ERR(glWindowPos4iMESA, )

void
glWindowPos4ivMESA_c(v)
  const GLint* v;
CODE:
  OGLM_GLEWINIT
  OGLM_CHECK_ERR(glWindowPos4ivMESA, )
  OGLM_AVAIL_CHECK(__glewWindowPos4ivMESA, glWindowPos4ivMESA)
  glWindowPos4ivMESA(v);
  OGLM_CHECK_ERR(glWindowPos4ivMESA, )

void
glWindowPos4ivMESA_p(...)
CODE:
  OGLM_GLEWINIT
  OGLM_CHECK_ERR(glWindowPos4ivMESA, )
  OGLM_AVAIL_CHECK(__glewWindowPos4ivMESA, glWindowPos4ivMESA)
  GLint* v = OGLM_GET_VARARGS(v,0,GLint,IV,4);
  glWindowPos4ivMESA((const GLint* )v);
  OGLM_CHECK_ERR(glWindowPos4ivMESA, free(v);)
  free(v);

void
glWindowPos4sMESA(x, y, z, w)
  GLshort x;
  GLshort y;
  GLshort z;
  GLshort w;
CODE:
  OGLM_GLEWINIT
  OGLM_CHECK_ERR(glWindowPos4sMESA, )
  OGLM_AVAIL_CHECK(__glewWindowPos4sMESA, glWindowPos4sMESA)
  glWindowPos4sMESA(x, y, z, w);
  OGLM_CHECK_ERR(glWindowPos4sMESA, )

void
glWindowPos4svMESA_c(v)
  const GLshort* v;
CODE:
  OGLM_GLEWINIT
  OGLM_CHECK_ERR(glWindowPos4svMESA, )
  OGLM_AVAIL_CHECK(__glewWindowPos4svMESA, glWindowPos4svMESA)
  glWindowPos4svMESA(v);
  OGLM_CHECK_ERR(glWindowPos4svMESA, )

void
glWindowPos4svMESA_p(...)
CODE:
  OGLM_GLEWINIT
  OGLM_CHECK_ERR(glWindowPos4svMESA, )
  OGLM_AVAIL_CHECK(__glewWindowPos4svMESA, glWindowPos4svMESA)
  GLshort* v = OGLM_GET_VARARGS(v,0,GLshort,IV,4);
  glWindowPos4svMESA((const GLshort* )v);
  OGLM_CHECK_ERR(glWindowPos4svMESA, free(v);)
  free(v);

void
glWindowRectanglesEXT_c(mode, count, box)
  GLenum mode;
  GLsizei count;
  const GLint * box;
CODE:
  OGLM_GLEWINIT
  OGLM_CHECK_ERR(glWindowRectanglesEXT, )
  OGLM_AVAIL_CHECK(__glewWindowRectanglesEXT, glWindowRectanglesEXT)
  glWindowRectanglesEXT(mode, count, box);
  OGLM_CHECK_ERR(glWindowRectanglesEXT, )

void
glWindowRectanglesEXT_p(mode, ...)
  GLenum mode;
CODE:
  OGLM_GLEWINIT
  OGLM_CHECK_ERR(glWindowRectanglesEXT, )
  OGLM_AVAIL_CHECK(__glewWindowRectanglesEXT, glWindowRectanglesEXT)
  GLsizei count = items-1;
  GLint * box = OGLM_GET_VARARGS(box,1,GLint,IV,count);
  glWindowRectanglesEXT((GLenum )mode, (GLsizei )count, (const GLint * )box);
  OGLM_CHECK_ERR(glWindowRectanglesEXT, free(box);)
  free(box);

void
glWriteMaskEXT(res, in, outX, outY, outZ, outW)
  GLuint res;
  GLuint in;
  GLenum outX;
  GLenum outY;
  GLenum outZ;
  GLenum outW;
CODE:
  OGLM_GLEWINIT
  OGLM_CHECK_ERR(glWriteMaskEXT, )
  OGLM_AVAIL_CHECK(__glewWriteMaskEXT, glWriteMaskEXT)
  glWriteMaskEXT(res, in, outX, outY, outZ, outW);
  OGLM_CHECK_ERR(glWriteMaskEXT, )

