graphics-toolkit/src/gl_functions.php

<?php

use Cijber\GraphicsToolkit\GL;
use FFI\Cdata;

// generated gl functions

function glAccum(int $op, float $value) {
  static $proc;
  return ($proc ??= GL::getProcAddress('accum'))($op, $value);
}

function glAccumxOES(int $op, int $value) {
  static $proc;
  return ($proc ??= GL::getProcAddress('accumxOES'))($op, $value);
}

function glActiveProgramEXT(int $program) {
  static $proc;
  return ($proc ??= GL::getProcAddress('activeProgramEXT'))($program);
}

function glActiveShaderProgram(int $pipeline, int $program) {
  static $proc;
  return ($proc ??= GL::getProcAddress('activeShaderProgram'))($pipeline, $program);
}

function glActiveShaderProgramEXT(int $pipeline, int $program) {
  static $proc;
  return ($proc ??= GL::getProcAddress('activeShaderProgramEXT'))($pipeline, $program);
}

function glActiveStencilFaceEXT(int $face) {
  static $proc;
  return ($proc ??= GL::getProcAddress('activeStencilFaceEXT'))($face);
}

function glActiveTexture(int $texture) {
  static $proc;
  return ($proc ??= GL::getProcAddress('activeTexture'))($texture);
}

function glActiveTextureARB(int $texture) {
  static $proc;
  return ($proc ??= GL::getProcAddress('activeTextureARB'))($texture);
}

function glActiveVaryingNV(int $program, $name) {
  static $proc;
  return ($proc ??= GL::getProcAddress('activeVaryingNV'))($program, $name);
}

function glAlphaFragmentOp1ATI(int $op, int $dst, int $dstMod, int $arg1, int $arg1Rep, int $arg1Mod) {
  static $proc;
  return ($proc ??= GL::getProcAddress('alphaFragmentOp1ATI'))($op, $dst, $dstMod, $arg1, $arg1Rep, $arg1Mod);
}

function glAlphaFragmentOp2ATI(int $op, int $dst, int $dstMod, int $arg1, int $arg1Rep, int $arg1Mod, int $arg2, int $arg2Rep, int $arg2Mod) {
  static $proc;
  return ($proc ??= GL::getProcAddress('alphaFragmentOp2ATI'))($op, $dst, $dstMod, $arg1, $arg1Rep, $arg1Mod, $arg2, $arg2Rep, $arg2Mod);
}

function glAlphaFragmentOp3ATI(int $op, int $dst, int $dstMod, int $arg1, int $arg1Rep, int $arg1Mod, int $arg2, int $arg2Rep, int $arg2Mod, int $arg3, int $arg3Rep, int $arg3Mod) {
  static $proc;
  return ($proc ??= GL::getProcAddress('alphaFragmentOp3ATI'))($op, $dst, $dstMod, $arg1, $arg1Rep, $arg1Mod, $arg2, $arg2Rep, $arg2Mod, $arg3, $arg3Rep, $arg3Mod);
}

function glAlphaFunc(int $func, float $ref) {
  static $proc;
  return ($proc ??= GL::getProcAddress('alphaFunc'))($func, $ref);
}

function glAlphaFuncQCOM(int $func, $ref) {
  static $proc;
  return ($proc ??= GL::getProcAddress('alphaFuncQCOM'))($func, $ref);
}

function glAlphaFuncx(int $func, int $ref) {
  static $proc;
  return ($proc ??= GL::getProcAddress('alphaFuncx'))($func, $ref);
}

function glAlphaFuncxOES(int $func, int $ref) {
  static $proc;
  return ($proc ??= GL::getProcAddress('alphaFuncxOES'))($func, $ref);
}

function glApplyFramebufferAttachmentCMAAINTEL() {
  static $proc;
  return ($proc ??= GL::getProcAddress('applyFramebufferAttachmentCMAAINTEL'))();
}

function glApplyTextureEXT(int $mode) {
  static $proc;
  return ($proc ??= GL::getProcAddress('applyTextureEXT'))($mode);
}

function glAreProgramsResidentNV(int $n, $programs, $residences) {
  static $proc;
  return ($proc ??= GL::getProcAddress('areProgramsResidentNV'))($n, $programs, $residences);
}

function glAreTexturesResident(int $n, $textures, $residences) {
  static $proc;
  return ($proc ??= GL::getProcAddress('areTexturesResident'))($n, $textures, $residences);
}

function glAreTexturesResidentEXT(int $n, $textures, $residences) {
  static $proc;
  return ($proc ??= GL::getProcAddress('areTexturesResidentEXT'))($n, $textures, $residences);
}

function glArrayElement(int $i) {
  static $proc;
  return ($proc ??= GL::getProcAddress('arrayElement'))($i);
}

function glArrayElementEXT(int $i) {
  static $proc;
  return ($proc ??= GL::getProcAddress('arrayElementEXT'))($i);
}

function glArrayObjectATI(int $array, int $size, int $type, int $stride, int $buffer, int $offset) {
  static $proc;
  return ($proc ??= GL::getProcAddress('arrayObjectATI'))($array, $size, $type, $stride, $buffer, $offset);
}

function glAsyncMarkerSGIX(int $marker) {
  static $proc;
  return ($proc ??= GL::getProcAddress('asyncMarkerSGIX'))($marker);
}

function glAttachObjectARB(int $containerObj, int $obj) {
  static $proc;
  return ($proc ??= GL::getProcAddress('attachObjectARB'))($containerObj, $obj);
}

function glAttachShader(int $program, int $shader) {
  static $proc;
  return ($proc ??= GL::getProcAddress('attachShader'))($program, $shader);
}

function glBegin(int $mode) {
  static $proc;
  return ($proc ??= GL::getProcAddress('begin'))($mode);
}

function glBeginConditionalRender(int $id, int $mode) {
  static $proc;
  return ($proc ??= GL::getProcAddress('beginConditionalRender'))($id, $mode);
}

function glBeginConditionalRenderNV(int $id, int $mode) {
  static $proc;
  return ($proc ??= GL::getProcAddress('beginConditionalRenderNV'))($id, $mode);
}

function glBeginConditionalRenderNVX(int $id) {
  static $proc;
  return ($proc ??= GL::getProcAddress('beginConditionalRenderNVX'))($id);
}

function glBeginFragmentShaderATI() {
  static $proc;
  return ($proc ??= GL::getProcAddress('beginFragmentShaderATI'))();
}

function glBeginOcclusionQueryNV(int $id) {
  static $proc;
  return ($proc ??= GL::getProcAddress('beginOcclusionQueryNV'))($id);
}

function glBeginPerfMonitorAMD(int $monitor) {
  static $proc;
  return ($proc ??= GL::getProcAddress('beginPerfMonitorAMD'))($monitor);
}

function glBeginPerfQueryINTEL(int $queryHandle) {
  static $proc;
  return ($proc ??= GL::getProcAddress('beginPerfQueryINTEL'))($queryHandle);
}

function glBeginQuery(int $target, int $id) {
  static $proc;
  return ($proc ??= GL::getProcAddress('beginQuery'))($target, $id);
}

function glBeginQueryARB(int $target, int $id) {
  static $proc;
  return ($proc ??= GL::getProcAddress('beginQueryARB'))($target, $id);
}

function glBeginQueryEXT(int $target, int $id) {
  static $proc;
  return ($proc ??= GL::getProcAddress('beginQueryEXT'))($target, $id);
}

function glBeginQueryIndexed(int $target, int $index, int $id) {
  static $proc;
  return ($proc ??= GL::getProcAddress('beginQueryIndexed'))($target, $index, $id);
}

function glBeginTransformFeedback(int $primitiveMode) {
  static $proc;
  return ($proc ??= GL::getProcAddress('beginTransformFeedback'))($primitiveMode);
}

function glBeginTransformFeedbackEXT(int $primitiveMode) {
  static $proc;
  return ($proc ??= GL::getProcAddress('beginTransformFeedbackEXT'))($primitiveMode);
}

function glBeginTransformFeedbackNV(int $primitiveMode) {
  static $proc;
  return ($proc ??= GL::getProcAddress('beginTransformFeedbackNV'))($primitiveMode);
}

function glBeginVertexShaderEXT() {
  static $proc;
  return ($proc ??= GL::getProcAddress('beginVertexShaderEXT'))();
}

function glBeginVideoCaptureNV(int $video_capture_slot) {
  static $proc;
  return ($proc ??= GL::getProcAddress('beginVideoCaptureNV'))($video_capture_slot);
}

function glBindAttribLocation(int $program, int $index, $name) {
  static $proc;
  return ($proc ??= GL::getProcAddress('bindAttribLocation'))($program, $index, $name);
}

function glBindAttribLocationARB(int $programObj, int $index, $name) {
  static $proc;
  return ($proc ??= GL::getProcAddress('bindAttribLocationARB'))($programObj, $index, $name);
}

function glBindBuffer(int $target, int $buffer) {
  static $proc;
  return ($proc ??= GL::getProcAddress('bindBuffer'))($target, $buffer);
}

function glBindBufferARB(int $target, int $buffer) {
  static $proc;
  return ($proc ??= GL::getProcAddress('bindBufferARB'))($target, $buffer);
}

function glBindBufferBase(int $target, int $index, int $buffer) {
  static $proc;
  return ($proc ??= GL::getProcAddress('bindBufferBase'))($target, $index, $buffer);
}

function glBindBufferBaseEXT(int $target, int $index, int $buffer) {
  static $proc;
  return ($proc ??= GL::getProcAddress('bindBufferBaseEXT'))($target, $index, $buffer);
}

function glBindBufferBaseNV(int $target, int $index, int $buffer) {
  static $proc;
  return ($proc ??= GL::getProcAddress('bindBufferBaseNV'))($target, $index, $buffer);
}

function glBindBufferOffsetEXT(int $target, int $index, int $buffer, int $offset) {
  static $proc;
  return ($proc ??= GL::getProcAddress('bindBufferOffsetEXT'))($target, $index, $buffer, $offset);
}

function glBindBufferOffsetNV(int $target, int $index, int $buffer, int $offset) {
  static $proc;
  return ($proc ??= GL::getProcAddress('bindBufferOffsetNV'))($target, $index, $buffer, $offset);
}

function glBindBufferRange(int $target, int $index, int $buffer, int $offset, int $size) {
  static $proc;
  return ($proc ??= GL::getProcAddress('bindBufferRange'))($target, $index, $buffer, $offset, $size);
}

function glBindBufferRangeEXT(int $target, int $index, int $buffer, int $offset, int $size) {
  static $proc;
  return ($proc ??= GL::getProcAddress('bindBufferRangeEXT'))($target, $index, $buffer, $offset, $size);
}

function glBindBufferRangeNV(int $target, int $index, int $buffer, int $offset, int $size) {
  static $proc;
  return ($proc ??= GL::getProcAddress('bindBufferRangeNV'))($target, $index, $buffer, $offset, $size);
}

function glBindBuffersBase(int $target, int $first, int $count, $buffers) {
  static $proc;
  return ($proc ??= GL::getProcAddress('bindBuffersBase'))($target, $first, $count, $buffers);
}

function glBindBuffersRange(int $target, int $first, int $count, $buffers, $offsets, $sizes) {
  static $proc;
  return ($proc ??= GL::getProcAddress('bindBuffersRange'))($target, $first, $count, $buffers, $offsets, $sizes);
}

function glBindFragDataLocation(int $program, int $color, $name) {
  static $proc;
  return ($proc ??= GL::getProcAddress('bindFragDataLocation'))($program, $color, $name);
}

function glBindFragDataLocationEXT(int $program, int $color, $name) {
  static $proc;
  return ($proc ??= GL::getProcAddress('bindFragDataLocationEXT'))($program, $color, $name);
}

function glBindFragDataLocationIndexed(int $program, int $colorNumber, int $index, $name) {
  static $proc;
  return ($proc ??= GL::getProcAddress('bindFragDataLocationIndexed'))($program, $colorNumber, $index, $name);
}

function glBindFragDataLocationIndexedEXT(int $program, int $colorNumber, int $index, $name) {
  static $proc;
  return ($proc ??= GL::getProcAddress('bindFragDataLocationIndexedEXT'))($program, $colorNumber, $index, $name);
}

function glBindFragmentShaderATI(int $id) {
  static $proc;
  return ($proc ??= GL::getProcAddress('bindFragmentShaderATI'))($id);
}

function glBindFramebuffer(int $target, int $framebuffer) {
  static $proc;
  return ($proc ??= GL::getProcAddress('bindFramebuffer'))($target, $framebuffer);
}

function glBindFramebufferEXT(int $target, int $framebuffer) {
  static $proc;
  return ($proc ??= GL::getProcAddress('bindFramebufferEXT'))($target, $framebuffer);
}

function glBindFramebufferOES(int $target, int $framebuffer) {
  static $proc;
  return ($proc ??= GL::getProcAddress('bindFramebufferOES'))($target, $framebuffer);
}

function glBindImageTexture(int $unit, int $texture, int $level, int $layered, int $layer, int $access, int $format) {
  static $proc;
  return ($proc ??= GL::getProcAddress('bindImageTexture'))($unit, $texture, $level, $layered, $layer, $access, $format);
}

function glBindImageTextureEXT(int $index, int $texture, int $level, int $layered, int $layer, int $access, int $format) {
  static $proc;
  return ($proc ??= GL::getProcAddress('bindImageTextureEXT'))($index, $texture, $level, $layered, $layer, $access, $format);
}

function glBindImageTextures(int $first, int $count, $textures) {
  static $proc;
  return ($proc ??= GL::getProcAddress('bindImageTextures'))($first, $count, $textures);
}

function glBindLightParameterEXT(int $light, int $value) {
  static $proc;
  return ($proc ??= GL::getProcAddress('bindLightParameterEXT'))($light, $value);
}

function glBindMaterialParameterEXT(int $face, int $value) {
  static $proc;
  return ($proc ??= GL::getProcAddress('bindMaterialParameterEXT'))($face, $value);
}

function glBindMultiTextureEXT(int $texunit, int $target, int $texture) {
  static $proc;
  return ($proc ??= GL::getProcAddress('bindMultiTextureEXT'))($texunit, $target, $texture);
}

function glBindParameterEXT(int $value) {
  static $proc;
  return ($proc ??= GL::getProcAddress('bindParameterEXT'))($value);
}

function glBindProgramARB(int $target, int $program) {
  static $proc;
  return ($proc ??= GL::getProcAddress('bindProgramARB'))($target, $program);
}

function glBindProgramNV(int $target, int $id) {
  static $proc;
  return ($proc ??= GL::getProcAddress('bindProgramNV'))($target, $id);
}

function glBindProgramPipeline(int $pipeline) {
  static $proc;
  return ($proc ??= GL::getProcAddress('bindProgramPipeline'))($pipeline);
}

function glBindProgramPipelineEXT(int $pipeline) {
  static $proc;
  return ($proc ??= GL::getProcAddress('bindProgramPipelineEXT'))($pipeline);
}

function glBindRenderbuffer(int $target, int $renderbuffer) {
  static $proc;
  return ($proc ??= GL::getProcAddress('bindRenderbuffer'))($target, $renderbuffer);
}

function glBindRenderbufferEXT(int $target, int $renderbuffer) {
  static $proc;
  return ($proc ??= GL::getProcAddress('bindRenderbufferEXT'))($target, $renderbuffer);
}

function glBindRenderbufferOES(int $target, int $renderbuffer) {
  static $proc;
  return ($proc ??= GL::getProcAddress('bindRenderbufferOES'))($target, $renderbuffer);
}

function glBindSampler(int $unit, int $sampler) {
  static $proc;
  return ($proc ??= GL::getProcAddress('bindSampler'))($unit, $sampler);
}

function glBindSamplers(int $first, int $count, $samplers) {
  static $proc;
  return ($proc ??= GL::getProcAddress('bindSamplers'))($first, $count, $samplers);
}

function glBindTexGenParameterEXT(int $unit, int $coord, int $value) {
  static $proc;
  return ($proc ??= GL::getProcAddress('bindTexGenParameterEXT'))($unit, $coord, $value);
}

function glBindTexture(int $target, int $texture) {
  static $proc;
  return ($proc ??= GL::getProcAddress('bindTexture'))($target, $texture);
}

function glBindTextureEXT(int $target, int $texture) {
  static $proc;
  return ($proc ??= GL::getProcAddress('bindTextureEXT'))($target, $texture);
}

function glBindTextureUnit(int $unit, int $texture) {
  static $proc;
  return ($proc ??= GL::getProcAddress('bindTextureUnit'))($unit, $texture);
}

function glBindTextureUnitParameterEXT(int $unit, int $value) {
  static $proc;
  return ($proc ??= GL::getProcAddress('bindTextureUnitParameterEXT'))($unit, $value);
}

function glBindTextures(int $first, int $count, $textures) {
  static $proc;
  return ($proc ??= GL::getProcAddress('bindTextures'))($first, $count, $textures);
}

function glBindTransformFeedback(int $target, int $id) {
  static $proc;
  return ($proc ??= GL::getProcAddress('bindTransformFeedback'))($target, $id);
}

function glBindTransformFeedbackNV(int $target, int $id) {
  static $proc;
  return ($proc ??= GL::getProcAddress('bindTransformFeedbackNV'))($target, $id);
}

function glBindVertexArray(int $array) {
  static $proc;
  return ($proc ??= GL::getProcAddress('bindVertexArray'))($array);
}

function glBindVertexArrayAPPLE(int $array) {
  static $proc;
  return ($proc ??= GL::getProcAddress('bindVertexArrayAPPLE'))($array);
}

function glBindVertexArrayOES(int $array) {
  static $proc;
  return ($proc ??= GL::getProcAddress('bindVertexArrayOES'))($array);
}

function glBindVertexBuffer(int $bindingindex, int $buffer, int $offset, int $stride) {
  static $proc;
  return ($proc ??= GL::getProcAddress('bindVertexBuffer'))($bindingindex, $buffer, $offset, $stride);
}

function glBindVertexBuffers(int $first, int $count, $buffers, $offsets, $strides) {
  static $proc;
  return ($proc ??= GL::getProcAddress('bindVertexBuffers'))($first, $count, $buffers, $offsets, $strides);
}

function glBindVertexShaderEXT(int $id) {
  static $proc;
  return ($proc ??= GL::getProcAddress('bindVertexShaderEXT'))($id);
}

function glBindVideoCaptureStreamBufferNV(int $video_capture_slot, int $stream, int $frame_region, int $offset) {
  static $proc;
  return ($proc ??= GL::getProcAddress('bindVideoCaptureStreamBufferNV'))($video_capture_slot, $stream, $frame_region, $offset);
}

function glBindVideoCaptureStreamTextureNV(int $video_capture_slot, int $stream, int $frame_region, int $target, int $texture) {
  static $proc;
  return ($proc ??= GL::getProcAddress('bindVideoCaptureStreamTextureNV'))($video_capture_slot, $stream, $frame_region, $target, $texture);
}

function glBinormal3bEXT(int $bx, int $by, int $bz) {
  static $proc;
  return ($proc ??= GL::getProcAddress('binormal3bEXT'))($bx, $by, $bz);
}

function glBinormal3bvEXT($v) {
  static $proc;
  return ($proc ??= GL::getProcAddress('binormal3bvEXT'))($v);
}

function glBinormal3dEXT(float $bx, float $by, float $bz) {
  static $proc;
  return ($proc ??= GL::getProcAddress('binormal3dEXT'))($bx, $by, $bz);
}

function glBinormal3dvEXT($v) {
  static $proc;
  return ($proc ??= GL::getProcAddress('binormal3dvEXT'))($v);
}

function glBinormal3fEXT(float $bx, float $by, float $bz) {
  static $proc;
  return ($proc ??= GL::getProcAddress('binormal3fEXT'))($bx, $by, $bz);
}

function glBinormal3fvEXT($v) {
  static $proc;
  return ($proc ??= GL::getProcAddress('binormal3fvEXT'))($v);
}

function glBinormal3iEXT(int $bx, int $by, int $bz) {
  static $proc;
  return ($proc ??= GL::getProcAddress('binormal3iEXT'))($bx, $by, $bz);
}

function glBinormal3ivEXT($v) {
  static $proc;
  return ($proc ??= GL::getProcAddress('binormal3ivEXT'))($v);
}

function glBinormal3sEXT(int $bx, int $by, int $bz) {
  static $proc;
  return ($proc ??= GL::getProcAddress('binormal3sEXT'))($bx, $by, $bz);
}

function glBinormal3svEXT($v) {
  static $proc;
  return ($proc ??= GL::getProcAddress('binormal3svEXT'))($v);
}

function glBinormalPointerEXT(int $type, int $stride, $pointer) {
  static $proc;
  return ($proc ??= GL::getProcAddress('binormalPointerEXT'))($type, $stride, $pointer);
}

function glBitmap(int $width, int $height, float $xorig, float $yorig, float $xmove, float $ymove, $bitmap) {
  static $proc;
  return ($proc ??= GL::getProcAddress('bitmap'))($width, $height, $xorig, $yorig, $xmove, $ymove, $bitmap);
}

function glBitmapxOES(int $width, int $height, int $xorig, int $yorig, int $xmove, int $ymove, $bitmap) {
  static $proc;
  return ($proc ??= GL::getProcAddress('bitmapxOES'))($width, $height, $xorig, $yorig, $xmove, $ymove, $bitmap);
}

function glBlendBarrier() {
  static $proc;
  return ($proc ??= GL::getProcAddress('blendBarrier'))();
}

function glBlendBarrierKHR() {
  static $proc;
  return ($proc ??= GL::getProcAddress('blendBarrierKHR'))();
}

function glBlendBarrierNV() {
  static $proc;
  return ($proc ??= GL::getProcAddress('blendBarrierNV'))();
}

function glBlendColor(float $red, float $green, float $blue, float $alpha) {
  static $proc;
  return ($proc ??= GL::getProcAddress('blendColor'))($red, $green, $blue, $alpha);
}

function glBlendColorEXT(float $red, float $green, float $blue, float $alpha) {
  static $proc;
  return ($proc ??= GL::getProcAddress('blendColorEXT'))($red, $green, $blue, $alpha);
}

function glBlendColorxOES(int $red, int $green, int $blue, int $alpha) {
  static $proc;
  return ($proc ??= GL::getProcAddress('blendColorxOES'))($red, $green, $blue, $alpha);
}

function glBlendEquation(int $mode) {
  static $proc;
  return ($proc ??= GL::getProcAddress('blendEquation'))($mode);
}

function glBlendEquationEXT(int $mode) {
  static $proc;
  return ($proc ??= GL::getProcAddress('blendEquationEXT'))($mode);
}

function glBlendEquationIndexedAMD(int $buf, int $mode) {
  static $proc;
  return ($proc ??= GL::getProcAddress('blendEquationIndexedAMD'))($buf, $mode);
}

function glBlendEquationOES(int $mode) {
  static $proc;
  return ($proc ??= GL::getProcAddress('blendEquationOES'))($mode);
}

function glBlendEquationSeparate(int $modeRGB, int $modeAlpha) {
  static $proc;
  return ($proc ??= GL::getProcAddress('blendEquationSeparate'))($modeRGB, $modeAlpha);
}

function glBlendEquationSeparateEXT(int $modeRGB, int $modeAlpha) {
  static $proc;
  return ($proc ??= GL::getProcAddress('blendEquationSeparateEXT'))($modeRGB, $modeAlpha);
}

function glBlendEquationSeparateIndexedAMD(int $buf, int $modeRGB, int $modeAlpha) {
  static $proc;
  return ($proc ??= GL::getProcAddress('blendEquationSeparateIndexedAMD'))($buf, $modeRGB, $modeAlpha);
}

function glBlendEquationSeparateOES(int $modeRGB, int $modeAlpha) {
  static $proc;
  return ($proc ??= GL::getProcAddress('blendEquationSeparateOES'))($modeRGB, $modeAlpha);
}

function glBlendEquationSeparatei(int $buf, int $modeRGB, int $modeAlpha) {
  static $proc;
  return ($proc ??= GL::getProcAddress('blendEquationSeparatei'))($buf, $modeRGB, $modeAlpha);
}

function glBlendEquationSeparateiARB(int $buf, int $modeRGB, int $modeAlpha) {
  static $proc;
  return ($proc ??= GL::getProcAddress('blendEquationSeparateiARB'))($buf, $modeRGB, $modeAlpha);
}

function glBlendEquationSeparateiEXT(int $buf, int $modeRGB, int $modeAlpha) {
  static $proc;
  return ($proc ??= GL::getProcAddress('blendEquationSeparateiEXT'))($buf, $modeRGB, $modeAlpha);
}

function glBlendEquationSeparateiOES(int $buf, int $modeRGB, int $modeAlpha) {
  static $proc;
  return ($proc ??= GL::getProcAddress('blendEquationSeparateiOES'))($buf, $modeRGB, $modeAlpha);
}

function glBlendEquationi(int $buf, int $mode) {
  static $proc;
  return ($proc ??= GL::getProcAddress('blendEquationi'))($buf, $mode);
}

function glBlendEquationiARB(int $buf, int $mode) {
  static $proc;
  return ($proc ??= GL::getProcAddress('blendEquationiARB'))($buf, $mode);
}

function glBlendEquationiEXT(int $buf, int $mode) {
  static $proc;
  return ($proc ??= GL::getProcAddress('blendEquationiEXT'))($buf, $mode);
}

function glBlendEquationiOES(int $buf, int $mode) {
  static $proc;
  return ($proc ??= GL::getProcAddress('blendEquationiOES'))($buf, $mode);
}

function glBlendFunc(int $sfactor, int $dfactor) {
  static $proc;
  return ($proc ??= GL::getProcAddress('blendFunc'))($sfactor, $dfactor);
}

function glBlendFuncIndexedAMD(int $buf, int $src, int $dst) {
  static $proc;
  return ($proc ??= GL::getProcAddress('blendFuncIndexedAMD'))($buf, $src, $dst);
}

function glBlendFuncSeparate(int $sfactorRGB, int $dfactorRGB, int $sfactorAlpha, int $dfactorAlpha) {
  static $proc;
  return ($proc ??= GL::getProcAddress('blendFuncSeparate'))($sfactorRGB, $dfactorRGB, $sfactorAlpha, $dfactorAlpha);
}

function glBlendFuncSeparateEXT(int $sfactorRGB, int $dfactorRGB, int $sfactorAlpha, int $dfactorAlpha) {
  static $proc;
  return ($proc ??= GL::getProcAddress('blendFuncSeparateEXT'))($sfactorRGB, $dfactorRGB, $sfactorAlpha, $dfactorAlpha);
}

function glBlendFuncSeparateINGR(int $sfactorRGB, int $dfactorRGB, int $sfactorAlpha, int $dfactorAlpha) {
  static $proc;
  return ($proc ??= GL::getProcAddress('blendFuncSeparateINGR'))($sfactorRGB, $dfactorRGB, $sfactorAlpha, $dfactorAlpha);
}

function glBlendFuncSeparateIndexedAMD(int $buf, int $srcRGB, int $dstRGB, int $srcAlpha, int $dstAlpha) {
  static $proc;
  return ($proc ??= GL::getProcAddress('blendFuncSeparateIndexedAMD'))($buf, $srcRGB, $dstRGB, $srcAlpha, $dstAlpha);
}

function glBlendFuncSeparateOES(int $srcRGB, int $dstRGB, int $srcAlpha, int $dstAlpha) {
  static $proc;
  return ($proc ??= GL::getProcAddress('blendFuncSeparateOES'))($srcRGB, $dstRGB, $srcAlpha, $dstAlpha);
}

function glBlendFuncSeparatei(int $buf, int $srcRGB, int $dstRGB, int $srcAlpha, int $dstAlpha) {
  static $proc;
  return ($proc ??= GL::getProcAddress('blendFuncSeparatei'))($buf, $srcRGB, $dstRGB, $srcAlpha, $dstAlpha);
}

function glBlendFuncSeparateiARB(int $buf, int $srcRGB, int $dstRGB, int $srcAlpha, int $dstAlpha) {
  static $proc;
  return ($proc ??= GL::getProcAddress('blendFuncSeparateiARB'))($buf, $srcRGB, $dstRGB, $srcAlpha, $dstAlpha);
}

function glBlendFuncSeparateiEXT(int $buf, int $srcRGB, int $dstRGB, int $srcAlpha, int $dstAlpha) {
  static $proc;
  return ($proc ??= GL::getProcAddress('blendFuncSeparateiEXT'))($buf, $srcRGB, $dstRGB, $srcAlpha, $dstAlpha);
}

function glBlendFuncSeparateiOES(int $buf, int $srcRGB, int $dstRGB, int $srcAlpha, int $dstAlpha) {
  static $proc;
  return ($proc ??= GL::getProcAddress('blendFuncSeparateiOES'))($buf, $srcRGB, $dstRGB, $srcAlpha, $dstAlpha);
}

function glBlendFunci(int $buf, int $src, int $dst) {
  static $proc;
  return ($proc ??= GL::getProcAddress('blendFunci'))($buf, $src, $dst);
}

function glBlendFunciARB(int $buf, int $src, int $dst) {
  static $proc;
  return ($proc ??= GL::getProcAddress('blendFunciARB'))($buf, $src, $dst);
}

function glBlendFunciEXT(int $buf, int $src, int $dst) {
  static $proc;
  return ($proc ??= GL::getProcAddress('blendFunciEXT'))($buf, $src, $dst);
}

function glBlendFunciOES(int $buf, int $src, int $dst) {
  static $proc;
  return ($proc ??= GL::getProcAddress('blendFunciOES'))($buf, $src, $dst);
}

function glBlendParameteriNV(int $pname, int $value) {
  static $proc;
  return ($proc ??= GL::getProcAddress('blendParameteriNV'))($pname, $value);
}

function glBlitFramebuffer(int $srcX0, int $srcY0, int $srcX1, int $srcY1, int $dstX0, int $dstY0, int $dstX1, int $dstY1, int $mask, int $filter) {
  static $proc;
  return ($proc ??= GL::getProcAddress('blitFramebuffer'))($srcX0, $srcY0, $srcX1, $srcY1, $dstX0, $dstY0, $dstX1, $dstY1, $mask, $filter);
}

function glBlitFramebufferANGLE(int $srcX0, int $srcY0, int $srcX1, int $srcY1, int $dstX0, int $dstY0, int $dstX1, int $dstY1, int $mask, int $filter) {
  static $proc;
  return ($proc ??= GL::getProcAddress('blitFramebufferANGLE'))($srcX0, $srcY0, $srcX1, $srcY1, $dstX0, $dstY0, $dstX1, $dstY1, $mask, $filter);
}

function glBlitFramebufferEXT(int $srcX0, int $srcY0, int $srcX1, int $srcY1, int $dstX0, int $dstY0, int $dstX1, int $dstY1, int $mask, int $filter) {
  static $proc;
  return ($proc ??= GL::getProcAddress('blitFramebufferEXT'))($srcX0, $srcY0, $srcX1, $srcY1, $dstX0, $dstY0, $dstX1, $dstY1, $mask, $filter);
}

function glBlitFramebufferNV(int $srcX0, int $srcY0, int $srcX1, int $srcY1, int $dstX0, int $dstY0, int $dstX1, int $dstY1, int $mask, int $filter) {
  static $proc;
  return ($proc ??= GL::getProcAddress('blitFramebufferNV'))($srcX0, $srcY0, $srcX1, $srcY1, $dstX0, $dstY0, $dstX1, $dstY1, $mask, $filter);
}

function glBlitNamedFramebuffer(int $readFramebuffer, int $drawFramebuffer, int $srcX0, int $srcY0, int $srcX1, int $srcY1, int $dstX0, int $dstY0, int $dstX1, int $dstY1, int $mask, int $filter) {
  static $proc;
  return ($proc ??= GL::getProcAddress('blitNamedFramebuffer'))($readFramebuffer, $drawFramebuffer, $srcX0, $srcY0, $srcX1, $srcY1, $dstX0, $dstY0, $dstX1, $dstY1, $mask, $filter);
}

function glBufferAddressRangeNV(int $pname, int $index, int $address, int $length) {
  static $proc;
  return ($proc ??= GL::getProcAddress('bufferAddressRangeNV'))($pname, $index, $address, $length);
}

function glBufferData(int $target, int $size, $data, int $usage) {
  static $proc;
  return ($proc ??= GL::getProcAddress('bufferData'))($target, $size, $data, $usage);
}

function glBufferDataARB(int $target, int $size, $data, int $usage) {
  static $proc;
  return ($proc ??= GL::getProcAddress('bufferDataARB'))($target, $size, $data, $usage);
}

function glBufferPageCommitmentARB(int $target, int $offset, int $size, int $commit) {
  static $proc;
  return ($proc ??= GL::getProcAddress('bufferPageCommitmentARB'))($target, $offset, $size, $commit);
}

function glBufferParameteriAPPLE(int $target, int $pname, int $param) {
  static $proc;
  return ($proc ??= GL::getProcAddress('bufferParameteriAPPLE'))($target, $pname, $param);
}

function glBufferStorage(int $target, int $size, $data, int $flags) {
  static $proc;
  return ($proc ??= GL::getProcAddress('bufferStorage'))($target, $size, $data, $flags);
}

function glBufferStorageEXT(int $target, int $size, $data, int $flags) {
  static $proc;
  return ($proc ??= GL::getProcAddress('bufferStorageEXT'))($target, $size, $data, $flags);
}

function glBufferSubData(int $target, int $offset, int $size, $data) {
  static $proc;
  return ($proc ??= GL::getProcAddress('bufferSubData'))($target, $offset, $size, $data);
}

function glBufferSubDataARB(int $target, int $offset, int $size, $data) {
  static $proc;
  return ($proc ??= GL::getProcAddress('bufferSubDataARB'))($target, $offset, $size, $data);
}

function glCallCommandListNV(int $list) {
  static $proc;
  return ($proc ??= GL::getProcAddress('callCommandListNV'))($list);
}

function glCallList(int $list) {
  static $proc;
  return ($proc ??= GL::getProcAddress('callList'))($list);
}

function glCallLists(int $n, int $type, $lists) {
  static $proc;
  return ($proc ??= GL::getProcAddress('callLists'))($n, $type, $lists);
}

function glCheckFramebufferStatus(int $target) {
  static $proc;
  return ($proc ??= GL::getProcAddress('checkFramebufferStatus'))($target);
}

function glCheckFramebufferStatusEXT(int $target) {
  static $proc;
  return ($proc ??= GL::getProcAddress('checkFramebufferStatusEXT'))($target);
}

function glCheckFramebufferStatusOES(int $target) {
  static $proc;
  return ($proc ??= GL::getProcAddress('checkFramebufferStatusOES'))($target);
}

function glCheckNamedFramebufferStatus(int $framebuffer, int $target) {
  static $proc;
  return ($proc ??= GL::getProcAddress('checkNamedFramebufferStatus'))($framebuffer, $target);
}

function glCheckNamedFramebufferStatusEXT(int $framebuffer, int $target) {
  static $proc;
  return ($proc ??= GL::getProcAddress('checkNamedFramebufferStatusEXT'))($framebuffer, $target);
}

function glClampColor(int $target, int $clamp) {
  static $proc;
  return ($proc ??= GL::getProcAddress('clampColor'))($target, $clamp);
}

function glClampColorARB(int $target, int $clamp) {
  static $proc;
  return ($proc ??= GL::getProcAddress('clampColorARB'))($target, $clamp);
}

function glClear(int $mask) {
  static $proc;
  return ($proc ??= GL::getProcAddress('clear'))($mask);
}

function glClearAccum(float $red, float $green, float $blue, float $alpha) {
  static $proc;
  return ($proc ??= GL::getProcAddress('clearAccum'))($red, $green, $blue, $alpha);
}

function glClearAccumxOES(int $red, int $green, int $blue, int $alpha) {
  static $proc;
  return ($proc ??= GL::getProcAddress('clearAccumxOES'))($red, $green, $blue, $alpha);
}

function glClearBufferData(int $target, int $internalformat, int $format, int $type, $data) {
  static $proc;
  return ($proc ??= GL::getProcAddress('clearBufferData'))($target, $internalformat, $format, $type, $data);
}

function glClearBufferSubData(int $target, int $internalformat, int $offset, int $size, int $format, int $type, $data) {
  static $proc;
  return ($proc ??= GL::getProcAddress('clearBufferSubData'))($target, $internalformat, $offset, $size, $format, $type, $data);
}

function glClearBufferfi(int $buffer, int $drawbuffer, float $depth, int $stencil) {
  static $proc;
  return ($proc ??= GL::getProcAddress('clearBufferfi'))($buffer, $drawbuffer, $depth, $stencil);
}

function glClearBufferfv(int $buffer, int $drawbuffer, $value) {
  static $proc;
  return ($proc ??= GL::getProcAddress('clearBufferfv'))($buffer, $drawbuffer, $value);
}

function glClearBufferiv(int $buffer, int $drawbuffer, $value) {
  static $proc;
  return ($proc ??= GL::getProcAddress('clearBufferiv'))($buffer, $drawbuffer, $value);
}

function glClearBufferuiv(int $buffer, int $drawbuffer, $value) {
  static $proc;
  return ($proc ??= GL::getProcAddress('clearBufferuiv'))($buffer, $drawbuffer, $value);
}

function glClearColor(float $red, float $green, float $blue, float $alpha) {
  static $proc;
  return ($proc ??= GL::getProcAddress('clearColor'))($red, $green, $blue, $alpha);
}

function glClearColorIiEXT(int $red, int $green, int $blue, int $alpha) {
  static $proc;
  return ($proc ??= GL::getProcAddress('clearColorIiEXT'))($red, $green, $blue, $alpha);
}

function glClearColorIuiEXT(int $red, int $green, int $blue, int $alpha) {
  static $proc;
  return ($proc ??= GL::getProcAddress('clearColorIuiEXT'))($red, $green, $blue, $alpha);
}

function glClearColorx(int $red, int $green, int $blue, int $alpha) {
  static $proc;
  return ($proc ??= GL::getProcAddress('clearColorx'))($red, $green, $blue, $alpha);
}

function glClearColorxOES(int $red, int $green, int $blue, int $alpha) {
  static $proc;
  return ($proc ??= GL::getProcAddress('clearColorxOES'))($red, $green, $blue, $alpha);
}

function glClearDepth(float $depth) {
  static $proc;
  return ($proc ??= GL::getProcAddress('clearDepth'))($depth);
}

function glClearDepthdNV(float $depth) {
  static $proc;
  return ($proc ??= GL::getProcAddress('clearDepthdNV'))($depth);
}

function glClearDepthf(float $d) {
  static $proc;
  return ($proc ??= GL::getProcAddress('clearDepthf'))($d);
}

function glClearDepthfOES($depth) {
  static $proc;
  return ($proc ??= GL::getProcAddress('clearDepthfOES'))($depth);
}

function glClearDepthx(int $depth) {
  static $proc;
  return ($proc ??= GL::getProcAddress('clearDepthx'))($depth);
}

function glClearDepthxOES(int $depth) {
  static $proc;
  return ($proc ??= GL::getProcAddress('clearDepthxOES'))($depth);
}

function glClearIndex(float $c) {
  static $proc;
  return ($proc ??= GL::getProcAddress('clearIndex'))($c);
}

function glClearNamedBufferData(int $buffer, int $internalformat, int $format, int $type, $data) {
  static $proc;
  return ($proc ??= GL::getProcAddress('clearNamedBufferData'))($buffer, $internalformat, $format, $type, $data);
}

function glClearNamedBufferDataEXT(int $buffer, int $internalformat, int $format, int $type, $data) {
  static $proc;
  return ($proc ??= GL::getProcAddress('clearNamedBufferDataEXT'))($buffer, $internalformat, $format, $type, $data);
}

function glClearNamedBufferSubData(int $buffer, int $internalformat, int $offset, int $size, int $format, int $type, $data) {
  static $proc;
  return ($proc ??= GL::getProcAddress('clearNamedBufferSubData'))($buffer, $internalformat, $offset, $size, $format, $type, $data);
}

function glClearNamedBufferSubDataEXT(int $buffer, int $internalformat, int $offset, int $size, int $format, int $type, $data) {
  static $proc;
  return ($proc ??= GL::getProcAddress('clearNamedBufferSubDataEXT'))($buffer, $internalformat, $offset, $size, $format, $type, $data);
}

function glClearNamedFramebufferfi(int $framebuffer, int $buffer, int $drawbuffer, float $depth, int $stencil) {
  static $proc;
  return ($proc ??= GL::getProcAddress('clearNamedFramebufferfi'))($framebuffer, $buffer, $drawbuffer, $depth, $stencil);
}

function glClearNamedFramebufferfv(int $framebuffer, int $buffer, int $drawbuffer, $value) {
  static $proc;
  return ($proc ??= GL::getProcAddress('clearNamedFramebufferfv'))($framebuffer, $buffer, $drawbuffer, $value);
}

function glClearNamedFramebufferiv(int $framebuffer, int $buffer, int $drawbuffer, $value) {
  static $proc;
  return ($proc ??= GL::getProcAddress('clearNamedFramebufferiv'))($framebuffer, $buffer, $drawbuffer, $value);
}

function glClearNamedFramebufferuiv(int $framebuffer, int $buffer, int $drawbuffer, $value) {
  static $proc;
  return ($proc ??= GL::getProcAddress('clearNamedFramebufferuiv'))($framebuffer, $buffer, $drawbuffer, $value);
}

function glClearPixelLocalStorageuiEXT(int $offset, int $n, $values) {
  static $proc;
  return ($proc ??= GL::getProcAddress('clearPixelLocalStorageuiEXT'))($offset, $n, $values);
}

function glClearStencil(int $s) {
  static $proc;
  return ($proc ??= GL::getProcAddress('clearStencil'))($s);
}

function glClearTexImage(int $texture, int $level, int $format, int $type, $data) {
  static $proc;
  return ($proc ??= GL::getProcAddress('clearTexImage'))($texture, $level, $format, $type, $data);
}

function glClearTexImageEXT(int $texture, int $level, int $format, int $type, $data) {
  static $proc;
  return ($proc ??= GL::getProcAddress('clearTexImageEXT'))($texture, $level, $format, $type, $data);
}

function glClearTexSubImage(int $texture, int $level, int $xoffset, int $yoffset, int $zoffset, int $width, int $height, int $depth, int $format, int $type, $data) {
  static $proc;
  return ($proc ??= GL::getProcAddress('clearTexSubImage'))($texture, $level, $xoffset, $yoffset, $zoffset, $width, $height, $depth, $format, $type, $data);
}

function glClearTexSubImageEXT(int $texture, int $level, int $xoffset, int $yoffset, int $zoffset, int $width, int $height, int $depth, int $format, int $type, $data) {
  static $proc;
  return ($proc ??= GL::getProcAddress('clearTexSubImageEXT'))($texture, $level, $xoffset, $yoffset, $zoffset, $width, $height, $depth, $format, $type, $data);
}

function glClientActiveTexture(int $texture) {
  static $proc;
  return ($proc ??= GL::getProcAddress('clientActiveTexture'))($texture);
}

function glClientActiveTextureARB(int $texture) {
  static $proc;
  return ($proc ??= GL::getProcAddress('clientActiveTextureARB'))($texture);
}

function glClientActiveVertexStreamATI(int $stream) {
  static $proc;
  return ($proc ??= GL::getProcAddress('clientActiveVertexStreamATI'))($stream);
}

function glClientAttribDefaultEXT(int $mask) {
  static $proc;
  return ($proc ??= GL::getProcAddress('clientAttribDefaultEXT'))($mask);
}

function glClientWaitSync(int $sync, int $flags, int $timeout) {
  static $proc;
  return ($proc ??= GL::getProcAddress('clientWaitSync'))($sync, $flags, $timeout);
}

function glClientWaitSyncAPPLE(int $sync, int $flags, int $timeout) {
  static $proc;
  return ($proc ??= GL::getProcAddress('clientWaitSyncAPPLE'))($sync, $flags, $timeout);
}

function glClipControl(int $origin, int $depth) {
  static $proc;
  return ($proc ??= GL::getProcAddress('clipControl'))($origin, $depth);
}

function glClipPlane(int $plane, $equation) {
  static $proc;
  return ($proc ??= GL::getProcAddress('clipPlane'))($plane, $equation);
}

function glClipPlanef(int $p, $eqn) {
  static $proc;
  return ($proc ??= GL::getProcAddress('clipPlanef'))($p, $eqn);
}

function glClipPlanefIMG(int $p, $eqn) {
  static $proc;
  return ($proc ??= GL::getProcAddress('clipPlanefIMG'))($p, $eqn);
}

function glClipPlanefOES(int $plane, $equation) {
  static $proc;
  return ($proc ??= GL::getProcAddress('clipPlanefOES'))($plane, $equation);
}

function glClipPlanex(int $plane, $equation) {
  static $proc;
  return ($proc ??= GL::getProcAddress('clipPlanex'))($plane, $equation);
}

function glClipPlanexIMG(int $p, $eqn) {
  static $proc;
  return ($proc ??= GL::getProcAddress('clipPlanexIMG'))($p, $eqn);
}

function glClipPlanexOES(int $plane, $equation) {
  static $proc;
  return ($proc ??= GL::getProcAddress('clipPlanexOES'))($plane, $equation);
}

function glColor3b(int $red, int $green, int $blue) {
  static $proc;
  return ($proc ??= GL::getProcAddress('color3b'))($red, $green, $blue);
}

function glColor3bv($v) {
  static $proc;
  return ($proc ??= GL::getProcAddress('color3bv'))($v);
}

function glColor3d(float $red, float $green, float $blue) {
  static $proc;
  return ($proc ??= GL::getProcAddress('color3d'))($red, $green, $blue);
}

function glColor3dv($v) {
  static $proc;
  return ($proc ??= GL::getProcAddress('color3dv'))($v);
}

function glColor3f(float $red, float $green, float $blue) {
  static $proc;
  return ($proc ??= GL::getProcAddress('color3f'))($red, $green, $blue);
}

function glColor3fVertex3fSUN(float $r, float $g, float $b, float $x, float $y, float $z) {
  static $proc;
  return ($proc ??= GL::getProcAddress('color3fVertex3fSUN'))($r, $g, $b, $x, $y, $z);
}

function glColor3fVertex3fvSUN($c, $v) {
  static $proc;
  return ($proc ??= GL::getProcAddress('color3fVertex3fvSUN'))($c, $v);
}

function glColor3fv($v) {
  static $proc;
  return ($proc ??= GL::getProcAddress('color3fv'))($v);
}

function glColor3hNV(int $red, int $green, int $blue) {
  static $proc;
  return ($proc ??= GL::getProcAddress('color3hNV'))($red, $green, $blue);
}

function glColor3hvNV($v) {
  static $proc;
  return ($proc ??= GL::getProcAddress('color3hvNV'))($v);
}

function glColor3i(int $red, int $green, int $blue) {
  static $proc;
  return ($proc ??= GL::getProcAddress('color3i'))($red, $green, $blue);
}

function glColor3iv($v) {
  static $proc;
  return ($proc ??= GL::getProcAddress('color3iv'))($v);
}

function glColor3s(int $red, int $green, int $blue) {
  static $proc;
  return ($proc ??= GL::getProcAddress('color3s'))($red, $green, $blue);
}

function glColor3sv($v) {
  static $proc;
  return ($proc ??= GL::getProcAddress('color3sv'))($v);
}

function glColor3ub(int $red, int $green, int $blue) {
  static $proc;
  return ($proc ??= GL::getProcAddress('color3ub'))($red, $green, $blue);
}

function glColor3ubv($v) {
  static $proc;
  return ($proc ??= GL::getProcAddress('color3ubv'))($v);
}

function glColor3ui(int $red, int $green, int $blue) {
  static $proc;
  return ($proc ??= GL::getProcAddress('color3ui'))($red, $green, $blue);
}

function glColor3uiv($v) {
  static $proc;
  return ($proc ??= GL::getProcAddress('color3uiv'))($v);
}

function glColor3us(int $red, int $green, int $blue) {
  static $proc;
  return ($proc ??= GL::getProcAddress('color3us'))($red, $green, $blue);
}

function glColor3usv($v) {
  static $proc;
  return ($proc ??= GL::getProcAddress('color3usv'))($v);
}

function glColor3xOES(int $red, int $green, int $blue) {
  static $proc;
  return ($proc ??= GL::getProcAddress('color3xOES'))($red, $green, $blue);
}

function glColor3xvOES($components) {
  static $proc;
  return ($proc ??= GL::getProcAddress('color3xvOES'))($components);
}

function glColor4b(int $red, int $green, int $blue, int $alpha) {
  static $proc;
  return ($proc ??= GL::getProcAddress('color4b'))($red, $green, $blue, $alpha);
}

function glColor4bv($v) {
  static $proc;
  return ($proc ??= GL::getProcAddress('color4bv'))($v);
}

function glColor4d(float $red, float $green, float $blue, float $alpha) {
  static $proc;
  return ($proc ??= GL::getProcAddress('color4d'))($red, $green, $blue, $alpha);
}

function glColor4dv($v) {
  static $proc;
  return ($proc ??= GL::getProcAddress('color4dv'))($v);
}

function glColor4f(float $red, float $green, float $blue, float $alpha) {
  static $proc;
  return ($proc ??= GL::getProcAddress('color4f'))($red, $green, $blue, $alpha);
}

function glColor4fNormal3fVertex3fSUN(float $r, float $g, float $b, float $a, float $nx, float $ny, float $nz, float $x, float $y, float $z) {
  static $proc;
  return ($proc ??= GL::getProcAddress('color4fNormal3fVertex3fSUN'))($r, $g, $b, $a, $nx, $ny, $nz, $x, $y, $z);
}

function glColor4fNormal3fVertex3fvSUN($c, $n, $v) {
  static $proc;
  return ($proc ??= GL::getProcAddress('color4fNormal3fVertex3fvSUN'))($c, $n, $v);
}

function glColor4fv($v) {
  static $proc;
  return ($proc ??= GL::getProcAddress('color4fv'))($v);
}

function glColor4hNV(int $red, int $green, int $blue, int $alpha) {
  static $proc;
  return ($proc ??= GL::getProcAddress('color4hNV'))($red, $green, $blue, $alpha);
}

function glColor4hvNV($v) {
  static $proc;
  return ($proc ??= GL::getProcAddress('color4hvNV'))($v);
}

function glColor4i(int $red, int $green, int $blue, int $alpha) {
  static $proc;
  return ($proc ??= GL::getProcAddress('color4i'))($red, $green, $blue, $alpha);
}

function glColor4iv($v) {
  static $proc;
  return ($proc ??= GL::getProcAddress('color4iv'))($v);
}

function glColor4s(int $red, int $green, int $blue, int $alpha) {
  static $proc;
  return ($proc ??= GL::getProcAddress('color4s'))($red, $green, $blue, $alpha);
}

function glColor4sv($v) {
  static $proc;
  return ($proc ??= GL::getProcAddress('color4sv'))($v);
}

function glColor4ub(int $red, int $green, int $blue, int $alpha) {
  static $proc;
  return ($proc ??= GL::getProcAddress('color4ub'))($red, $green, $blue, $alpha);
}

function glColor4ubVertex2fSUN(int $r, int $g, int $b, int $a, float $x, float $y) {
  static $proc;
  return ($proc ??= GL::getProcAddress('color4ubVertex2fSUN'))($r, $g, $b, $a, $x, $y);
}

function glColor4ubVertex2fvSUN($c, $v) {
  static $proc;
  return ($proc ??= GL::getProcAddress('color4ubVertex2fvSUN'))($c, $v);
}

function glColor4ubVertex3fSUN(int $r, int $g, int $b, int $a, float $x, float $y, float $z) {
  static $proc;
  return ($proc ??= GL::getProcAddress('color4ubVertex3fSUN'))($r, $g, $b, $a, $x, $y, $z);
}

function glColor4ubVertex3fvSUN($c, $v) {
  static $proc;
  return ($proc ??= GL::getProcAddress('color4ubVertex3fvSUN'))($c, $v);
}

function glColor4ubv($v) {
  static $proc;
  return ($proc ??= GL::getProcAddress('color4ubv'))($v);
}

function glColor4ui(int $red, int $green, int $blue, int $alpha) {
  static $proc;
  return ($proc ??= GL::getProcAddress('color4ui'))($red, $green, $blue, $alpha);
}

function glColor4uiv($v) {
  static $proc;
  return ($proc ??= GL::getProcAddress('color4uiv'))($v);
}

function glColor4us(int $red, int $green, int $blue, int $alpha) {
  static $proc;
  return ($proc ??= GL::getProcAddress('color4us'))($red, $green, $blue, $alpha);
}

function glColor4usv($v) {
  static $proc;
  return ($proc ??= GL::getProcAddress('color4usv'))($v);
}

function glColor4x(int $red, int $green, int $blue, int $alpha) {
  static $proc;
  return ($proc ??= GL::getProcAddress('color4x'))($red, $green, $blue, $alpha);
}

function glColor4xOES(int $red, int $green, int $blue, int $alpha) {
  static $proc;
  return ($proc ??= GL::getProcAddress('color4xOES'))($red, $green, $blue, $alpha);
}

function glColor4xvOES($components) {
  static $proc;
  return ($proc ??= GL::getProcAddress('color4xvOES'))($components);
}

function glColorFormatNV(int $size, int $type, int $stride) {
  static $proc;
  return ($proc ??= GL::getProcAddress('colorFormatNV'))($size, $type, $stride);
}

function glColorFragmentOp1ATI(int $op, int $dst, int $dstMask, int $dstMod, int $arg1, int $arg1Rep, int $arg1Mod) {
  static $proc;
  return ($proc ??= GL::getProcAddress('colorFragmentOp1ATI'))($op, $dst, $dstMask, $dstMod, $arg1, $arg1Rep, $arg1Mod);
}

function glColorFragmentOp2ATI(int $op, int $dst, int $dstMask, int $dstMod, int $arg1, int $arg1Rep, int $arg1Mod, int $arg2, int $arg2Rep, int $arg2Mod) {
  static $proc;
  return ($proc ??= GL::getProcAddress('colorFragmentOp2ATI'))($op, $dst, $dstMask, $dstMod, $arg1, $arg1Rep, $arg1Mod, $arg2, $arg2Rep, $arg2Mod);
}

function glColorFragmentOp3ATI(int $op, int $dst, int $dstMask, int $dstMod, int $arg1, int $arg1Rep, int $arg1Mod, int $arg2, int $arg2Rep, int $arg2Mod, int $arg3, int $arg3Rep, int $arg3Mod) {
  static $proc;
  return ($proc ??= GL::getProcAddress('colorFragmentOp3ATI'))($op, $dst, $dstMask, $dstMod, $arg1, $arg1Rep, $arg1Mod, $arg2, $arg2Rep, $arg2Mod, $arg3, $arg3Rep, $arg3Mod);
}

function glColorMask(int $red, int $green, int $blue, int $alpha) {
  static $proc;
  return ($proc ??= GL::getProcAddress('colorMask'))($red, $green, $blue, $alpha);
}

function glColorMaskIndexedEXT(int $index, int $r, int $g, int $b, int $a) {
  static $proc;
  return ($proc ??= GL::getProcAddress('colorMaskIndexedEXT'))($index, $r, $g, $b, $a);
}

function glColorMaski(int $index, int $r, int $g, int $b, int $a) {
  static $proc;
  return ($proc ??= GL::getProcAddress('colorMaski'))($index, $r, $g, $b, $a);
}

function glColorMaskiEXT(int $index, int $r, int $g, int $b, int $a) {
  static $proc;
  return ($proc ??= GL::getProcAddress('colorMaskiEXT'))($index, $r, $g, $b, $a);
}

function glColorMaskiOES(int $index, int $r, int $g, int $b, int $a) {
  static $proc;
  return ($proc ??= GL::getProcAddress('colorMaskiOES'))($index, $r, $g, $b, $a);
}

function glColorMaterial(int $face, int $mode) {
  static $proc;
  return ($proc ??= GL::getProcAddress('colorMaterial'))($face, $mode);
}

function glColorP3ui(int $type, int $color) {
  static $proc;
  return ($proc ??= GL::getProcAddress('colorP3ui'))($type, $color);
}

function glColorP3uiv(int $type, $color) {
  static $proc;
  return ($proc ??= GL::getProcAddress('colorP3uiv'))($type, $color);
}

function glColorP4ui(int $type, int $color) {
  static $proc;
  return ($proc ??= GL::getProcAddress('colorP4ui'))($type, $color);
}

function glColorP4uiv(int $type, $color) {
  static $proc;
  return ($proc ??= GL::getProcAddress('colorP4uiv'))($type, $color);
}

function glColorPointer(int $size, int $type, int $stride, $pointer) {
  static $proc;
  return ($proc ??= GL::getProcAddress('colorPointer'))($size, $type, $stride, $pointer);
}

function glColorPointerEXT(int $size, int $type, int $stride, int $count, $pointer) {
  static $proc;
  return ($proc ??= GL::getProcAddress('colorPointerEXT'))($size, $type, $stride, $count, $pointer);
}

function glColorPointerListIBM(int $size, int $type, int $stride, $pointer, int $ptrstride) {
  static $proc;
  return ($proc ??= GL::getProcAddress('colorPointerListIBM'))($size, $type, $stride, $pointer, $ptrstride);
}

function glColorPointervINTEL(int $size, int $type, $pointer) {
  static $proc;
  return ($proc ??= GL::getProcAddress('colorPointervINTEL'))($size, $type, $pointer);
}

function glColorSubTable(int $target, int $start, int $count, int $format, int $type, $data) {
  static $proc;
  return ($proc ??= GL::getProcAddress('colorSubTable'))($target, $start, $count, $format, $type, $data);
}

function glColorSubTableEXT(int $target, int $start, int $count, int $format, int $type, $data) {
  static $proc;
  return ($proc ??= GL::getProcAddress('colorSubTableEXT'))($target, $start, $count, $format, $type, $data);
}

function glColorTable(int $target, int $internalformat, int $width, int $format, int $type, $table) {
  static $proc;
  return ($proc ??= GL::getProcAddress('colorTable'))($target, $internalformat, $width, $format, $type, $table);
}

function glColorTableEXT(int $target, int $internalFormat, int $width, int $format, int $type, $table) {
  static $proc;
  return ($proc ??= GL::getProcAddress('colorTableEXT'))($target, $internalFormat, $width, $format, $type, $table);
}

function glColorTableParameterfv(int $target, int $pname, $params) {
  static $proc;
  return ($proc ??= GL::getProcAddress('colorTableParameterfv'))($target, $pname, $params);
}

function glColorTableParameterfvSGI(int $target, int $pname, $params) {
  static $proc;
  return ($proc ??= GL::getProcAddress('colorTableParameterfvSGI'))($target, $pname, $params);
}

function glColorTableParameteriv(int $target, int $pname, $params) {
  static $proc;
  return ($proc ??= GL::getProcAddress('colorTableParameteriv'))($target, $pname, $params);
}

function glColorTableParameterivSGI(int $target, int $pname, $params) {
  static $proc;
  return ($proc ??= GL::getProcAddress('colorTableParameterivSGI'))($target, $pname, $params);
}

function glColorTableSGI(int $target, int $internalformat, int $width, int $format, int $type, $table) {
  static $proc;
  return ($proc ??= GL::getProcAddress('colorTableSGI'))($target, $internalformat, $width, $format, $type, $table);
}

function glCombinerInputNV(int $stage, int $portion, int $variable, int $input, int $mapping, int $componentUsage) {
  static $proc;
  return ($proc ??= GL::getProcAddress('combinerInputNV'))($stage, $portion, $variable, $input, $mapping, $componentUsage);
}

function glCombinerOutputNV(int $stage, int $portion, int $abOutput, int $cdOutput, int $sumOutput, int $scale, int $bias, int $abDotProduct, int $cdDotProduct, int $muxSum) {
  static $proc;
  return ($proc ??= GL::getProcAddress('combinerOutputNV'))($stage, $portion, $abOutput, $cdOutput, $sumOutput, $scale, $bias, $abDotProduct, $cdDotProduct, $muxSum);
}

function glCombinerParameterfNV(int $pname, float $param) {
  static $proc;
  return ($proc ??= GL::getProcAddress('combinerParameterfNV'))($pname, $param);
}

function glCombinerParameterfvNV(int $pname, $params) {
  static $proc;
  return ($proc ??= GL::getProcAddress('combinerParameterfvNV'))($pname, $params);
}

function glCombinerParameteriNV(int $pname, int $param) {
  static $proc;
  return ($proc ??= GL::getProcAddress('combinerParameteriNV'))($pname, $param);
}

function glCombinerParameterivNV(int $pname, $params) {
  static $proc;
  return ($proc ??= GL::getProcAddress('combinerParameterivNV'))($pname, $params);
}

function glCombinerStageParameterfvNV(int $stage, int $pname, $params) {
  static $proc;
  return ($proc ??= GL::getProcAddress('combinerStageParameterfvNV'))($stage, $pname, $params);
}

function glCommandListSegmentsNV(int $list, int $segments) {
  static $proc;
  return ($proc ??= GL::getProcAddress('commandListSegmentsNV'))($list, $segments);
}

function glCompileCommandListNV(int $list) {
  static $proc;
  return ($proc ??= GL::getProcAddress('compileCommandListNV'))($list);
}

function glCompileShader(int $shader) {
  static $proc;
  return ($proc ??= GL::getProcAddress('compileShader'))($shader);
}

function glCompileShaderARB(int $shaderObj) {
  static $proc;
  return ($proc ??= GL::getProcAddress('compileShaderARB'))($shaderObj);
}

function glCompileShaderIncludeARB(int $shader, int $count, $path, $length) {
  static $proc;
  return ($proc ??= GL::getProcAddress('compileShaderIncludeARB'))($shader, $count, $path, $length);
}

function glCompressedMultiTexImage1DEXT(int $texunit, int $target, int $level, int $internalformat, int $width, int $border, int $imageSize, $bits) {
  static $proc;
  return ($proc ??= GL::getProcAddress('compressedMultiTexImage1DEXT'))($texunit, $target, $level, $internalformat, $width, $border, $imageSize, $bits);
}

function glCompressedMultiTexImage2DEXT(int $texunit, int $target, int $level, int $internalformat, int $width, int $height, int $border, int $imageSize, $bits) {
  static $proc;
  return ($proc ??= GL::getProcAddress('compressedMultiTexImage2DEXT'))($texunit, $target, $level, $internalformat, $width, $height, $border, $imageSize, $bits);
}

function glCompressedMultiTexImage3DEXT(int $texunit, int $target, int $level, int $internalformat, int $width, int $height, int $depth, int $border, int $imageSize, $bits) {
  static $proc;
  return ($proc ??= GL::getProcAddress('compressedMultiTexImage3DEXT'))($texunit, $target, $level, $internalformat, $width, $height, $depth, $border, $imageSize, $bits);
}

function glCompressedMultiTexSubImage1DEXT(int $texunit, int $target, int $level, int $xoffset, int $width, int $format, int $imageSize, $bits) {
  static $proc;
  return ($proc ??= GL::getProcAddress('compressedMultiTexSubImage1DEXT'))($texunit, $target, $level, $xoffset, $width, $format, $imageSize, $bits);
}

function glCompressedMultiTexSubImage2DEXT(int $texunit, int $target, int $level, int $xoffset, int $yoffset, int $width, int $height, int $format, int $imageSize, $bits) {
  static $proc;
  return ($proc ??= GL::getProcAddress('compressedMultiTexSubImage2DEXT'))($texunit, $target, $level, $xoffset, $yoffset, $width, $height, $format, $imageSize, $bits);
}

function glCompressedMultiTexSubImage3DEXT(int $texunit, int $target, int $level, int $xoffset, int $yoffset, int $zoffset, int $width, int $height, int $depth, int $format, int $imageSize, $bits) {
  static $proc;
  return ($proc ??= GL::getProcAddress('compressedMultiTexSubImage3DEXT'))($texunit, $target, $level, $xoffset, $yoffset, $zoffset, $width, $height, $depth, $format, $imageSize, $bits);
}

function glCompressedTexImage1D(int $target, int $level, int $internalformat, int $width, int $border, int $imageSize, $data) {
  static $proc;
  return ($proc ??= GL::getProcAddress('compressedTexImage1D'))($target, $level, $internalformat, $width, $border, $imageSize, $data);
}

function glCompressedTexImage1DARB(int $target, int $level, int $internalformat, int $width, int $border, int $imageSize, $data) {
  static $proc;
  return ($proc ??= GL::getProcAddress('compressedTexImage1DARB'))($target, $level, $internalformat, $width, $border, $imageSize, $data);
}

function glCompressedTexImage2D(int $target, int $level, int $internalformat, int $width, int $height, int $border, int $imageSize, $data) {
  static $proc;
  return ($proc ??= GL::getProcAddress('compressedTexImage2D'))($target, $level, $internalformat, $width, $height, $border, $imageSize, $data);
}

function glCompressedTexImage2DARB(int $target, int $level, int $internalformat, int $width, int $height, int $border, int $imageSize, $data) {
  static $proc;
  return ($proc ??= GL::getProcAddress('compressedTexImage2DARB'))($target, $level, $internalformat, $width, $height, $border, $imageSize, $data);
}

function glCompressedTexImage3D(int $target, int $level, int $internalformat, int $width, int $height, int $depth, int $border, int $imageSize, $data) {
  static $proc;
  return ($proc ??= GL::getProcAddress('compressedTexImage3D'))($target, $level, $internalformat, $width, $height, $depth, $border, $imageSize, $data);
}

function glCompressedTexImage3DARB(int $target, int $level, int $internalformat, int $width, int $height, int $depth, int $border, int $imageSize, $data) {
  static $proc;
  return ($proc ??= GL::getProcAddress('compressedTexImage3DARB'))($target, $level, $internalformat, $width, $height, $depth, $border, $imageSize, $data);
}

function glCompressedTexImage3DOES(int $target, int $level, int $internalformat, int $width, int $height, int $depth, int $border, int $imageSize, $data) {
  static $proc;
  return ($proc ??= GL::getProcAddress('compressedTexImage3DOES'))($target, $level, $internalformat, $width, $height, $depth, $border, $imageSize, $data);
}

function glCompressedTexSubImage1D(int $target, int $level, int $xoffset, int $width, int $format, int $imageSize, $data) {
  static $proc;
  return ($proc ??= GL::getProcAddress('compressedTexSubImage1D'))($target, $level, $xoffset, $width, $format, $imageSize, $data);
}

function glCompressedTexSubImage1DARB(int $target, int $level, int $xoffset, int $width, int $format, int $imageSize, $data) {
  static $proc;
  return ($proc ??= GL::getProcAddress('compressedTexSubImage1DARB'))($target, $level, $xoffset, $width, $format, $imageSize, $data);
}

function glCompressedTexSubImage2D(int $target, int $level, int $xoffset, int $yoffset, int $width, int $height, int $format, int $imageSize, $data) {
  static $proc;
  return ($proc ??= GL::getProcAddress('compressedTexSubImage2D'))($target, $level, $xoffset, $yoffset, $width, $height, $format, $imageSize, $data);
}

function glCompressedTexSubImage2DARB(int $target, int $level, int $xoffset, int $yoffset, int $width, int $height, int $format, int $imageSize, $data) {
  static $proc;
  return ($proc ??= GL::getProcAddress('compressedTexSubImage2DARB'))($target, $level, $xoffset, $yoffset, $width, $height, $format, $imageSize, $data);
}

function glCompressedTexSubImage3D(int $target, int $level, int $xoffset, int $yoffset, int $zoffset, int $width, int $height, int $depth, int $format, int $imageSize, $data) {
  static $proc;
  return ($proc ??= GL::getProcAddress('compressedTexSubImage3D'))($target, $level, $xoffset, $yoffset, $zoffset, $width, $height, $depth, $format, $imageSize, $data);
}

function glCompressedTexSubImage3DARB(int $target, int $level, int $xoffset, int $yoffset, int $zoffset, int $width, int $height, int $depth, int $format, int $imageSize, $data) {
  static $proc;
  return ($proc ??= GL::getProcAddress('compressedTexSubImage3DARB'))($target, $level, $xoffset, $yoffset, $zoffset, $width, $height, $depth, $format, $imageSize, $data);
}

function glCompressedTexSubImage3DOES(int $target, int $level, int $xoffset, int $yoffset, int $zoffset, int $width, int $height, int $depth, int $format, int $imageSize, $data) {
  static $proc;
  return ($proc ??= GL::getProcAddress('compressedTexSubImage3DOES'))($target, $level, $xoffset, $yoffset, $zoffset, $width, $height, $depth, $format, $imageSize, $data);
}

function glCompressedTextureImage1DEXT(int $texture, int $target, int $level, int $internalformat, int $width, int $border, int $imageSize, $bits) {
  static $proc;
  return ($proc ??= GL::getProcAddress('compressedTextureImage1DEXT'))($texture, $target, $level, $internalformat, $width, $border, $imageSize, $bits);
}

function glCompressedTextureImage2DEXT(int $texture, int $target, int $level, int $internalformat, int $width, int $height, int $border, int $imageSize, $bits) {
  static $proc;
  return ($proc ??= GL::getProcAddress('compressedTextureImage2DEXT'))($texture, $target, $level, $internalformat, $width, $height, $border, $imageSize, $bits);
}

function glCompressedTextureImage3DEXT(int $texture, int $target, int $level, int $internalformat, int $width, int $height, int $depth, int $border, int $imageSize, $bits) {
  static $proc;
  return ($proc ??= GL::getProcAddress('compressedTextureImage3DEXT'))($texture, $target, $level, $internalformat, $width, $height, $depth, $border, $imageSize, $bits);
}

function glCompressedTextureSubImage1D(int $texture, int $level, int $xoffset, int $width, int $format, int $imageSize, $data) {
  static $proc;
  return ($proc ??= GL::getProcAddress('compressedTextureSubImage1D'))($texture, $level, $xoffset, $width, $format, $imageSize, $data);
}

function glCompressedTextureSubImage1DEXT(int $texture, int $target, int $level, int $xoffset, int $width, int $format, int $imageSize, $bits) {
  static $proc;
  return ($proc ??= GL::getProcAddress('compressedTextureSubImage1DEXT'))($texture, $target, $level, $xoffset, $width, $format, $imageSize, $bits);
}

function glCompressedTextureSubImage2D(int $texture, int $level, int $xoffset, int $yoffset, int $width, int $height, int $format, int $imageSize, $data) {
  static $proc;
  return ($proc ??= GL::getProcAddress('compressedTextureSubImage2D'))($texture, $level, $xoffset, $yoffset, $width, $height, $format, $imageSize, $data);
}

function glCompressedTextureSubImage2DEXT(int $texture, int $target, int $level, int $xoffset, int $yoffset, int $width, int $height, int $format, int $imageSize, $bits) {
  static $proc;
  return ($proc ??= GL::getProcAddress('compressedTextureSubImage2DEXT'))($texture, $target, $level, $xoffset, $yoffset, $width, $height, $format, $imageSize, $bits);
}

function glCompressedTextureSubImage3D(int $texture, int $level, int $xoffset, int $yoffset, int $zoffset, int $width, int $height, int $depth, int $format, int $imageSize, $data) {
  static $proc;
  return ($proc ??= GL::getProcAddress('compressedTextureSubImage3D'))($texture, $level, $xoffset, $yoffset, $zoffset, $width, $height, $depth, $format, $imageSize, $data);
}

function glCompressedTextureSubImage3DEXT(int $texture, int $target, int $level, int $xoffset, int $yoffset, int $zoffset, int $width, int $height, int $depth, int $format, int $imageSize, $bits) {
  static $proc;
  return ($proc ??= GL::getProcAddress('compressedTextureSubImage3DEXT'))($texture, $target, $level, $xoffset, $yoffset, $zoffset, $width, $height, $depth, $format, $imageSize, $bits);
}

function glConservativeRasterParameterfNV(int $pname, float $value) {
  static $proc;
  return ($proc ??= GL::getProcAddress('conservativeRasterParameterfNV'))($pname, $value);
}

function glConservativeRasterParameteriNV(int $pname, int $param) {
  static $proc;
  return ($proc ??= GL::getProcAddress('conservativeRasterParameteriNV'))($pname, $param);
}

function glConvolutionFilter1D(int $target, int $internalformat, int $width, int $format, int $type, $image) {
  static $proc;
  return ($proc ??= GL::getProcAddress('convolutionFilter1D'))($target, $internalformat, $width, $format, $type, $image);
}

function glConvolutionFilter1DEXT(int $target, int $internalformat, int $width, int $format, int $type, $image) {
  static $proc;
  return ($proc ??= GL::getProcAddress('convolutionFilter1DEXT'))($target, $internalformat, $width, $format, $type, $image);
}

function glConvolutionFilter2D(int $target, int $internalformat, int $width, int $height, int $format, int $type, $image) {
  static $proc;
  return ($proc ??= GL::getProcAddress('convolutionFilter2D'))($target, $internalformat, $width, $height, $format, $type, $image);
}

function glConvolutionFilter2DEXT(int $target, int $internalformat, int $width, int $height, int $format, int $type, $image) {
  static $proc;
  return ($proc ??= GL::getProcAddress('convolutionFilter2DEXT'))($target, $internalformat, $width, $height, $format, $type, $image);
}

function glConvolutionParameterf(int $target, int $pname, float $params) {
  static $proc;
  return ($proc ??= GL::getProcAddress('convolutionParameterf'))($target, $pname, $params);
}

function glConvolutionParameterfEXT(int $target, int $pname, float $params) {
  static $proc;
  return ($proc ??= GL::getProcAddress('convolutionParameterfEXT'))($target, $pname, $params);
}

function glConvolutionParameterfv(int $target, int $pname, $params) {
  static $proc;
  return ($proc ??= GL::getProcAddress('convolutionParameterfv'))($target, $pname, $params);
}

function glConvolutionParameterfvEXT(int $target, int $pname, $params) {
  static $proc;
  return ($proc ??= GL::getProcAddress('convolutionParameterfvEXT'))($target, $pname, $params);
}

function glConvolutionParameteri(int $target, int $pname, int $params) {
  static $proc;
  return ($proc ??= GL::getProcAddress('convolutionParameteri'))($target, $pname, $params);
}

function glConvolutionParameteriEXT(int $target, int $pname, int $params) {
  static $proc;
  return ($proc ??= GL::getProcAddress('convolutionParameteriEXT'))($target, $pname, $params);
}

function glConvolutionParameteriv(int $target, int $pname, $params) {
  static $proc;
  return ($proc ??= GL::getProcAddress('convolutionParameteriv'))($target, $pname, $params);
}

function glConvolutionParameterivEXT(int $target, int $pname, $params) {
  static $proc;
  return ($proc ??= GL::getProcAddress('convolutionParameterivEXT'))($target, $pname, $params);
}

function glConvolutionParameterxOES(int $target, int $pname, int $param) {
  static $proc;
  return ($proc ??= GL::getProcAddress('convolutionParameterxOES'))($target, $pname, $param);
}

function glConvolutionParameterxvOES(int $target, int $pname, $params) {
  static $proc;
  return ($proc ??= GL::getProcAddress('convolutionParameterxvOES'))($target, $pname, $params);
}

function glCopyBufferSubData(int $readTarget, int $writeTarget, int $readOffset, int $writeOffset, int $size) {
  static $proc;
  return ($proc ??= GL::getProcAddress('copyBufferSubData'))($readTarget, $writeTarget, $readOffset, $writeOffset, $size);
}

function glCopyBufferSubDataNV(int $readTarget, int $writeTarget, int $readOffset, int $writeOffset, int $size) {
  static $proc;
  return ($proc ??= GL::getProcAddress('copyBufferSubDataNV'))($readTarget, $writeTarget, $readOffset, $writeOffset, $size);
}

function glCopyColorSubTable(int $target, int $start, int $x, int $y, int $width) {
  static $proc;
  return ($proc ??= GL::getProcAddress('copyColorSubTable'))($target, $start, $x, $y, $width);
}

function glCopyColorSubTableEXT(int $target, int $start, int $x, int $y, int $width) {
  static $proc;
  return ($proc ??= GL::getProcAddress('copyColorSubTableEXT'))($target, $start, $x, $y, $width);
}

function glCopyColorTable(int $target, int $internalformat, int $x, int $y, int $width) {
  static $proc;
  return ($proc ??= GL::getProcAddress('copyColorTable'))($target, $internalformat, $x, $y, $width);
}

function glCopyColorTableSGI(int $target, int $internalformat, int $x, int $y, int $width) {
  static $proc;
  return ($proc ??= GL::getProcAddress('copyColorTableSGI'))($target, $internalformat, $x, $y, $width);
}

function glCopyConvolutionFilter1D(int $target, int $internalformat, int $x, int $y, int $width) {
  static $proc;
  return ($proc ??= GL::getProcAddress('copyConvolutionFilter1D'))($target, $internalformat, $x, $y, $width);
}

function glCopyConvolutionFilter1DEXT(int $target, int $internalformat, int $x, int $y, int $width) {
  static $proc;
  return ($proc ??= GL::getProcAddress('copyConvolutionFilter1DEXT'))($target, $internalformat, $x, $y, $width);
}

function glCopyConvolutionFilter2D(int $target, int $internalformat, int $x, int $y, int $width, int $height) {
  static $proc;
  return ($proc ??= GL::getProcAddress('copyConvolutionFilter2D'))($target, $internalformat, $x, $y, $width, $height);
}

function glCopyConvolutionFilter2DEXT(int $target, int $internalformat, int $x, int $y, int $width, int $height) {
  static $proc;
  return ($proc ??= GL::getProcAddress('copyConvolutionFilter2DEXT'))($target, $internalformat, $x, $y, $width, $height);
}

function glCopyImageSubData(int $srcName, int $srcTarget, int $srcLevel, int $srcX, int $srcY, int $srcZ, int $dstName, int $dstTarget, int $dstLevel, int $dstX, int $dstY, int $dstZ, int $srcWidth, int $srcHeight, int $srcDepth) {
  static $proc;
  return ($proc ??= GL::getProcAddress('copyImageSubData'))($srcName, $srcTarget, $srcLevel, $srcX, $srcY, $srcZ, $dstName, $dstTarget, $dstLevel, $dstX, $dstY, $dstZ, $srcWidth, $srcHeight, $srcDepth);
}

function glCopyImageSubDataEXT(int $srcName, int $srcTarget, int $srcLevel, int $srcX, int $srcY, int $srcZ, int $dstName, int $dstTarget, int $dstLevel, int $dstX, int $dstY, int $dstZ, int $srcWidth, int $srcHeight, int $srcDepth) {
  static $proc;
  return ($proc ??= GL::getProcAddress('copyImageSubDataEXT'))($srcName, $srcTarget, $srcLevel, $srcX, $srcY, $srcZ, $dstName, $dstTarget, $dstLevel, $dstX, $dstY, $dstZ, $srcWidth, $srcHeight, $srcDepth);
}

function glCopyImageSubDataNV(int $srcName, int $srcTarget, int $srcLevel, int $srcX, int $srcY, int $srcZ, int $dstName, int $dstTarget, int $dstLevel, int $dstX, int $dstY, int $dstZ, int $width, int $height, int $depth) {
  static $proc;
  return ($proc ??= GL::getProcAddress('copyImageSubDataNV'))($srcName, $srcTarget, $srcLevel, $srcX, $srcY, $srcZ, $dstName, $dstTarget, $dstLevel, $dstX, $dstY, $dstZ, $width, $height, $depth);
}

function glCopyImageSubDataOES(int $srcName, int $srcTarget, int $srcLevel, int $srcX, int $srcY, int $srcZ, int $dstName, int $dstTarget, int $dstLevel, int $dstX, int $dstY, int $dstZ, int $srcWidth, int $srcHeight, int $srcDepth) {
  static $proc;
  return ($proc ??= GL::getProcAddress('copyImageSubDataOES'))($srcName, $srcTarget, $srcLevel, $srcX, $srcY, $srcZ, $dstName, $dstTarget, $dstLevel, $dstX, $dstY, $dstZ, $srcWidth, $srcHeight, $srcDepth);
}

function glCopyMultiTexImage1DEXT(int $texunit, int $target, int $level, int $internalformat, int $x, int $y, int $width, int $border) {
  static $proc;
  return ($proc ??= GL::getProcAddress('copyMultiTexImage1DEXT'))($texunit, $target, $level, $internalformat, $x, $y, $width, $border);
}

function glCopyMultiTexImage2DEXT(int $texunit, int $target, int $level, int $internalformat, int $x, int $y, int $width, int $height, int $border) {
  static $proc;
  return ($proc ??= GL::getProcAddress('copyMultiTexImage2DEXT'))($texunit, $target, $level, $internalformat, $x, $y, $width, $height, $border);
}

function glCopyMultiTexSubImage1DEXT(int $texunit, int $target, int $level, int $xoffset, int $x, int $y, int $width) {
  static $proc;
  return ($proc ??= GL::getProcAddress('copyMultiTexSubImage1DEXT'))($texunit, $target, $level, $xoffset, $x, $y, $width);
}

function glCopyMultiTexSubImage2DEXT(int $texunit, int $target, int $level, int $xoffset, int $yoffset, int $x, int $y, int $width, int $height) {
  static $proc;
  return ($proc ??= GL::getProcAddress('copyMultiTexSubImage2DEXT'))($texunit, $target, $level, $xoffset, $yoffset, $x, $y, $width, $height);
}

function glCopyMultiTexSubImage3DEXT(int $texunit, int $target, int $level, int $xoffset, int $yoffset, int $zoffset, int $x, int $y, int $width, int $height) {
  static $proc;
  return ($proc ??= GL::getProcAddress('copyMultiTexSubImage3DEXT'))($texunit, $target, $level, $xoffset, $yoffset, $zoffset, $x, $y, $width, $height);
}

function glCopyNamedBufferSubData(int $readBuffer, int $writeBuffer, int $readOffset, int $writeOffset, int $size) {
  static $proc;
  return ($proc ??= GL::getProcAddress('copyNamedBufferSubData'))($readBuffer, $writeBuffer, $readOffset, $writeOffset, $size);
}

function glCopyPathNV(int $resultPath, int $srcPath) {
  static $proc;
  return ($proc ??= GL::getProcAddress('copyPathNV'))($resultPath, $srcPath);
}

function glCopyPixels(int $x, int $y, int $width, int $height, int $type) {
  static $proc;
  return ($proc ??= GL::getProcAddress('copyPixels'))($x, $y, $width, $height, $type);
}

function glCopyTexImage1D(int $target, int $level, int $internalformat, int $x, int $y, int $width, int $border) {
  static $proc;
  return ($proc ??= GL::getProcAddress('copyTexImage1D'))($target, $level, $internalformat, $x, $y, $width, $border);
}

function glCopyTexImage1DEXT(int $target, int $level, int $internalformat, int $x, int $y, int $width, int $border) {
  static $proc;
  return ($proc ??= GL::getProcAddress('copyTexImage1DEXT'))($target, $level, $internalformat, $x, $y, $width, $border);
}

function glCopyTexImage2D(int $target, int $level, int $internalformat, int $x, int $y, int $width, int $height, int $border) {
  static $proc;
  return ($proc ??= GL::getProcAddress('copyTexImage2D'))($target, $level, $internalformat, $x, $y, $width, $height, $border);
}

function glCopyTexImage2DEXT(int $target, int $level, int $internalformat, int $x, int $y, int $width, int $height, int $border) {
  static $proc;
  return ($proc ??= GL::getProcAddress('copyTexImage2DEXT'))($target, $level, $internalformat, $x, $y, $width, $height, $border);
}

function glCopyTexSubImage1D(int $target, int $level, int $xoffset, int $x, int $y, int $width) {
  static $proc;
  return ($proc ??= GL::getProcAddress('copyTexSubImage1D'))($target, $level, $xoffset, $x, $y, $width);
}

function glCopyTexSubImage1DEXT(int $target, int $level, int $xoffset, int $x, int $y, int $width) {
  static $proc;
  return ($proc ??= GL::getProcAddress('copyTexSubImage1DEXT'))($target, $level, $xoffset, $x, $y, $width);
}

function glCopyTexSubImage2D(int $target, int $level, int $xoffset, int $yoffset, int $x, int $y, int $width, int $height) {
  static $proc;
  return ($proc ??= GL::getProcAddress('copyTexSubImage2D'))($target, $level, $xoffset, $yoffset, $x, $y, $width, $height);
}

function glCopyTexSubImage2DEXT(int $target, int $level, int $xoffset, int $yoffset, int $x, int $y, int $width, int $height) {
  static $proc;
  return ($proc ??= GL::getProcAddress('copyTexSubImage2DEXT'))($target, $level, $xoffset, $yoffset, $x, $y, $width, $height);
}

function glCopyTexSubImage3D(int $target, int $level, int $xoffset, int $yoffset, int $zoffset, int $x, int $y, int $width, int $height) {
  static $proc;
  return ($proc ??= GL::getProcAddress('copyTexSubImage3D'))($target, $level, $xoffset, $yoffset, $zoffset, $x, $y, $width, $height);
}

function glCopyTexSubImage3DEXT(int $target, int $level, int $xoffset, int $yoffset, int $zoffset, int $x, int $y, int $width, int $height) {
  static $proc;
  return ($proc ??= GL::getProcAddress('copyTexSubImage3DEXT'))($target, $level, $xoffset, $yoffset, $zoffset, $x, $y, $width, $height);
}

function glCopyTexSubImage3DOES(int $target, int $level, int $xoffset, int $yoffset, int $zoffset, int $x, int $y, int $width, int $height) {
  static $proc;
  return ($proc ??= GL::getProcAddress('copyTexSubImage3DOES'))($target, $level, $xoffset, $yoffset, $zoffset, $x, $y, $width, $height);
}

function glCopyTextureImage1DEXT(int $texture, int $target, int $level, int $internalformat, int $x, int $y, int $width, int $border) {
  static $proc;
  return ($proc ??= GL::getProcAddress('copyTextureImage1DEXT'))($texture, $target, $level, $internalformat, $x, $y, $width, $border);
}

function glCopyTextureImage2DEXT(int $texture, int $target, int $level, int $internalformat, int $x, int $y, int $width, int $height, int $border) {
  static $proc;
  return ($proc ??= GL::getProcAddress('copyTextureImage2DEXT'))($texture, $target, $level, $internalformat, $x, $y, $width, $height, $border);
}

function glCopyTextureLevelsAPPLE(int $destinationTexture, int $sourceTexture, int $sourceBaseLevel, int $sourceLevelCount) {
  static $proc;
  return ($proc ??= GL::getProcAddress('copyTextureLevelsAPPLE'))($destinationTexture, $sourceTexture, $sourceBaseLevel, $sourceLevelCount);
}

function glCopyTextureSubImage1D(int $texture, int $level, int $xoffset, int $x, int $y, int $width) {
  static $proc;
  return ($proc ??= GL::getProcAddress('copyTextureSubImage1D'))($texture, $level, $xoffset, $x, $y, $width);
}

function glCopyTextureSubImage1DEXT(int $texture, int $target, int $level, int $xoffset, int $x, int $y, int $width) {
  static $proc;
  return ($proc ??= GL::getProcAddress('copyTextureSubImage1DEXT'))($texture, $target, $level, $xoffset, $x, $y, $width);
}

function glCopyTextureSubImage2D(int $texture, int $level, int $xoffset, int $yoffset, int $x, int $y, int $width, int $height) {
  static $proc;
  return ($proc ??= GL::getProcAddress('copyTextureSubImage2D'))($texture, $level, $xoffset, $yoffset, $x, $y, $width, $height);
}

function glCopyTextureSubImage2DEXT(int $texture, int $target, int $level, int $xoffset, int $yoffset, int $x, int $y, int $width, int $height) {
  static $proc;
  return ($proc ??= GL::getProcAddress('copyTextureSubImage2DEXT'))($texture, $target, $level, $xoffset, $yoffset, $x, $y, $width, $height);
}

function glCopyTextureSubImage3D(int $texture, int $level, int $xoffset, int $yoffset, int $zoffset, int $x, int $y, int $width, int $height) {
  static $proc;
  return ($proc ??= GL::getProcAddress('copyTextureSubImage3D'))($texture, $level, $xoffset, $yoffset, $zoffset, $x, $y, $width, $height);
}

function glCopyTextureSubImage3DEXT(int $texture, int $target, int $level, int $xoffset, int $yoffset, int $zoffset, int $x, int $y, int $width, int $height) {
  static $proc;
  return ($proc ??= GL::getProcAddress('copyTextureSubImage3DEXT'))($texture, $target, $level, $xoffset, $yoffset, $zoffset, $x, $y, $width, $height);
}

function glCoverFillPathInstancedNV(int $numPaths, int $pathNameType, $paths, int $pathBase, int $coverMode, int $transformType, $transformValues) {
  static $proc;
  return ($proc ??= GL::getProcAddress('coverFillPathInstancedNV'))($numPaths, $pathNameType, $paths, $pathBase, $coverMode, $transformType, $transformValues);
}

function glCoverFillPathNV(int $path, int $coverMode) {
  static $proc;
  return ($proc ??= GL::getProcAddress('coverFillPathNV'))($path, $coverMode);
}

function glCoverStrokePathInstancedNV(int $numPaths, int $pathNameType, $paths, int $pathBase, int $coverMode, int $transformType, $transformValues) {
  static $proc;
  return ($proc ??= GL::getProcAddress('coverStrokePathInstancedNV'))($numPaths, $pathNameType, $paths, $pathBase, $coverMode, $transformType, $transformValues);
}

function glCoverStrokePathNV(int $path, int $coverMode) {
  static $proc;
  return ($proc ??= GL::getProcAddress('coverStrokePathNV'))($path, $coverMode);
}

function glCoverageMaskNV(int $mask) {
  static $proc;
  return ($proc ??= GL::getProcAddress('coverageMaskNV'))($mask);
}

function glCoverageModulationNV(int $components) {
  static $proc;
  return ($proc ??= GL::getProcAddress('coverageModulationNV'))($components);
}

function glCoverageModulationTableNV(int $n, $v) {
  static $proc;
  return ($proc ??= GL::getProcAddress('coverageModulationTableNV'))($n, $v);
}

function glCoverageOperationNV(int $operation) {
  static $proc;
  return ($proc ??= GL::getProcAddress('coverageOperationNV'))($operation);
}

function glCreateBuffers(int $n, $buffers) {
  static $proc;
  return ($proc ??= GL::getProcAddress('createBuffers'))($n, $buffers);
}

function glCreateCommandListsNV(int $n, $lists) {
  static $proc;
  return ($proc ??= GL::getProcAddress('createCommandListsNV'))($n, $lists);
}

function glCreateFramebuffers(int $n, $framebuffers) {
  static $proc;
  return ($proc ??= GL::getProcAddress('createFramebuffers'))($n, $framebuffers);
}

function glCreatePerfQueryINTEL(int $queryId, $queryHandle) {
  static $proc;
  return ($proc ??= GL::getProcAddress('createPerfQueryINTEL'))($queryId, $queryHandle);
}

function glCreateProgram() {
  static $proc;
  return ($proc ??= GL::getProcAddress('createProgram'))();
}

function glCreateProgramObjectARB() {
  static $proc;
  return ($proc ??= GL::getProcAddress('createProgramObjectARB'))();
}

function glCreateProgramPipelines(int $n, $pipelines) {
  static $proc;
  return ($proc ??= GL::getProcAddress('createProgramPipelines'))($n, $pipelines);
}

function glCreateQueries(int $target, int $n, $ids) {
  static $proc;
  return ($proc ??= GL::getProcAddress('createQueries'))($target, $n, $ids);
}

function glCreateRenderbuffers(int $n, $renderbuffers) {
  static $proc;
  return ($proc ??= GL::getProcAddress('createRenderbuffers'))($n, $renderbuffers);
}

function glCreateSamplers(int $n, $samplers) {
  static $proc;
  return ($proc ??= GL::getProcAddress('createSamplers'))($n, $samplers);
}

function glCreateShader(int $type) {
  static $proc;
  return ($proc ??= GL::getProcAddress('createShader'))($type);
}

function glCreateShaderObjectARB(int $shaderType) {
  static $proc;
  return ($proc ??= GL::getProcAddress('createShaderObjectARB'))($shaderType);
}

function glCreateShaderProgramEXT(int $type, $string) {
  static $proc;
  return ($proc ??= GL::getProcAddress('createShaderProgramEXT'))($type, $string);
}

function glCreateShaderProgramv(int $type, int $count, $strings) {
  static $proc;
  return ($proc ??= GL::getProcAddress('createShaderProgramv'))($type, $count, $strings);
}

function glCreateShaderProgramvEXT(int $type, int $count, $strings) {
  static $proc;
  return ($proc ??= GL::getProcAddress('createShaderProgramvEXT'))($type, $count, $strings);
}

function glCreateStatesNV(int $n, $states) {
  static $proc;
  return ($proc ??= GL::getProcAddress('createStatesNV'))($n, $states);
}

function glCreateSyncFromCLeventARB($context, $event, int $flags) {
  static $proc;
  return ($proc ??= GL::getProcAddress('createSyncFromCLeventARB'))($context, $event, $flags);
}

function glCreateTextures(int $target, int $n, $textures) {
  static $proc;
  return ($proc ??= GL::getProcAddress('createTextures'))($target, $n, $textures);
}

function glCreateTransformFeedbacks(int $n, $ids) {
  static $proc;
  return ($proc ??= GL::getProcAddress('createTransformFeedbacks'))($n, $ids);
}

function glCreateVertexArrays(int $n, $arrays) {
  static $proc;
  return ($proc ??= GL::getProcAddress('createVertexArrays'))($n, $arrays);
}

function glCullFace(int $mode) {
  static $proc;
  return ($proc ??= GL::getProcAddress('cullFace'))($mode);
}

function glCullParameterdvEXT(int $pname, $params) {
  static $proc;
  return ($proc ??= GL::getProcAddress('cullParameterdvEXT'))($pname, $params);
}

function glCullParameterfvEXT(int $pname, $params) {
  static $proc;
  return ($proc ??= GL::getProcAddress('cullParameterfvEXT'))($pname, $params);
}

function glCurrentPaletteMatrixARB(int $index) {
  static $proc;
  return ($proc ??= GL::getProcAddress('currentPaletteMatrixARB'))($index);
}

function glCurrentPaletteMatrixOES(int $matrixpaletteindex) {
  static $proc;
  return ($proc ??= GL::getProcAddress('currentPaletteMatrixOES'))($matrixpaletteindex);
}

function glDebugMessageCallback($callback, $userParam) {
  static $proc;
  return ($proc ??= GL::getProcAddress('debugMessageCallback'))($callback, $userParam);
}

function glDebugMessageCallbackAMD($callback, $userParam) {
  static $proc;
  return ($proc ??= GL::getProcAddress('debugMessageCallbackAMD'))($callback, $userParam);
}

function glDebugMessageCallbackARB($callback, $userParam) {
  static $proc;
  return ($proc ??= GL::getProcAddress('debugMessageCallbackARB'))($callback, $userParam);
}

function glDebugMessageCallbackKHR($callback, $userParam) {
  static $proc;
  return ($proc ??= GL::getProcAddress('debugMessageCallbackKHR'))($callback, $userParam);
}

function glDebugMessageControl(int $source, int $type, int $severity, int $count, $ids, int $enabled) {
  static $proc;
  return ($proc ??= GL::getProcAddress('debugMessageControl'))($source, $type, $severity, $count, $ids, $enabled);
}

function glDebugMessageControlARB(int $source, int $type, int $severity, int $count, $ids, int $enabled) {
  static $proc;
  return ($proc ??= GL::getProcAddress('debugMessageControlARB'))($source, $type, $severity, $count, $ids, $enabled);
}

function glDebugMessageControlKHR(int $source, int $type, int $severity, int $count, $ids, int $enabled) {
  static $proc;
  return ($proc ??= GL::getProcAddress('debugMessageControlKHR'))($source, $type, $severity, $count, $ids, $enabled);
}

function glDebugMessageEnableAMD(int $category, int $severity, int $count, $ids, int $enabled) {
  static $proc;
  return ($proc ??= GL::getProcAddress('debugMessageEnableAMD'))($category, $severity, $count, $ids, $enabled);
}

function glDebugMessageInsert(int $source, int $type, int $id, int $severity, int $length, $buf) {
  static $proc;
  return ($proc ??= GL::getProcAddress('debugMessageInsert'))($source, $type, $id, $severity, $length, $buf);
}

function glDebugMessageInsertAMD(int $category, int $severity, int $id, int $length, $buf) {
  static $proc;
  return ($proc ??= GL::getProcAddress('debugMessageInsertAMD'))($category, $severity, $id, $length, $buf);
}

function glDebugMessageInsertARB(int $source, int $type, int $id, int $severity, int $length, $buf) {
  static $proc;
  return ($proc ??= GL::getProcAddress('debugMessageInsertARB'))($source, $type, $id, $severity, $length, $buf);
}

function glDebugMessageInsertKHR(int $source, int $type, int $id, int $severity, int $length, $buf) {
  static $proc;
  return ($proc ??= GL::getProcAddress('debugMessageInsertKHR'))($source, $type, $id, $severity, $length, $buf);
}

function glDeformSGIX(int $mask) {
  static $proc;
  return ($proc ??= GL::getProcAddress('deformSGIX'))($mask);
}

function glDeformationMap3dSGIX(int $target, float $u1, float $u2, int $ustride, int $uorder, float $v1, float $v2, int $vstride, int $vorder, float $w1, float $w2, int $wstride, int $worder, $points) {
  static $proc;
  return ($proc ??= GL::getProcAddress('deformationMap3dSGIX'))($target, $u1, $u2, $ustride, $uorder, $v1, $v2, $vstride, $vorder, $w1, $w2, $wstride, $worder, $points);
}

function glDeformationMap3fSGIX(int $target, float $u1, float $u2, int $ustride, int $uorder, float $v1, float $v2, int $vstride, int $vorder, float $w1, float $w2, int $wstride, int $worder, $points) {
  static $proc;
  return ($proc ??= GL::getProcAddress('deformationMap3fSGIX'))($target, $u1, $u2, $ustride, $uorder, $v1, $v2, $vstride, $vorder, $w1, $w2, $wstride, $worder, $points);
}

function glDeleteAsyncMarkersSGIX(int $marker, int $range) {
  static $proc;
  return ($proc ??= GL::getProcAddress('deleteAsyncMarkersSGIX'))($marker, $range);
}

function glDeleteBuffers(int $n, $buffers) {
  static $proc;
  return ($proc ??= GL::getProcAddress('deleteBuffers'))($n, $buffers);
}

function glDeleteBuffersARB(int $n, $buffers) {
  static $proc;
  return ($proc ??= GL::getProcAddress('deleteBuffersARB'))($n, $buffers);
}

function glDeleteCommandListsNV(int $n, $lists) {
  static $proc;
  return ($proc ??= GL::getProcAddress('deleteCommandListsNV'))($n, $lists);
}

function glDeleteFencesAPPLE(int $n, $fences) {
  static $proc;
  return ($proc ??= GL::getProcAddress('deleteFencesAPPLE'))($n, $fences);
}

function glDeleteFencesNV(int $n, $fences) {
  static $proc;
  return ($proc ??= GL::getProcAddress('deleteFencesNV'))($n, $fences);
}

function glDeleteFragmentShaderATI(int $id) {
  static $proc;
  return ($proc ??= GL::getProcAddress('deleteFragmentShaderATI'))($id);
}

function glDeleteFramebuffers(int $n, $framebuffers) {
  static $proc;
  return ($proc ??= GL::getProcAddress('deleteFramebuffers'))($n, $framebuffers);
}

function glDeleteFramebuffersEXT(int $n, $framebuffers) {
  static $proc;
  return ($proc ??= GL::getProcAddress('deleteFramebuffersEXT'))($n, $framebuffers);
}

function glDeleteFramebuffersOES(int $n, $framebuffers) {
  static $proc;
  return ($proc ??= GL::getProcAddress('deleteFramebuffersOES'))($n, $framebuffers);
}

function glDeleteLists(int $list, int $range) {
  static $proc;
  return ($proc ??= GL::getProcAddress('deleteLists'))($list, $range);
}

function glDeleteNamedStringARB(int $namelen, $name) {
  static $proc;
  return ($proc ??= GL::getProcAddress('deleteNamedStringARB'))($namelen, $name);
}

function glDeleteNamesAMD(int $identifier, int $num, $names) {
  static $proc;
  return ($proc ??= GL::getProcAddress('deleteNamesAMD'))($identifier, $num, $names);
}

function glDeleteObjectARB(int $obj) {
  static $proc;
  return ($proc ??= GL::getProcAddress('deleteObjectARB'))($obj);
}

function glDeleteOcclusionQueriesNV(int $n, $ids) {
  static $proc;
  return ($proc ??= GL::getProcAddress('deleteOcclusionQueriesNV'))($n, $ids);
}

function glDeletePathsNV(int $path, int $range) {
  static $proc;
  return ($proc ??= GL::getProcAddress('deletePathsNV'))($path, $range);
}

function glDeletePerfMonitorsAMD(int $n, $monitors) {
  static $proc;
  return ($proc ??= GL::getProcAddress('deletePerfMonitorsAMD'))($n, $monitors);
}

function glDeletePerfQueryINTEL(int $queryHandle) {
  static $proc;
  return ($proc ??= GL::getProcAddress('deletePerfQueryINTEL'))($queryHandle);
}

function glDeleteProgram(int $program) {
  static $proc;
  return ($proc ??= GL::getProcAddress('deleteProgram'))($program);
}

function glDeleteProgramPipelines(int $n, $pipelines) {
  static $proc;
  return ($proc ??= GL::getProcAddress('deleteProgramPipelines'))($n, $pipelines);
}

function glDeleteProgramPipelinesEXT(int $n, $pipelines) {
  static $proc;
  return ($proc ??= GL::getProcAddress('deleteProgramPipelinesEXT'))($n, $pipelines);
}

function glDeleteProgramsARB(int $n, $programs) {
  static $proc;
  return ($proc ??= GL::getProcAddress('deleteProgramsARB'))($n, $programs);
}

function glDeleteProgramsNV(int $n, $programs) {
  static $proc;
  return ($proc ??= GL::getProcAddress('deleteProgramsNV'))($n, $programs);
}

function glDeleteQueries(int $n, $ids) {
  static $proc;
  return ($proc ??= GL::getProcAddress('deleteQueries'))($n, $ids);
}

function glDeleteQueriesARB(int $n, $ids) {
  static $proc;
  return ($proc ??= GL::getProcAddress('deleteQueriesARB'))($n, $ids);
}

function glDeleteQueriesEXT(int $n, $ids) {
  static $proc;
  return ($proc ??= GL::getProcAddress('deleteQueriesEXT'))($n, $ids);
}

function glDeleteRenderbuffers(int $n, $renderbuffers) {
  static $proc;
  return ($proc ??= GL::getProcAddress('deleteRenderbuffers'))($n, $renderbuffers);
}

function glDeleteRenderbuffersEXT(int $n, $renderbuffers) {
  static $proc;
  return ($proc ??= GL::getProcAddress('deleteRenderbuffersEXT'))($n, $renderbuffers);
}

function glDeleteRenderbuffersOES(int $n, $renderbuffers) {
  static $proc;
  return ($proc ??= GL::getProcAddress('deleteRenderbuffersOES'))($n, $renderbuffers);
}

function glDeleteSamplers(int $count, $samplers) {
  static $proc;
  return ($proc ??= GL::getProcAddress('deleteSamplers'))($count, $samplers);
}

function glDeleteShader(int $shader) {
  static $proc;
  return ($proc ??= GL::getProcAddress('deleteShader'))($shader);
}

function glDeleteStatesNV(int $n, $states) {
  static $proc;
  return ($proc ??= GL::getProcAddress('deleteStatesNV'))($n, $states);
}

function glDeleteSync(int $sync) {
  static $proc;
  return ($proc ??= GL::getProcAddress('deleteSync'))($sync);
}

function glDeleteSyncAPPLE(int $sync) {
  static $proc;
  return ($proc ??= GL::getProcAddress('deleteSyncAPPLE'))($sync);
}

function glDeleteTextures(int $n, $textures) {
  static $proc;
  return ($proc ??= GL::getProcAddress('deleteTextures'))($n, $textures);
}

function glDeleteTexturesEXT(int $n, $textures) {
  static $proc;
  return ($proc ??= GL::getProcAddress('deleteTexturesEXT'))($n, $textures);
}

function glDeleteTransformFeedbacks(int $n, $ids) {
  static $proc;
  return ($proc ??= GL::getProcAddress('deleteTransformFeedbacks'))($n, $ids);
}

function glDeleteTransformFeedbacksNV(int $n, $ids) {
  static $proc;
  return ($proc ??= GL::getProcAddress('deleteTransformFeedbacksNV'))($n, $ids);
}

function glDeleteVertexArrays(int $n, $arrays) {
  static $proc;
  return ($proc ??= GL::getProcAddress('deleteVertexArrays'))($n, $arrays);
}

function glDeleteVertexArraysAPPLE(int $n, $arrays) {
  static $proc;
  return ($proc ??= GL::getProcAddress('deleteVertexArraysAPPLE'))($n, $arrays);
}

function glDeleteVertexArraysOES(int $n, $arrays) {
  static $proc;
  return ($proc ??= GL::getProcAddress('deleteVertexArraysOES'))($n, $arrays);
}

function glDeleteVertexShaderEXT(int $id) {
  static $proc;
  return ($proc ??= GL::getProcAddress('deleteVertexShaderEXT'))($id);
}

function glDepthBoundsEXT($zmin, $zmax) {
  static $proc;
  return ($proc ??= GL::getProcAddress('depthBoundsEXT'))($zmin, $zmax);
}

function glDepthBoundsdNV(float $zmin, float $zmax) {
  static $proc;
  return ($proc ??= GL::getProcAddress('depthBoundsdNV'))($zmin, $zmax);
}

function glDepthFunc(int $func) {
  static $proc;
  return ($proc ??= GL::getProcAddress('depthFunc'))($func);
}

function glDepthMask(int $flag) {
  static $proc;
  return ($proc ??= GL::getProcAddress('depthMask'))($flag);
}

function glDepthRange(float $near, float $far) {
  static $proc;
  return ($proc ??= GL::getProcAddress('depthRange'))($near, $far);
}

function glDepthRangeArrayfvNV(int $first, int $count, $v) {
  static $proc;
  return ($proc ??= GL::getProcAddress('depthRangeArrayfvNV'))($first, $count, $v);
}

function glDepthRangeArrayfvOES(int $first, int $count, $v) {
  static $proc;
  return ($proc ??= GL::getProcAddress('depthRangeArrayfvOES'))($first, $count, $v);
}

function glDepthRangeArrayv(int $first, int $count, $v) {
  static $proc;
  return ($proc ??= GL::getProcAddress('depthRangeArrayv'))($first, $count, $v);
}

function glDepthRangeIndexed(int $index, float $n, float $f) {
  static $proc;
  return ($proc ??= GL::getProcAddress('depthRangeIndexed'))($index, $n, $f);
}

function glDepthRangeIndexedfNV(int $index, float $n, float $f) {
  static $proc;
  return ($proc ??= GL::getProcAddress('depthRangeIndexedfNV'))($index, $n, $f);
}

function glDepthRangeIndexedfOES(int $index, float $n, float $f) {
  static $proc;
  return ($proc ??= GL::getProcAddress('depthRangeIndexedfOES'))($index, $n, $f);
}

function glDepthRangedNV(float $zNear, float $zFar) {
  static $proc;
  return ($proc ??= GL::getProcAddress('depthRangedNV'))($zNear, $zFar);
}

function glDepthRangef(float $n, float $f) {
  static $proc;
  return ($proc ??= GL::getProcAddress('depthRangef'))($n, $f);
}

function glDepthRangefOES($n, $f) {
  static $proc;
  return ($proc ??= GL::getProcAddress('depthRangefOES'))($n, $f);
}

function glDepthRangex(int $n, int $f) {
  static $proc;
  return ($proc ??= GL::getProcAddress('depthRangex'))($n, $f);
}

function glDepthRangexOES(int $n, int $f) {
  static $proc;
  return ($proc ??= GL::getProcAddress('depthRangexOES'))($n, $f);
}

function glDetachObjectARB(int $containerObj, int $attachedObj) {
  static $proc;
  return ($proc ??= GL::getProcAddress('detachObjectARB'))($containerObj, $attachedObj);
}

function glDetachShader(int $program, int $shader) {
  static $proc;
  return ($proc ??= GL::getProcAddress('detachShader'))($program, $shader);
}

function glDetailTexFuncSGIS(int $target, int $n, $points) {
  static $proc;
  return ($proc ??= GL::getProcAddress('detailTexFuncSGIS'))($target, $n, $points);
}

function glDisable(int $cap) {
  static $proc;
  return ($proc ??= GL::getProcAddress('disable'))($cap);
}

function glDisableClientState(int $array) {
  static $proc;
  return ($proc ??= GL::getProcAddress('disableClientState'))($array);
}

function glDisableClientStateIndexedEXT(int $array, int $index) {
  static $proc;
  return ($proc ??= GL::getProcAddress('disableClientStateIndexedEXT'))($array, $index);
}

function glDisableClientStateiEXT(int $array, int $index) {
  static $proc;
  return ($proc ??= GL::getProcAddress('disableClientStateiEXT'))($array, $index);
}

function glDisableDriverControlQCOM(int $driverControl) {
  static $proc;
  return ($proc ??= GL::getProcAddress('disableDriverControlQCOM'))($driverControl);
}

function glDisableIndexedEXT(int $target, int $index) {
  static $proc;
  return ($proc ??= GL::getProcAddress('disableIndexedEXT'))($target, $index);
}

function glDisableVariantClientStateEXT(int $id) {
  static $proc;
  return ($proc ??= GL::getProcAddress('disableVariantClientStateEXT'))($id);
}

function glDisableVertexArrayAttrib(int $vaobj, int $index) {
  static $proc;
  return ($proc ??= GL::getProcAddress('disableVertexArrayAttrib'))($vaobj, $index);
}

function glDisableVertexArrayAttribEXT(int $vaobj, int $index) {
  static $proc;
  return ($proc ??= GL::getProcAddress('disableVertexArrayAttribEXT'))($vaobj, $index);
}

function glDisableVertexArrayEXT(int $vaobj, int $array) {
  static $proc;
  return ($proc ??= GL::getProcAddress('disableVertexArrayEXT'))($vaobj, $array);
}

function glDisableVertexAttribAPPLE(int $index, int $pname) {
  static $proc;
  return ($proc ??= GL::getProcAddress('disableVertexAttribAPPLE'))($index, $pname);
}

function glDisableVertexAttribArray(int $index) {
  static $proc;
  return ($proc ??= GL::getProcAddress('disableVertexAttribArray'))($index);
}

function glDisableVertexAttribArrayARB(int $index) {
  static $proc;
  return ($proc ??= GL::getProcAddress('disableVertexAttribArrayARB'))($index);
}

function glDisablei(int $target, int $index) {
  static $proc;
  return ($proc ??= GL::getProcAddress('disablei'))($target, $index);
}

function glDisableiEXT(int $target, int $index) {
  static $proc;
  return ($proc ??= GL::getProcAddress('disableiEXT'))($target, $index);
}

function glDisableiNV(int $target, int $index) {
  static $proc;
  return ($proc ??= GL::getProcAddress('disableiNV'))($target, $index);
}

function glDisableiOES(int $target, int $index) {
  static $proc;
  return ($proc ??= GL::getProcAddress('disableiOES'))($target, $index);
}

function glDiscardFramebufferEXT(int $target, int $numAttachments, $attachments) {
  static $proc;
  return ($proc ??= GL::getProcAddress('discardFramebufferEXT'))($target, $numAttachments, $attachments);
}

function glDispatchCompute(int $num_groups_x, int $num_groups_y, int $num_groups_z) {
  static $proc;
  return ($proc ??= GL::getProcAddress('dispatchCompute'))($num_groups_x, $num_groups_y, $num_groups_z);
}

function glDispatchComputeGroupSizeARB(int $num_groups_x, int $num_groups_y, int $num_groups_z, int $group_size_x, int $group_size_y, int $group_size_z) {
  static $proc;
  return ($proc ??= GL::getProcAddress('dispatchComputeGroupSizeARB'))($num_groups_x, $num_groups_y, $num_groups_z, $group_size_x, $group_size_y, $group_size_z);
}

function glDispatchComputeIndirect(int $indirect) {
  static $proc;
  return ($proc ??= GL::getProcAddress('dispatchComputeIndirect'))($indirect);
}

function glDrawArrays(int $mode, int $first, int $count) {
  static $proc;
  return ($proc ??= GL::getProcAddress('drawArrays'))($mode, $first, $count);
}

function glDrawArraysEXT(int $mode, int $first, int $count) {
  static $proc;
  return ($proc ??= GL::getProcAddress('drawArraysEXT'))($mode, $first, $count);
}

function glDrawArraysIndirect(int $mode, $indirect) {
  static $proc;
  return ($proc ??= GL::getProcAddress('drawArraysIndirect'))($mode, $indirect);
}

function glDrawArraysInstanced(int $mode, int $first, int $count, int $instancecount) {
  static $proc;
  return ($proc ??= GL::getProcAddress('drawArraysInstanced'))($mode, $first, $count, $instancecount);
}

function glDrawArraysInstancedANGLE(int $mode, int $first, int $count, int $primcount) {
  static $proc;
  return ($proc ??= GL::getProcAddress('drawArraysInstancedANGLE'))($mode, $first, $count, $primcount);
}

function glDrawArraysInstancedARB(int $mode, int $first, int $count, int $primcount) {
  static $proc;
  return ($proc ??= GL::getProcAddress('drawArraysInstancedARB'))($mode, $first, $count, $primcount);
}

function glDrawArraysInstancedBaseInstance(int $mode, int $first, int $count, int $instancecount, int $baseinstance) {
  static $proc;
  return ($proc ??= GL::getProcAddress('drawArraysInstancedBaseInstance'))($mode, $first, $count, $instancecount, $baseinstance);
}

function glDrawArraysInstancedBaseInstanceEXT(int $mode, int $first, int $count, int $instancecount, int $baseinstance) {
  static $proc;
  return ($proc ??= GL::getProcAddress('drawArraysInstancedBaseInstanceEXT'))($mode, $first, $count, $instancecount, $baseinstance);
}

function glDrawArraysInstancedEXT(int $mode, int $start, int $count, int $primcount) {
  static $proc;
  return ($proc ??= GL::getProcAddress('drawArraysInstancedEXT'))($mode, $start, $count, $primcount);
}

function glDrawArraysInstancedNV(int $mode, int $first, int $count, int $primcount) {
  static $proc;
  return ($proc ??= GL::getProcAddress('drawArraysInstancedNV'))($mode, $first, $count, $primcount);
}

function glDrawBuffer(int $buf) {
  static $proc;
  return ($proc ??= GL::getProcAddress('drawBuffer'))($buf);
}

function glDrawBuffers(int $n, $bufs) {
  static $proc;
  return ($proc ??= GL::getProcAddress('drawBuffers'))($n, $bufs);
}

function glDrawBuffersARB(int $n, $bufs) {
  static $proc;
  return ($proc ??= GL::getProcAddress('drawBuffersARB'))($n, $bufs);
}

function glDrawBuffersATI(int $n, $bufs) {
  static $proc;
  return ($proc ??= GL::getProcAddress('drawBuffersATI'))($n, $bufs);
}

function glDrawBuffersEXT(int $n, $bufs) {
  static $proc;
  return ($proc ??= GL::getProcAddress('drawBuffersEXT'))($n, $bufs);
}

function glDrawBuffersIndexedEXT(int $n, $location, $indices) {
  static $proc;
  return ($proc ??= GL::getProcAddress('drawBuffersIndexedEXT'))($n, $location, $indices);
}

function glDrawBuffersNV(int $n, $bufs) {
  static $proc;
  return ($proc ??= GL::getProcAddress('drawBuffersNV'))($n, $bufs);
}

function glDrawCommandsAddressNV(int $primitiveMode, $indirects, $sizes, int $count) {
  static $proc;
  return ($proc ??= GL::getProcAddress('drawCommandsAddressNV'))($primitiveMode, $indirects, $sizes, $count);
}

function glDrawCommandsNV(int $primitiveMode, int $buffer, $indirects, $sizes, int $count) {
  static $proc;
  return ($proc ??= GL::getProcAddress('drawCommandsNV'))($primitiveMode, $buffer, $indirects, $sizes, $count);
}

function glDrawCommandsStatesAddressNV($indirects, $sizes, $states, $fbos, int $count) {
  static $proc;
  return ($proc ??= GL::getProcAddress('drawCommandsStatesAddressNV'))($indirects, $sizes, $states, $fbos, $count);
}

function glDrawCommandsStatesNV(int $buffer, $indirects, $sizes, $states, $fbos, int $count) {
  static $proc;
  return ($proc ??= GL::getProcAddress('drawCommandsStatesNV'))($buffer, $indirects, $sizes, $states, $fbos, $count);
}

function glDrawElementArrayAPPLE(int $mode, int $first, int $count) {
  static $proc;
  return ($proc ??= GL::getProcAddress('drawElementArrayAPPLE'))($mode, $first, $count);
}

function glDrawElementArrayATI(int $mode, int $count) {
  static $proc;
  return ($proc ??= GL::getProcAddress('drawElementArrayATI'))($mode, $count);
}

function glDrawElements(int $mode, int $count, int $type, int $indices) {
  static $proc;
  return ($proc ??= GL::getProcAddress('drawElements'))($mode, $count, $type, $indices);
}

function glDrawElementsBaseVertex(int $mode, int $count, int $type, $indices, int $basevertex) {
  static $proc;
  return ($proc ??= GL::getProcAddress('drawElementsBaseVertex'))($mode, $count, $type, $indices, $basevertex);
}

function glDrawElementsBaseVertexEXT(int $mode, int $count, int $type, $indices, int $basevertex) {
  static $proc;
  return ($proc ??= GL::getProcAddress('drawElementsBaseVertexEXT'))($mode, $count, $type, $indices, $basevertex);
}

function glDrawElementsBaseVertexOES(int $mode, int $count, int $type, $indices, int $basevertex) {
  static $proc;
  return ($proc ??= GL::getProcAddress('drawElementsBaseVertexOES'))($mode, $count, $type, $indices, $basevertex);
}

function glDrawElementsIndirect(int $mode, int $type, $indirect) {
  static $proc;
  return ($proc ??= GL::getProcAddress('drawElementsIndirect'))($mode, $type, $indirect);
}

function glDrawElementsInstanced(int $mode, int $count, int $type, $indices, int $instancecount) {
  static $proc;
  return ($proc ??= GL::getProcAddress('drawElementsInstanced'))($mode, $count, $type, $indices, $instancecount);
}

function glDrawElementsInstancedANGLE(int $mode, int $count, int $type, $indices, int $primcount) {
  static $proc;
  return ($proc ??= GL::getProcAddress('drawElementsInstancedANGLE'))($mode, $count, $type, $indices, $primcount);
}

function glDrawElementsInstancedARB(int $mode, int $count, int $type, $indices, int $primcount) {
  static $proc;
  return ($proc ??= GL::getProcAddress('drawElementsInstancedARB'))($mode, $count, $type, $indices, $primcount);
}

function glDrawElementsInstancedBaseInstance(int $mode, int $count, int $type, $indices, int $instancecount, int $baseinstance) {
  static $proc;
  return ($proc ??= GL::getProcAddress('drawElementsInstancedBaseInstance'))($mode, $count, $type, $indices, $instancecount, $baseinstance);
}

function glDrawElementsInstancedBaseInstanceEXT(int $mode, int $count, int $type, $indices, int $instancecount, int $baseinstance) {
  static $proc;
  return ($proc ??= GL::getProcAddress('drawElementsInstancedBaseInstanceEXT'))($mode, $count, $type, $indices, $instancecount, $baseinstance);
}

function glDrawElementsInstancedBaseVertex(int $mode, int $count, int $type, $indices, int $instancecount, int $basevertex) {
  static $proc;
  return ($proc ??= GL::getProcAddress('drawElementsInstancedBaseVertex'))($mode, $count, $type, $indices, $instancecount, $basevertex);
}

function glDrawElementsInstancedBaseVertexBaseInstance(int $mode, int $count, int $type, $indices, int $instancecount, int $basevertex, int $baseinstance) {
  static $proc;
  return ($proc ??= GL::getProcAddress('drawElementsInstancedBaseVertexBaseInstance'))($mode, $count, $type, $indices, $instancecount, $basevertex, $baseinstance);
}

function glDrawElementsInstancedBaseVertexBaseInstanceEXT(int $mode, int $count, int $type, $indices, int $instancecount, int $basevertex, int $baseinstance) {
  static $proc;
  return ($proc ??= GL::getProcAddress('drawElementsInstancedBaseVertexBaseInstanceEXT'))($mode, $count, $type, $indices, $instancecount, $basevertex, $baseinstance);
}

function glDrawElementsInstancedBaseVertexEXT(int $mode, int $count, int $type, $indices, int $instancecount, int $basevertex) {
  static $proc;
  return ($proc ??= GL::getProcAddress('drawElementsInstancedBaseVertexEXT'))($mode, $count, $type, $indices, $instancecount, $basevertex);
}

function glDrawElementsInstancedBaseVertexOES(int $mode, int $count, int $type, $indices, int $instancecount, int $basevertex) {
  static $proc;
  return ($proc ??= GL::getProcAddress('drawElementsInstancedBaseVertexOES'))($mode, $count, $type, $indices, $instancecount, $basevertex);
}

function glDrawElementsInstancedEXT(int $mode, int $count, int $type, $indices, int $primcount) {
  static $proc;
  return ($proc ??= GL::getProcAddress('drawElementsInstancedEXT'))($mode, $count, $type, $indices, $primcount);
}

function glDrawElementsInstancedNV(int $mode, int $count, int $type, $indices, int $primcount) {
  static $proc;
  return ($proc ??= GL::getProcAddress('drawElementsInstancedNV'))($mode, $count, $type, $indices, $primcount);
}

function glDrawMeshArraysSUN(int $mode, int $first, int $count, int $width) {
  static $proc;
  return ($proc ??= GL::getProcAddress('drawMeshArraysSUN'))($mode, $first, $count, $width);
}

function glDrawPixels(int $width, int $height, int $format, int $type, $pixels) {
  static $proc;
  return ($proc ??= GL::getProcAddress('drawPixels'))($width, $height, $format, $type, $pixels);
}

function glDrawRangeElementArrayAPPLE(int $mode, int $start, int $end, int $first, int $count) {
  static $proc;
  return ($proc ??= GL::getProcAddress('drawRangeElementArrayAPPLE'))($mode, $start, $end, $first, $count);
}

function glDrawRangeElementArrayATI(int $mode, int $start, int $end, int $count) {
  static $proc;
  return ($proc ??= GL::getProcAddress('drawRangeElementArrayATI'))($mode, $start, $end, $count);
}

function glDrawRangeElements(int $mode, int $start, int $end, int $count, int $type, $indices) {
  static $proc;
  return ($proc ??= GL::getProcAddress('drawRangeElements'))($mode, $start, $end, $count, $type, $indices);
}

function glDrawRangeElementsBaseVertex(int $mode, int $start, int $end, int $count, int $type, $indices, int $basevertex) {
  static $proc;
  return ($proc ??= GL::getProcAddress('drawRangeElementsBaseVertex'))($mode, $start, $end, $count, $type, $indices, $basevertex);
}

function glDrawRangeElementsBaseVertexEXT(int $mode, int $start, int $end, int $count, int $type, $indices, int $basevertex) {
  static $proc;
  return ($proc ??= GL::getProcAddress('drawRangeElementsBaseVertexEXT'))($mode, $start, $end, $count, $type, $indices, $basevertex);
}

function glDrawRangeElementsBaseVertexOES(int $mode, int $start, int $end, int $count, int $type, $indices, int $basevertex) {
  static $proc;
  return ($proc ??= GL::getProcAddress('drawRangeElementsBaseVertexOES'))($mode, $start, $end, $count, $type, $indices, $basevertex);
}

function glDrawRangeElementsEXT(int $mode, int $start, int $end, int $count, int $type, $indices) {
  static $proc;
  return ($proc ??= GL::getProcAddress('drawRangeElementsEXT'))($mode, $start, $end, $count, $type, $indices);
}

function glDrawTexfOES(float $x, float $y, float $z, float $width, float $height) {
  static $proc;
  return ($proc ??= GL::getProcAddress('drawTexfOES'))($x, $y, $z, $width, $height);
}

function glDrawTexfvOES($coords) {
  static $proc;
  return ($proc ??= GL::getProcAddress('drawTexfvOES'))($coords);
}

function glDrawTexiOES(int $x, int $y, int $z, int $width, int $height) {
  static $proc;
  return ($proc ??= GL::getProcAddress('drawTexiOES'))($x, $y, $z, $width, $height);
}

function glDrawTexivOES($coords) {
  static $proc;
  return ($proc ??= GL::getProcAddress('drawTexivOES'))($coords);
}

function glDrawTexsOES(int $x, int $y, int $z, int $width, int $height) {
  static $proc;
  return ($proc ??= GL::getProcAddress('drawTexsOES'))($x, $y, $z, $width, $height);
}

function glDrawTexsvOES($coords) {
  static $proc;
  return ($proc ??= GL::getProcAddress('drawTexsvOES'))($coords);
}

function glDrawTextureNV(int $texture, int $sampler, float $x0, float $y0, float $x1, float $y1, float $z, float $s0, float $t0, float $s1, float $t1) {
  static $proc;
  return ($proc ??= GL::getProcAddress('drawTextureNV'))($texture, $sampler, $x0, $y0, $x1, $y1, $z, $s0, $t0, $s1, $t1);
}

function glDrawTexxOES(int $x, int $y, int $z, int $width, int $height) {
  static $proc;
  return ($proc ??= GL::getProcAddress('drawTexxOES'))($x, $y, $z, $width, $height);
}

function glDrawTexxvOES($coords) {
  static $proc;
  return ($proc ??= GL::getProcAddress('drawTexxvOES'))($coords);
}

function glDrawTransformFeedback(int $mode, int $id) {
  static $proc;
  return ($proc ??= GL::getProcAddress('drawTransformFeedback'))($mode, $id);
}

function glDrawTransformFeedbackEXT(int $mode, int $id) {
  static $proc;
  return ($proc ??= GL::getProcAddress('drawTransformFeedbackEXT'))($mode, $id);
}

function glDrawTransformFeedbackInstanced(int $mode, int $id, int $instancecount) {
  static $proc;
  return ($proc ??= GL::getProcAddress('drawTransformFeedbackInstanced'))($mode, $id, $instancecount);
}

function glDrawTransformFeedbackInstancedEXT(int $mode, int $id, int $instancecount) {
  static $proc;
  return ($proc ??= GL::getProcAddress('drawTransformFeedbackInstancedEXT'))($mode, $id, $instancecount);
}

function glDrawTransformFeedbackNV(int $mode, int $id) {
  static $proc;
  return ($proc ??= GL::getProcAddress('drawTransformFeedbackNV'))($mode, $id);
}

function glDrawTransformFeedbackStream(int $mode, int $id, int $stream) {
  static $proc;
  return ($proc ??= GL::getProcAddress('drawTransformFeedbackStream'))($mode, $id, $stream);
}

function glDrawTransformFeedbackStreamInstanced(int $mode, int $id, int $stream, int $instancecount) {
  static $proc;
  return ($proc ??= GL::getProcAddress('drawTransformFeedbackStreamInstanced'))($mode, $id, $stream, $instancecount);
}

function glEGLImageTargetRenderbufferStorageOES(int $target, int $image) {
  static $proc;
  return ($proc ??= GL::getProcAddress('eGLImageTargetRenderbufferStorageOES'))($target, $image);
}

function glEGLImageTargetTexture2DOES(int $target, int $image) {
  static $proc;
  return ($proc ??= GL::getProcAddress('eGLImageTargetTexture2DOES'))($target, $image);
}

function glEdgeFlag(int $flag) {
  static $proc;
  return ($proc ??= GL::getProcAddress('edgeFlag'))($flag);
}

function glEdgeFlagFormatNV(int $stride) {
  static $proc;
  return ($proc ??= GL::getProcAddress('edgeFlagFormatNV'))($stride);
}

function glEdgeFlagPointer(int $stride, $pointer) {
  static $proc;
  return ($proc ??= GL::getProcAddress('edgeFlagPointer'))($stride, $pointer);
}

function glEdgeFlagPointerEXT(int $stride, int $count, $pointer) {
  static $proc;
  return ($proc ??= GL::getProcAddress('edgeFlagPointerEXT'))($stride, $count, $pointer);
}

function glEdgeFlagPointerListIBM(int $stride, $pointer, int $ptrstride) {
  static $proc;
  return ($proc ??= GL::getProcAddress('edgeFlagPointerListIBM'))($stride, $pointer, $ptrstride);
}

function glEdgeFlagv($flag) {
  static $proc;
  return ($proc ??= GL::getProcAddress('edgeFlagv'))($flag);
}

function glElementPointerAPPLE(int $type, $pointer) {
  static $proc;
  return ($proc ??= GL::getProcAddress('elementPointerAPPLE'))($type, $pointer);
}

function glElementPointerATI(int $type, $pointer) {
  static $proc;
  return ($proc ??= GL::getProcAddress('elementPointerATI'))($type, $pointer);
}

function glEnable(int $cap) {
  static $proc;
  return ($proc ??= GL::getProcAddress('enable'))($cap);
}

function glEnableClientState(int $array) {
  static $proc;
  return ($proc ??= GL::getProcAddress('enableClientState'))($array);
}

function glEnableClientStateIndexedEXT(int $array, int $index) {
  static $proc;
  return ($proc ??= GL::getProcAddress('enableClientStateIndexedEXT'))($array, $index);
}

function glEnableClientStateiEXT(int $array, int $index) {
  static $proc;
  return ($proc ??= GL::getProcAddress('enableClientStateiEXT'))($array, $index);
}

function glEnableDriverControlQCOM(int $driverControl) {
  static $proc;
  return ($proc ??= GL::getProcAddress('enableDriverControlQCOM'))($driverControl);
}

function glEnableIndexedEXT(int $target, int $index) {
  static $proc;
  return ($proc ??= GL::getProcAddress('enableIndexedEXT'))($target, $index);
}

function glEnableVariantClientStateEXT(int $id) {
  static $proc;
  return ($proc ??= GL::getProcAddress('enableVariantClientStateEXT'))($id);
}

function glEnableVertexArrayAttrib(int $vaobj, int $index) {
  static $proc;
  return ($proc ??= GL::getProcAddress('enableVertexArrayAttrib'))($vaobj, $index);
}

function glEnableVertexArrayAttribEXT(int $vaobj, int $index) {
  static $proc;
  return ($proc ??= GL::getProcAddress('enableVertexArrayAttribEXT'))($vaobj, $index);
}

function glEnableVertexArrayEXT(int $vaobj, int $array) {
  static $proc;
  return ($proc ??= GL::getProcAddress('enableVertexArrayEXT'))($vaobj, $array);
}

function glEnableVertexAttribAPPLE(int $index, int $pname) {
  static $proc;
  return ($proc ??= GL::getProcAddress('enableVertexAttribAPPLE'))($index, $pname);
}

function glEnableVertexAttribArray(int $index) {
  static $proc;
  return ($proc ??= GL::getProcAddress('enableVertexAttribArray'))($index);
}

function glEnableVertexAttribArrayARB(int $index) {
  static $proc;
  return ($proc ??= GL::getProcAddress('enableVertexAttribArrayARB'))($index);
}

function glEnablei(int $target, int $index) {
  static $proc;
  return ($proc ??= GL::getProcAddress('enablei'))($target, $index);
}

function glEnableiEXT(int $target, int $index) {
  static $proc;
  return ($proc ??= GL::getProcAddress('enableiEXT'))($target, $index);
}

function glEnableiNV(int $target, int $index) {
  static $proc;
  return ($proc ??= GL::getProcAddress('enableiNV'))($target, $index);
}

function glEnableiOES(int $target, int $index) {
  static $proc;
  return ($proc ??= GL::getProcAddress('enableiOES'))($target, $index);
}

function glEnd() {
  static $proc;
  return ($proc ??= GL::getProcAddress('end'))();
}

function glEndConditionalRender() {
  static $proc;
  return ($proc ??= GL::getProcAddress('endConditionalRender'))();
}

function glEndConditionalRenderNV() {
  static $proc;
  return ($proc ??= GL::getProcAddress('endConditionalRenderNV'))();
}

function glEndConditionalRenderNVX() {
  static $proc;
  return ($proc ??= GL::getProcAddress('endConditionalRenderNVX'))();
}

function glEndFragmentShaderATI() {
  static $proc;
  return ($proc ??= GL::getProcAddress('endFragmentShaderATI'))();
}

function glEndList() {
  static $proc;
  return ($proc ??= GL::getProcAddress('endList'))();
}

function glEndOcclusionQueryNV() {
  static $proc;
  return ($proc ??= GL::getProcAddress('endOcclusionQueryNV'))();
}

function glEndPerfMonitorAMD(int $monitor) {
  static $proc;
  return ($proc ??= GL::getProcAddress('endPerfMonitorAMD'))($monitor);
}

function glEndPerfQueryINTEL(int $queryHandle) {
  static $proc;
  return ($proc ??= GL::getProcAddress('endPerfQueryINTEL'))($queryHandle);
}

function glEndQuery(int $target) {
  static $proc;
  return ($proc ??= GL::getProcAddress('endQuery'))($target);
}

function glEndQueryARB(int $target) {
  static $proc;
  return ($proc ??= GL::getProcAddress('endQueryARB'))($target);
}

function glEndQueryEXT(int $target) {
  static $proc;
  return ($proc ??= GL::getProcAddress('endQueryEXT'))($target);
}

function glEndQueryIndexed(int $target, int $index) {
  static $proc;
  return ($proc ??= GL::getProcAddress('endQueryIndexed'))($target, $index);
}

function glEndTilingQCOM(int $preserveMask) {
  static $proc;
  return ($proc ??= GL::getProcAddress('endTilingQCOM'))($preserveMask);
}

function glEndTransformFeedback() {
  static $proc;
  return ($proc ??= GL::getProcAddress('endTransformFeedback'))();
}

function glEndTransformFeedbackEXT() {
  static $proc;
  return ($proc ??= GL::getProcAddress('endTransformFeedbackEXT'))();
}

function glEndTransformFeedbackNV() {
  static $proc;
  return ($proc ??= GL::getProcAddress('endTransformFeedbackNV'))();
}

function glEndVertexShaderEXT() {
  static $proc;
  return ($proc ??= GL::getProcAddress('endVertexShaderEXT'))();
}

function glEndVideoCaptureNV(int $video_capture_slot) {
  static $proc;
  return ($proc ??= GL::getProcAddress('endVideoCaptureNV'))($video_capture_slot);
}

function glEvalCoord1d(float $u) {
  static $proc;
  return ($proc ??= GL::getProcAddress('evalCoord1d'))($u);
}

function glEvalCoord1dv($u) {
  static $proc;
  return ($proc ??= GL::getProcAddress('evalCoord1dv'))($u);
}

function glEvalCoord1f(float $u) {
  static $proc;
  return ($proc ??= GL::getProcAddress('evalCoord1f'))($u);
}

function glEvalCoord1fv($u) {
  static $proc;
  return ($proc ??= GL::getProcAddress('evalCoord1fv'))($u);
}

function glEvalCoord1xOES(int $u) {
  static $proc;
  return ($proc ??= GL::getProcAddress('evalCoord1xOES'))($u);
}

function glEvalCoord1xvOES($coords) {
  static $proc;
  return ($proc ??= GL::getProcAddress('evalCoord1xvOES'))($coords);
}

function glEvalCoord2d(float $u, float $v) {
  static $proc;
  return ($proc ??= GL::getProcAddress('evalCoord2d'))($u, $v);
}

function glEvalCoord2dv($u) {
  static $proc;
  return ($proc ??= GL::getProcAddress('evalCoord2dv'))($u);
}

function glEvalCoord2f(float $u, float $v) {
  static $proc;
  return ($proc ??= GL::getProcAddress('evalCoord2f'))($u, $v);
}

function glEvalCoord2fv($u) {
  static $proc;
  return ($proc ??= GL::getProcAddress('evalCoord2fv'))($u);
}

function glEvalCoord2xOES(int $u, int $v) {
  static $proc;
  return ($proc ??= GL::getProcAddress('evalCoord2xOES'))($u, $v);
}

function glEvalCoord2xvOES($coords) {
  static $proc;
  return ($proc ??= GL::getProcAddress('evalCoord2xvOES'))($coords);
}

function glEvalMapsNV(int $target, int $mode) {
  static $proc;
  return ($proc ??= GL::getProcAddress('evalMapsNV'))($target, $mode);
}

function glEvalMesh1(int $mode, int $i1, int $i2) {
  static $proc;
  return ($proc ??= GL::getProcAddress('evalMesh1'))($mode, $i1, $i2);
}

function glEvalMesh2(int $mode, int $i1, int $i2, int $j1, int $j2) {
  static $proc;
  return ($proc ??= GL::getProcAddress('evalMesh2'))($mode, $i1, $i2, $j1, $j2);
}

function glEvalPoint1(int $i) {
  static $proc;
  return ($proc ??= GL::getProcAddress('evalPoint1'))($i);
}

function glEvalPoint2(int $i, int $j) {
  static $proc;
  return ($proc ??= GL::getProcAddress('evalPoint2'))($i, $j);
}

function glEvaluateDepthValuesARB() {
  static $proc;
  return ($proc ??= GL::getProcAddress('evaluateDepthValuesARB'))();
}

function glExecuteProgramNV(int $target, int $id, $params) {
  static $proc;
  return ($proc ??= GL::getProcAddress('executeProgramNV'))($target, $id, $params);
}

function glExtGetBufferPointervQCOM(int $target, $params) {
  static $proc;
  return ($proc ??= GL::getProcAddress('extGetBufferPointervQCOM'))($target, $params);
}

function glExtGetBuffersQCOM($buffers, int $maxBuffers, $numBuffers) {
  static $proc;
  return ($proc ??= GL::getProcAddress('extGetBuffersQCOM'))($buffers, $maxBuffers, $numBuffers);
}

function glExtGetFramebuffersQCOM($framebuffers, int $maxFramebuffers, $numFramebuffers) {
  static $proc;
  return ($proc ??= GL::getProcAddress('extGetFramebuffersQCOM'))($framebuffers, $maxFramebuffers, $numFramebuffers);
}

function glExtGetProgramBinarySourceQCOM(int $program, int $shadertype, $source, $length) {
  static $proc;
  return ($proc ??= GL::getProcAddress('extGetProgramBinarySourceQCOM'))($program, $shadertype, $source, $length);
}

function glExtGetProgramsQCOM($programs, int $maxPrograms, $numPrograms) {
  static $proc;
  return ($proc ??= GL::getProcAddress('extGetProgramsQCOM'))($programs, $maxPrograms, $numPrograms);
}

function glExtGetRenderbuffersQCOM($renderbuffers, int $maxRenderbuffers, $numRenderbuffers) {
  static $proc;
  return ($proc ??= GL::getProcAddress('extGetRenderbuffersQCOM'))($renderbuffers, $maxRenderbuffers, $numRenderbuffers);
}

function glExtGetShadersQCOM($shaders, int $maxShaders, $numShaders) {
  static $proc;
  return ($proc ??= GL::getProcAddress('extGetShadersQCOM'))($shaders, $maxShaders, $numShaders);
}

function glExtGetTexLevelParameterivQCOM(int $texture, int $face, int $level, int $pname, $params) {
  static $proc;
  return ($proc ??= GL::getProcAddress('extGetTexLevelParameterivQCOM'))($texture, $face, $level, $pname, $params);
}

function glExtGetTexSubImageQCOM(int $target, int $level, int $xoffset, int $yoffset, int $zoffset, int $width, int $height, int $depth, int $format, int $type, $texels) {
  static $proc;
  return ($proc ??= GL::getProcAddress('extGetTexSubImageQCOM'))($target, $level, $xoffset, $yoffset, $zoffset, $width, $height, $depth, $format, $type, $texels);
}

function glExtGetTexturesQCOM($textures, int $maxTextures, $numTextures) {
  static $proc;
  return ($proc ??= GL::getProcAddress('extGetTexturesQCOM'))($textures, $maxTextures, $numTextures);
}

function glExtIsProgramBinaryQCOM(int $program) {
  static $proc;
  return ($proc ??= GL::getProcAddress('extIsProgramBinaryQCOM'))($program);
}

function glExtTexObjectStateOverrideiQCOM(int $target, int $pname, int $param) {
  static $proc;
  return ($proc ??= GL::getProcAddress('extTexObjectStateOverrideiQCOM'))($target, $pname, $param);
}

function glExtractComponentEXT(int $res, int $src, int $num) {
  static $proc;
  return ($proc ??= GL::getProcAddress('extractComponentEXT'))($res, $src, $num);
}

function glFeedbackBuffer(int $size, int $type, $buffer) {
  static $proc;
  return ($proc ??= GL::getProcAddress('feedbackBuffer'))($size, $type, $buffer);
}

function glFeedbackBufferxOES(int $n, int $type, $buffer) {
  static $proc;
  return ($proc ??= GL::getProcAddress('feedbackBufferxOES'))($n, $type, $buffer);
}

function glFenceSync(int $condition, int $flags) {
  static $proc;
  return ($proc ??= GL::getProcAddress('fenceSync'))($condition, $flags);
}

function glFenceSyncAPPLE(int $condition, int $flags) {
  static $proc;
  return ($proc ??= GL::getProcAddress('fenceSyncAPPLE'))($condition, $flags);
}

function glFinalCombinerInputNV(int $variable, int $input, int $mapping, int $componentUsage) {
  static $proc;
  return ($proc ??= GL::getProcAddress('finalCombinerInputNV'))($variable, $input, $mapping, $componentUsage);
}

function glFinish() {
  static $proc;
  return ($proc ??= GL::getProcAddress('finish'))();
}

function glFinishAsyncSGIX($markerp) {
  static $proc;
  return ($proc ??= GL::getProcAddress('finishAsyncSGIX'))($markerp);
}

function glFinishFenceAPPLE(int $fence) {
  static $proc;
  return ($proc ??= GL::getProcAddress('finishFenceAPPLE'))($fence);
}

function glFinishFenceNV(int $fence) {
  static $proc;
  return ($proc ??= GL::getProcAddress('finishFenceNV'))($fence);
}

function glFinishObjectAPPLE(int $object, int $name) {
  static $proc;
  return ($proc ??= GL::getProcAddress('finishObjectAPPLE'))($object, $name);
}

function glFinishTextureSUNX() {
  static $proc;
  return ($proc ??= GL::getProcAddress('finishTextureSUNX'))();
}

function glFlush() {
  static $proc;
  return ($proc ??= GL::getProcAddress('flush'))();
}

function glFlushMappedBufferRange(int $target, int $offset, int $length) {
  static $proc;
  return ($proc ??= GL::getProcAddress('flushMappedBufferRange'))($target, $offset, $length);
}

function glFlushMappedBufferRangeAPPLE(int $target, int $offset, int $size) {
  static $proc;
  return ($proc ??= GL::getProcAddress('flushMappedBufferRangeAPPLE'))($target, $offset, $size);
}

function glFlushMappedBufferRangeEXT(int $target, int $offset, int $length) {
  static $proc;
  return ($proc ??= GL::getProcAddress('flushMappedBufferRangeEXT'))($target, $offset, $length);
}

function glFlushMappedNamedBufferRange(int $buffer, int $offset, int $length) {
  static $proc;
  return ($proc ??= GL::getProcAddress('flushMappedNamedBufferRange'))($buffer, $offset, $length);
}

function glFlushMappedNamedBufferRangeEXT(int $buffer, int $offset, int $length) {
  static $proc;
  return ($proc ??= GL::getProcAddress('flushMappedNamedBufferRangeEXT'))($buffer, $offset, $length);
}

function glFlushPixelDataRangeNV(int $target) {
  static $proc;
  return ($proc ??= GL::getProcAddress('flushPixelDataRangeNV'))($target);
}

function glFlushRasterSGIX() {
  static $proc;
  return ($proc ??= GL::getProcAddress('flushRasterSGIX'))();
}

function glFlushStaticDataIBM(int $target) {
  static $proc;
  return ($proc ??= GL::getProcAddress('flushStaticDataIBM'))($target);
}

function glFlushVertexArrayRangeAPPLE(int $length, $pointer) {
  static $proc;
  return ($proc ??= GL::getProcAddress('flushVertexArrayRangeAPPLE'))($length, $pointer);
}

function glFlushVertexArrayRangeNV() {
  static $proc;
  return ($proc ??= GL::getProcAddress('flushVertexArrayRangeNV'))();
}

function glFogCoordFormatNV(int $type, int $stride) {
  static $proc;
  return ($proc ??= GL::getProcAddress('fogCoordFormatNV'))($type, $stride);
}

function glFogCoordPointer(int $type, int $stride, $pointer) {
  static $proc;
  return ($proc ??= GL::getProcAddress('fogCoordPointer'))($type, $stride, $pointer);
}

function glFogCoordPointerEXT(int $type, int $stride, $pointer) {
  static $proc;
  return ($proc ??= GL::getProcAddress('fogCoordPointerEXT'))($type, $stride, $pointer);
}

function glFogCoordPointerListIBM(int $type, int $stride, $pointer, int $ptrstride) {
  static $proc;
  return ($proc ??= GL::getProcAddress('fogCoordPointerListIBM'))($type, $stride, $pointer, $ptrstride);
}

function glFogCoordd(float $coord) {
  static $proc;
  return ($proc ??= GL::getProcAddress('fogCoordd'))($coord);
}

function glFogCoorddEXT(float $coord) {
  static $proc;
  return ($proc ??= GL::getProcAddress('fogCoorddEXT'))($coord);
}

function glFogCoorddv($coord) {
  static $proc;
  return ($proc ??= GL::getProcAddress('fogCoorddv'))($coord);
}

function glFogCoorddvEXT($coord) {
  static $proc;
  return ($proc ??= GL::getProcAddress('fogCoorddvEXT'))($coord);
}

function glFogCoordf(float $coord) {
  static $proc;
  return ($proc ??= GL::getProcAddress('fogCoordf'))($coord);
}

function glFogCoordfEXT(float $coord) {
  static $proc;
  return ($proc ??= GL::getProcAddress('fogCoordfEXT'))($coord);
}

function glFogCoordfv($coord) {
  static $proc;
  return ($proc ??= GL::getProcAddress('fogCoordfv'))($coord);
}

function glFogCoordfvEXT($coord) {
  static $proc;
  return ($proc ??= GL::getProcAddress('fogCoordfvEXT'))($coord);
}

function glFogCoordhNV(int $fog) {
  static $proc;
  return ($proc ??= GL::getProcAddress('fogCoordhNV'))($fog);
}

function glFogCoordhvNV($fog) {
  static $proc;
  return ($proc ??= GL::getProcAddress('fogCoordhvNV'))($fog);
}

function glFogFuncSGIS(int $n, $points) {
  static $proc;
  return ($proc ??= GL::getProcAddress('fogFuncSGIS'))($n, $points);
}

function glFogf(int $pname, float $param) {
  static $proc;
  return ($proc ??= GL::getProcAddress('fogf'))($pname, $param);
}

function glFogfv(int $pname, $params) {
  static $proc;
  return ($proc ??= GL::getProcAddress('fogfv'))($pname, $params);
}

function glFogi(int $pname, int $param) {
  static $proc;
  return ($proc ??= GL::getProcAddress('fogi'))($pname, $param);
}

function glFogiv(int $pname, $params) {
  static $proc;
  return ($proc ??= GL::getProcAddress('fogiv'))($pname, $params);
}

function glFogx(int $pname, int $param) {
  static $proc;
  return ($proc ??= GL::getProcAddress('fogx'))($pname, $param);
}

function glFogxOES(int $pname, int $param) {
  static $proc;
  return ($proc ??= GL::getProcAddress('fogxOES'))($pname, $param);
}

function glFogxv(int $pname, $param) {
  static $proc;
  return ($proc ??= GL::getProcAddress('fogxv'))($pname, $param);
}

function glFogxvOES(int $pname, $param) {
  static $proc;
  return ($proc ??= GL::getProcAddress('fogxvOES'))($pname, $param);
}

function glFragmentColorMaterialSGIX(int $face, int $mode) {
  static $proc;
  return ($proc ??= GL::getProcAddress('fragmentColorMaterialSGIX'))($face, $mode);
}

function glFragmentCoverageColorNV(int $color) {
  static $proc;
  return ($proc ??= GL::getProcAddress('fragmentCoverageColorNV'))($color);
}

function glFragmentLightModelfSGIX(int $pname, float $param) {
  static $proc;
  return ($proc ??= GL::getProcAddress('fragmentLightModelfSGIX'))($pname, $param);
}

function glFragmentLightModelfvSGIX(int $pname, $params) {
  static $proc;
  return ($proc ??= GL::getProcAddress('fragmentLightModelfvSGIX'))($pname, $params);
}

function glFragmentLightModeliSGIX(int $pname, int $param) {
  static $proc;
  return ($proc ??= GL::getProcAddress('fragmentLightModeliSGIX'))($pname, $param);
}

function glFragmentLightModelivSGIX(int $pname, $params) {
  static $proc;
  return ($proc ??= GL::getProcAddress('fragmentLightModelivSGIX'))($pname, $params);
}

function glFragmentLightfSGIX(int $light, int $pname, float $param) {
  static $proc;
  return ($proc ??= GL::getProcAddress('fragmentLightfSGIX'))($light, $pname, $param);
}

function glFragmentLightfvSGIX(int $light, int $pname, $params) {
  static $proc;
  return ($proc ??= GL::getProcAddress('fragmentLightfvSGIX'))($light, $pname, $params);
}

function glFragmentLightiSGIX(int $light, int $pname, int $param) {
  static $proc;
  return ($proc ??= GL::getProcAddress('fragmentLightiSGIX'))($light, $pname, $param);
}

function glFragmentLightivSGIX(int $light, int $pname, $params) {
  static $proc;
  return ($proc ??= GL::getProcAddress('fragmentLightivSGIX'))($light, $pname, $params);
}

function glFragmentMaterialfSGIX(int $face, int $pname, float $param) {
  static $proc;
  return ($proc ??= GL::getProcAddress('fragmentMaterialfSGIX'))($face, $pname, $param);
}

function glFragmentMaterialfvSGIX(int $face, int $pname, $params) {
  static $proc;
  return ($proc ??= GL::getProcAddress('fragmentMaterialfvSGIX'))($face, $pname, $params);
}

function glFragmentMaterialiSGIX(int $face, int $pname, int $param) {
  static $proc;
  return ($proc ??= GL::getProcAddress('fragmentMaterialiSGIX'))($face, $pname, $param);
}

function glFragmentMaterialivSGIX(int $face, int $pname, $params) {
  static $proc;
  return ($proc ??= GL::getProcAddress('fragmentMaterialivSGIX'))($face, $pname, $params);
}

function glFrameTerminatorGREMEDY() {
  static $proc;
  return ($proc ??= GL::getProcAddress('frameTerminatorGREMEDY'))();
}

function glFrameZoomSGIX(int $factor) {
  static $proc;
  return ($proc ??= GL::getProcAddress('frameZoomSGIX'))($factor);
}

function glFramebufferDrawBufferEXT(int $framebuffer, int $mode) {
  static $proc;
  return ($proc ??= GL::getProcAddress('framebufferDrawBufferEXT'))($framebuffer, $mode);
}

function glFramebufferDrawBuffersEXT(int $framebuffer, int $n, $bufs) {
  static $proc;
  return ($proc ??= GL::getProcAddress('framebufferDrawBuffersEXT'))($framebuffer, $n, $bufs);
}

function glFramebufferParameteri(int $target, int $pname, int $param) {
  static $proc;
  return ($proc ??= GL::getProcAddress('framebufferParameteri'))($target, $pname, $param);
}

function glFramebufferPixelLocalStorageSizeEXT(int $target, int $size) {
  static $proc;
  return ($proc ??= GL::getProcAddress('framebufferPixelLocalStorageSizeEXT'))($target, $size);
}

function glFramebufferReadBufferEXT(int $framebuffer, int $mode) {
  static $proc;
  return ($proc ??= GL::getProcAddress('framebufferReadBufferEXT'))($framebuffer, $mode);
}

function glFramebufferRenderbuffer(int $target, int $attachment, int $renderbuffertarget, int $renderbuffer) {
  static $proc;
  return ($proc ??= GL::getProcAddress('framebufferRenderbuffer'))($target, $attachment, $renderbuffertarget, $renderbuffer);
}

function glFramebufferRenderbufferEXT(int $target, int $attachment, int $renderbuffertarget, int $renderbuffer) {
  static $proc;
  return ($proc ??= GL::getProcAddress('framebufferRenderbufferEXT'))($target, $attachment, $renderbuffertarget, $renderbuffer);
}

function glFramebufferRenderbufferOES(int $target, int $attachment, int $renderbuffertarget, int $renderbuffer) {
  static $proc;
  return ($proc ??= GL::getProcAddress('framebufferRenderbufferOES'))($target, $attachment, $renderbuffertarget, $renderbuffer);
}

function glFramebufferSampleLocationsfvARB(int $target, int $start, int $count, $v) {
  static $proc;
  return ($proc ??= GL::getProcAddress('framebufferSampleLocationsfvARB'))($target, $start, $count, $v);
}

function glFramebufferSampleLocationsfvNV(int $target, int $start, int $count, $v) {
  static $proc;
  return ($proc ??= GL::getProcAddress('framebufferSampleLocationsfvNV'))($target, $start, $count, $v);
}

function glFramebufferSamplePositionsfvAMD(int $target, int $numsamples, int $pixelindex, $values) {
  static $proc;
  return ($proc ??= GL::getProcAddress('framebufferSamplePositionsfvAMD'))($target, $numsamples, $pixelindex, $values);
}

function glFramebufferTexture(int $target, int $attachment, int $texture, int $level) {
  static $proc;
  return ($proc ??= GL::getProcAddress('framebufferTexture'))($target, $attachment, $texture, $level);
}

function glFramebufferTexture1D(int $target, int $attachment, int $textarget, int $texture, int $level) {
  static $proc;
  return ($proc ??= GL::getProcAddress('framebufferTexture1D'))($target, $attachment, $textarget, $texture, $level);
}

function glFramebufferTexture1DEXT(int $target, int $attachment, int $textarget, int $texture, int $level) {
  static $proc;
  return ($proc ??= GL::getProcAddress('framebufferTexture1DEXT'))($target, $attachment, $textarget, $texture, $level);
}

function glFramebufferTexture2D(int $target, int $attachment, int $textarget, int $texture, int $level) {
  static $proc;
  return ($proc ??= GL::getProcAddress('framebufferTexture2D'))($target, $attachment, $textarget, $texture, $level);
}

function glFramebufferTexture2DEXT(int $target, int $attachment, int $textarget, int $texture, int $level) {
  static $proc;
  return ($proc ??= GL::getProcAddress('framebufferTexture2DEXT'))($target, $attachment, $textarget, $texture, $level);
}

function glFramebufferTexture2DDownsampleIMG(int $target, int $attachment, int $textarget, int $texture, int $level, int $xscale, int $yscale) {
  static $proc;
  return ($proc ??= GL::getProcAddress('framebufferTexture2DDownsampleIMG'))($target, $attachment, $textarget, $texture, $level, $xscale, $yscale);
}

function glFramebufferTexture2DMultisampleEXT(int $target, int $attachment, int $textarget, int $texture, int $level, int $samples) {
  static $proc;
  return ($proc ??= GL::getProcAddress('framebufferTexture2DMultisampleEXT'))($target, $attachment, $textarget, $texture, $level, $samples);
}

function glFramebufferTexture2DMultisampleIMG(int $target, int $attachment, int $textarget, int $texture, int $level, int $samples) {
  static $proc;
  return ($proc ??= GL::getProcAddress('framebufferTexture2DMultisampleIMG'))($target, $attachment, $textarget, $texture, $level, $samples);
}

function glFramebufferTexture2DOES(int $target, int $attachment, int $textarget, int $texture, int $level) {
  static $proc;
  return ($proc ??= GL::getProcAddress('framebufferTexture2DOES'))($target, $attachment, $textarget, $texture, $level);
}

function glFramebufferTexture3D(int $target, int $attachment, int $textarget, int $texture, int $level, int $zoffset) {
  static $proc;
  return ($proc ??= GL::getProcAddress('framebufferTexture3D'))($target, $attachment, $textarget, $texture, $level, $zoffset);
}

function glFramebufferTexture3DEXT(int $target, int $attachment, int $textarget, int $texture, int $level, int $zoffset) {
  static $proc;
  return ($proc ??= GL::getProcAddress('framebufferTexture3DEXT'))($target, $attachment, $textarget, $texture, $level, $zoffset);
}

function glFramebufferTexture3DOES(int $target, int $attachment, int $textarget, int $texture, int $level, int $zoffset) {
  static $proc;
  return ($proc ??= GL::getProcAddress('framebufferTexture3DOES'))($target, $attachment, $textarget, $texture, $level, $zoffset);
}

function glFramebufferTextureARB(int $target, int $attachment, int $texture, int $level) {
  static $proc;
  return ($proc ??= GL::getProcAddress('framebufferTextureARB'))($target, $attachment, $texture, $level);
}

function glFramebufferTextureEXT(int $target, int $attachment, int $texture, int $level) {
  static $proc;
  return ($proc ??= GL::getProcAddress('framebufferTextureEXT'))($target, $attachment, $texture, $level);
}

function glFramebufferTextureFaceARB(int $target, int $attachment, int $texture, int $level, int $face) {
  static $proc;
  return ($proc ??= GL::getProcAddress('framebufferTextureFaceARB'))($target, $attachment, $texture, $level, $face);
}

function glFramebufferTextureFaceEXT(int $target, int $attachment, int $texture, int $level, int $face) {
  static $proc;
  return ($proc ??= GL::getProcAddress('framebufferTextureFaceEXT'))($target, $attachment, $texture, $level, $face);
}

function glFramebufferTextureLayer(int $target, int $attachment, int $texture, int $level, int $layer) {
  static $proc;
  return ($proc ??= GL::getProcAddress('framebufferTextureLayer'))($target, $attachment, $texture, $level, $layer);
}

function glFramebufferTextureLayerARB(int $target, int $attachment, int $texture, int $level, int $layer) {
  static $proc;
  return ($proc ??= GL::getProcAddress('framebufferTextureLayerARB'))($target, $attachment, $texture, $level, $layer);
}

function glFramebufferTextureLayerEXT(int $target, int $attachment, int $texture, int $level, int $layer) {
  static $proc;
  return ($proc ??= GL::getProcAddress('framebufferTextureLayerEXT'))($target, $attachment, $texture, $level, $layer);
}

function glFramebufferTextureLayerDownsampleIMG(int $target, int $attachment, int $texture, int $level, int $layer, int $xscale, int $yscale) {
  static $proc;
  return ($proc ??= GL::getProcAddress('framebufferTextureLayerDownsampleIMG'))($target, $attachment, $texture, $level, $layer, $xscale, $yscale);
}

function glFramebufferTextureMultisampleMultiviewOVR(int $target, int $attachment, int $texture, int $level, int $samples, int $baseViewIndex, int $numViews) {
  static $proc;
  return ($proc ??= GL::getProcAddress('framebufferTextureMultisampleMultiviewOVR'))($target, $attachment, $texture, $level, $samples, $baseViewIndex, $numViews);
}

function glFramebufferTextureMultiviewOVR(int $target, int $attachment, int $texture, int $level, int $baseViewIndex, int $numViews) {
  static $proc;
  return ($proc ??= GL::getProcAddress('framebufferTextureMultiviewOVR'))($target, $attachment, $texture, $level, $baseViewIndex, $numViews);
}

function glFramebufferTextureOES(int $target, int $attachment, int $texture, int $level) {
  static $proc;
  return ($proc ??= GL::getProcAddress('framebufferTextureOES'))($target, $attachment, $texture, $level);
}

function glFreeObjectBufferATI(int $buffer) {
  static $proc;
  return ($proc ??= GL::getProcAddress('freeObjectBufferATI'))($buffer);
}

function glFrontFace(int $mode) {
  static $proc;
  return ($proc ??= GL::getProcAddress('frontFace'))($mode);
}

function glFrustum(float $left, float $right, float $bottom, float $top, float $zNear, float $zFar) {
  static $proc;
  return ($proc ??= GL::getProcAddress('frustum'))($left, $right, $bottom, $top, $zNear, $zFar);
}

function glFrustumf(float $l, float $r, float $b, float $t, float $n, float $f) {
  static $proc;
  return ($proc ??= GL::getProcAddress('frustumf'))($l, $r, $b, $t, $n, $f);
}

function glFrustumfOES(float $l, float $r, float $b, float $t, float $n, float $f) {
  static $proc;
  return ($proc ??= GL::getProcAddress('frustumfOES'))($l, $r, $b, $t, $n, $f);
}

function glFrustumx(int $l, int $r, int $b, int $t, int $n, int $f) {
  static $proc;
  return ($proc ??= GL::getProcAddress('frustumx'))($l, $r, $b, $t, $n, $f);
}

function glFrustumxOES(int $l, int $r, int $b, int $t, int $n, int $f) {
  static $proc;
  return ($proc ??= GL::getProcAddress('frustumxOES'))($l, $r, $b, $t, $n, $f);
}

function glGenAsyncMarkersSGIX(int $range) {
  static $proc;
  return ($proc ??= GL::getProcAddress('genAsyncMarkersSGIX'))($range);
}

function glGenBuffers(int $n, $buffers) {
  static $proc;
  return ($proc ??= GL::getProcAddress('genBuffers'))($n, $buffers);
}

function glGenBuffersARB(int $n, $buffers) {
  static $proc;
  return ($proc ??= GL::getProcAddress('genBuffersARB'))($n, $buffers);
}

function glGenFencesAPPLE(int $n, $fences) {
  static $proc;
  return ($proc ??= GL::getProcAddress('genFencesAPPLE'))($n, $fences);
}

function glGenFencesNV(int $n, $fences) {
  static $proc;
  return ($proc ??= GL::getProcAddress('genFencesNV'))($n, $fences);
}

function glGenFragmentShadersATI(int $range) {
  static $proc;
  return ($proc ??= GL::getProcAddress('genFragmentShadersATI'))($range);
}

function glGenFramebuffers(int $n, $framebuffers) {
  static $proc;
  return ($proc ??= GL::getProcAddress('genFramebuffers'))($n, $framebuffers);
}

function glGenFramebuffersEXT(int $n, $framebuffers) {
  static $proc;
  return ($proc ??= GL::getProcAddress('genFramebuffersEXT'))($n, $framebuffers);
}

function glGenFramebuffersOES(int $n, $framebuffers) {
  static $proc;
  return ($proc ??= GL::getProcAddress('genFramebuffersOES'))($n, $framebuffers);
}

function glGenLists(int $range) {
  static $proc;
  return ($proc ??= GL::getProcAddress('genLists'))($range);
}

function glGenNamesAMD(int $identifier, int $num, $names) {
  static $proc;
  return ($proc ??= GL::getProcAddress('genNamesAMD'))($identifier, $num, $names);
}

function glGenOcclusionQueriesNV(int $n, $ids) {
  static $proc;
  return ($proc ??= GL::getProcAddress('genOcclusionQueriesNV'))($n, $ids);
}

function glGenPathsNV(int $range) {
  static $proc;
  return ($proc ??= GL::getProcAddress('genPathsNV'))($range);
}

function glGenPerfMonitorsAMD(int $n, $monitors) {
  static $proc;
  return ($proc ??= GL::getProcAddress('genPerfMonitorsAMD'))($n, $monitors);
}

function glGenProgramPipelines(int $n, $pipelines) {
  static $proc;
  return ($proc ??= GL::getProcAddress('genProgramPipelines'))($n, $pipelines);
}

function glGenProgramPipelinesEXT(int $n, $pipelines) {
  static $proc;
  return ($proc ??= GL::getProcAddress('genProgramPipelinesEXT'))($n, $pipelines);
}

function glGenProgramsARB(int $n, $programs) {
  static $proc;
  return ($proc ??= GL::getProcAddress('genProgramsARB'))($n, $programs);
}

function glGenProgramsNV(int $n, $programs) {
  static $proc;
  return ($proc ??= GL::getProcAddress('genProgramsNV'))($n, $programs);
}

function glGenQueries(int $n, $ids) {
  static $proc;
  return ($proc ??= GL::getProcAddress('genQueries'))($n, $ids);
}

function glGenQueriesARB(int $n, $ids) {
  static $proc;
  return ($proc ??= GL::getProcAddress('genQueriesARB'))($n, $ids);
}

function glGenQueriesEXT(int $n, $ids) {
  static $proc;
  return ($proc ??= GL::getProcAddress('genQueriesEXT'))($n, $ids);
}

function glGenRenderbuffers(int $n, $renderbuffers) {
  static $proc;
  return ($proc ??= GL::getProcAddress('genRenderbuffers'))($n, $renderbuffers);
}

function glGenRenderbuffersEXT(int $n, $renderbuffers) {
  static $proc;
  return ($proc ??= GL::getProcAddress('genRenderbuffersEXT'))($n, $renderbuffers);
}

function glGenRenderbuffersOES(int $n, $renderbuffers) {
  static $proc;
  return ($proc ??= GL::getProcAddress('genRenderbuffersOES'))($n, $renderbuffers);
}

function glGenSamplers(int $count, $samplers) {
  static $proc;
  return ($proc ??= GL::getProcAddress('genSamplers'))($count, $samplers);
}

function glGenSymbolsEXT(int $datatype, int $storagetype, int $range, int $components) {
  static $proc;
  return ($proc ??= GL::getProcAddress('genSymbolsEXT'))($datatype, $storagetype, $range, $components);
}

function glGenTextures(int $n, $textures) {
  static $proc;
  return ($proc ??= GL::getProcAddress('genTextures'))($n, $textures);
}

function glGenTexturesEXT(int $n, $textures) {
  static $proc;
  return ($proc ??= GL::getProcAddress('genTexturesEXT'))($n, $textures);
}

function glGenTransformFeedbacks(int $n, $ids) {
  static $proc;
  return ($proc ??= GL::getProcAddress('genTransformFeedbacks'))($n, $ids);
}

function glGenTransformFeedbacksNV(int $n, $ids) {
  static $proc;
  return ($proc ??= GL::getProcAddress('genTransformFeedbacksNV'))($n, $ids);
}

function glGenVertexArrays(int $n, $arrays) {
  static $proc;
  return ($proc ??= GL::getProcAddress('genVertexArrays'))($n, $arrays);
}

function glGenVertexArraysAPPLE(int $n, $arrays) {
  static $proc;
  return ($proc ??= GL::getProcAddress('genVertexArraysAPPLE'))($n, $arrays);
}

function glGenVertexArraysOES(int $n, $arrays) {
  static $proc;
  return ($proc ??= GL::getProcAddress('genVertexArraysOES'))($n, $arrays);
}

function glGenVertexShadersEXT(int $range) {
  static $proc;
  return ($proc ??= GL::getProcAddress('genVertexShadersEXT'))($range);
}

function glGenerateMipmap(int $target) {
  static $proc;
  return ($proc ??= GL::getProcAddress('generateMipmap'))($target);
}

function glGenerateMipmapEXT(int $target) {
  static $proc;
  return ($proc ??= GL::getProcAddress('generateMipmapEXT'))($target);
}

function glGenerateMipmapOES(int $target) {
  static $proc;
  return ($proc ??= GL::getProcAddress('generateMipmapOES'))($target);
}

function glGenerateMultiTexMipmapEXT(int $texunit, int $target) {
  static $proc;
  return ($proc ??= GL::getProcAddress('generateMultiTexMipmapEXT'))($texunit, $target);
}

function glGenerateTextureMipmap(int $texture) {
  static $proc;
  return ($proc ??= GL::getProcAddress('generateTextureMipmap'))($texture);
}

function glGenerateTextureMipmapEXT(int $texture, int $target) {
  static $proc;
  return ($proc ??= GL::getProcAddress('generateTextureMipmapEXT'))($texture, $target);
}

function glGetActiveAtomicCounterBufferiv(int $program, int $bufferIndex, int $pname, $params) {
  static $proc;
  return ($proc ??= GL::getProcAddress('getActiveAtomicCounterBufferiv'))($program, $bufferIndex, $pname, $params);
}

function glGetActiveAttrib(int $program, int $index, int $bufSize, $length, $size, $type, $name) {
  static $proc;
  return ($proc ??= GL::getProcAddress('getActiveAttrib'))($program, $index, $bufSize, $length, $size, $type, $name);
}

function glGetActiveAttribARB(int $programObj, int $index, int $maxLength, $length, $size, $type, $name) {
  static $proc;
  return ($proc ??= GL::getProcAddress('getActiveAttribARB'))($programObj, $index, $maxLength, $length, $size, $type, $name);
}

function glGetActiveSubroutineName(int $program, int $shadertype, int $index, int $bufsize, $length, $name) {
  static $proc;
  return ($proc ??= GL::getProcAddress('getActiveSubroutineName'))($program, $shadertype, $index, $bufsize, $length, $name);
}

function glGetActiveSubroutineUniformName(int $program, int $shadertype, int $index, int $bufsize, $length, $name) {
  static $proc;
  return ($proc ??= GL::getProcAddress('getActiveSubroutineUniformName'))($program, $shadertype, $index, $bufsize, $length, $name);
}

function glGetActiveSubroutineUniformiv(int $program, int $shadertype, int $index, int $pname, $values) {
  static $proc;
  return ($proc ??= GL::getProcAddress('getActiveSubroutineUniformiv'))($program, $shadertype, $index, $pname, $values);
}

function glGetActiveUniform(int $program, int $index, int $bufSize, $length, $size, $type, $name) {
  static $proc;
  return ($proc ??= GL::getProcAddress('getActiveUniform'))($program, $index, $bufSize, $length, $size, $type, $name);
}

function glGetActiveUniformARB(int $programObj, int $index, int $maxLength, $length, $size, $type, $name) {
  static $proc;
  return ($proc ??= GL::getProcAddress('getActiveUniformARB'))($programObj, $index, $maxLength, $length, $size, $type, $name);
}

function glGetActiveUniformBlockName(int $program, int $uniformBlockIndex, int $bufSize, $length, $uniformBlockName) {
  static $proc;
  return ($proc ??= GL::getProcAddress('getActiveUniformBlockName'))($program, $uniformBlockIndex, $bufSize, $length, $uniformBlockName);
}

function glGetActiveUniformBlockiv(int $program, int $uniformBlockIndex, int $pname, $params) {
  static $proc;
  return ($proc ??= GL::getProcAddress('getActiveUniformBlockiv'))($program, $uniformBlockIndex, $pname, $params);
}

function glGetActiveUniformName(int $program, int $uniformIndex, int $bufSize, $length, $uniformName) {
  static $proc;
  return ($proc ??= GL::getProcAddress('getActiveUniformName'))($program, $uniformIndex, $bufSize, $length, $uniformName);
}

function glGetActiveUniformsiv(int $program, int $uniformCount, $uniformIndices, int $pname, $params) {
  static $proc;
  return ($proc ??= GL::getProcAddress('getActiveUniformsiv'))($program, $uniformCount, $uniformIndices, $pname, $params);
}

function glGetActiveVaryingNV(int $program, int $index, int $bufSize, $length, $size, $type, $name) {
  static $proc;
  return ($proc ??= GL::getProcAddress('getActiveVaryingNV'))($program, $index, $bufSize, $length, $size, $type, $name);
}

function glGetArrayObjectfvATI(int $array, int $pname, $params) {
  static $proc;
  return ($proc ??= GL::getProcAddress('getArrayObjectfvATI'))($array, $pname, $params);
}

function glGetArrayObjectivATI(int $array, int $pname, $params) {
  static $proc;
  return ($proc ??= GL::getProcAddress('getArrayObjectivATI'))($array, $pname, $params);
}

function glGetAttachedObjectsARB(int $containerObj, int $maxCount, $count, $obj) {
  static $proc;
  return ($proc ??= GL::getProcAddress('getAttachedObjectsARB'))($containerObj, $maxCount, $count, $obj);
}

function glGetAttachedShaders(int $program, int $maxCount, $count, $shaders) {
  static $proc;
  return ($proc ??= GL::getProcAddress('getAttachedShaders'))($program, $maxCount, $count, $shaders);
}

function glGetAttribLocation(int $program, $name) {
  static $proc;
  return ($proc ??= GL::getProcAddress('getAttribLocation'))($program, $name);
}

function glGetAttribLocationARB(int $programObj, $name) {
  static $proc;
  return ($proc ??= GL::getProcAddress('getAttribLocationARB'))($programObj, $name);
}

function glGetBooleanIndexedvEXT(int $target, int $index, $data) {
  static $proc;
  return ($proc ??= GL::getProcAddress('getBooleanIndexedvEXT'))($target, $index, $data);
}

function glGetBooleani_v(int $target, int $index, $data) {
  static $proc;
  return ($proc ??= GL::getProcAddress('getBooleani_v'))($target, $index, $data);
}

function glGetBooleanv(int $pname, $data) {
  static $proc;
  return ($proc ??= GL::getProcAddress('getBooleanv'))($pname, $data);
}

function glGetBufferParameteri64v(int $target, int $pname, $params) {
  static $proc;
  return ($proc ??= GL::getProcAddress('getBufferParameteri64v'))($target, $pname, $params);
}

function glGetBufferParameteriv(int $target, int $pname, $params) {
  static $proc;
  return ($proc ??= GL::getProcAddress('getBufferParameteriv'))($target, $pname, $params);
}

function glGetBufferParameterivARB(int $target, int $pname, $params) {
  static $proc;
  return ($proc ??= GL::getProcAddress('getBufferParameterivARB'))($target, $pname, $params);
}

function glGetBufferParameterui64vNV(int $target, int $pname, $params) {
  static $proc;
  return ($proc ??= GL::getProcAddress('getBufferParameterui64vNV'))($target, $pname, $params);
}

function glGetBufferPointerv(int $target, int $pname, $params) {
  static $proc;
  return ($proc ??= GL::getProcAddress('getBufferPointerv'))($target, $pname, $params);
}

function glGetBufferPointervARB(int $target, int $pname, $params) {
  static $proc;
  return ($proc ??= GL::getProcAddress('getBufferPointervARB'))($target, $pname, $params);
}

function glGetBufferPointervOES(int $target, int $pname, $params) {
  static $proc;
  return ($proc ??= GL::getProcAddress('getBufferPointervOES'))($target, $pname, $params);
}

function glGetBufferSubData(int $target, int $offset, int $size, $data) {
  static $proc;
  return ($proc ??= GL::getProcAddress('getBufferSubData'))($target, $offset, $size, $data);
}

function glGetBufferSubDataARB(int $target, int $offset, int $size, $data) {
  static $proc;
  return ($proc ??= GL::getProcAddress('getBufferSubDataARB'))($target, $offset, $size, $data);
}

function glGetClipPlane(int $plane, $equation) {
  static $proc;
  return ($proc ??= GL::getProcAddress('getClipPlane'))($plane, $equation);
}

function glGetClipPlanef(int $plane, $equation) {
  static $proc;
  return ($proc ??= GL::getProcAddress('getClipPlanef'))($plane, $equation);
}

function glGetClipPlanefOES(int $plane, $equation) {
  static $proc;
  return ($proc ??= GL::getProcAddress('getClipPlanefOES'))($plane, $equation);
}

function glGetClipPlanex(int $plane, $equation) {
  static $proc;
  return ($proc ??= GL::getProcAddress('getClipPlanex'))($plane, $equation);
}

function glGetClipPlanexOES(int $plane, $equation) {
  static $proc;
  return ($proc ??= GL::getProcAddress('getClipPlanexOES'))($plane, $equation);
}

function glGetColorTable(int $target, int $format, int $type, $table) {
  static $proc;
  return ($proc ??= GL::getProcAddress('getColorTable'))($target, $format, $type, $table);
}

function glGetColorTableEXT(int $target, int $format, int $type, $data) {
  static $proc;
  return ($proc ??= GL::getProcAddress('getColorTableEXT'))($target, $format, $type, $data);
}

function glGetColorTableParameterfv(int $target, int $pname, $params) {
  static $proc;
  return ($proc ??= GL::getProcAddress('getColorTableParameterfv'))($target, $pname, $params);
}

function glGetColorTableParameterfvEXT(int $target, int $pname, $params) {
  static $proc;
  return ($proc ??= GL::getProcAddress('getColorTableParameterfvEXT'))($target, $pname, $params);
}

function glGetColorTableParameterfvSGI(int $target, int $pname, $params) {
  static $proc;
  return ($proc ??= GL::getProcAddress('getColorTableParameterfvSGI'))($target, $pname, $params);
}

function glGetColorTableParameteriv(int $target, int $pname, $params) {
  static $proc;
  return ($proc ??= GL::getProcAddress('getColorTableParameteriv'))($target, $pname, $params);
}

function glGetColorTableParameterivEXT(int $target, int $pname, $params) {
  static $proc;
  return ($proc ??= GL::getProcAddress('getColorTableParameterivEXT'))($target, $pname, $params);
}

function glGetColorTableParameterivSGI(int $target, int $pname, $params) {
  static $proc;
  return ($proc ??= GL::getProcAddress('getColorTableParameterivSGI'))($target, $pname, $params);
}

function glGetColorTableSGI(int $target, int $format, int $type, $table) {
  static $proc;
  return ($proc ??= GL::getProcAddress('getColorTableSGI'))($target, $format, $type, $table);
}

function glGetCombinerInputParameterfvNV(int $stage, int $portion, int $variable, int $pname, $params) {
  static $proc;
  return ($proc ??= GL::getProcAddress('getCombinerInputParameterfvNV'))($stage, $portion, $variable, $pname, $params);
}

function glGetCombinerInputParameterivNV(int $stage, int $portion, int $variable, int $pname, $params) {
  static $proc;
  return ($proc ??= GL::getProcAddress('getCombinerInputParameterivNV'))($stage, $portion, $variable, $pname, $params);
}

function glGetCombinerOutputParameterfvNV(int $stage, int $portion, int $pname, $params) {
  static $proc;
  return ($proc ??= GL::getProcAddress('getCombinerOutputParameterfvNV'))($stage, $portion, $pname, $params);
}

function glGetCombinerOutputParameterivNV(int $stage, int $portion, int $pname, $params) {
  static $proc;
  return ($proc ??= GL::getProcAddress('getCombinerOutputParameterivNV'))($stage, $portion, $pname, $params);
}

function glGetCombinerStageParameterfvNV(int $stage, int $pname, $params) {
  static $proc;
  return ($proc ??= GL::getProcAddress('getCombinerStageParameterfvNV'))($stage, $pname, $params);
}

function glGetCommandHeaderNV(int $tokenID, int $size) {
  static $proc;
  return ($proc ??= GL::getProcAddress('getCommandHeaderNV'))($tokenID, $size);
}

function glGetCompressedMultiTexImageEXT(int $texunit, int $target, int $lod, $img) {
  static $proc;
  return ($proc ??= GL::getProcAddress('getCompressedMultiTexImageEXT'))($texunit, $target, $lod, $img);
}

function glGetCompressedTexImage(int $target, int $level, $img) {
  static $proc;
  return ($proc ??= GL::getProcAddress('getCompressedTexImage'))($target, $level, $img);
}

function glGetCompressedTexImageARB(int $target, int $level, $img) {
  static $proc;
  return ($proc ??= GL::getProcAddress('getCompressedTexImageARB'))($target, $level, $img);
}

function glGetCompressedTextureImage(int $texture, int $level, int $bufSize, $pixels) {
  static $proc;
  return ($proc ??= GL::getProcAddress('getCompressedTextureImage'))($texture, $level, $bufSize, $pixels);
}

function glGetCompressedTextureImageEXT(int $texture, int $target, int $lod, $img) {
  static $proc;
  return ($proc ??= GL::getProcAddress('getCompressedTextureImageEXT'))($texture, $target, $lod, $img);
}

function glGetCompressedTextureSubImage(int $texture, int $level, int $xoffset, int $yoffset, int $zoffset, int $width, int $height, int $depth, int $bufSize, $pixels) {
  static $proc;
  return ($proc ??= GL::getProcAddress('getCompressedTextureSubImage'))($texture, $level, $xoffset, $yoffset, $zoffset, $width, $height, $depth, $bufSize, $pixels);
}

function glGetConvolutionFilter(int $target, int $format, int $type, $image) {
  static $proc;
  return ($proc ??= GL::getProcAddress('getConvolutionFilter'))($target, $format, $type, $image);
}

function glGetConvolutionFilterEXT(int $target, int $format, int $type, $image) {
  static $proc;
  return ($proc ??= GL::getProcAddress('getConvolutionFilterEXT'))($target, $format, $type, $image);
}

function glGetConvolutionParameterfv(int $target, int $pname, $params) {
  static $proc;
  return ($proc ??= GL::getProcAddress('getConvolutionParameterfv'))($target, $pname, $params);
}

function glGetConvolutionParameterfvEXT(int $target, int $pname, $params) {
  static $proc;
  return ($proc ??= GL::getProcAddress('getConvolutionParameterfvEXT'))($target, $pname, $params);
}

function glGetConvolutionParameteriv(int $target, int $pname, $params) {
  static $proc;
  return ($proc ??= GL::getProcAddress('getConvolutionParameteriv'))($target, $pname, $params);
}

function glGetConvolutionParameterivEXT(int $target, int $pname, $params) {
  static $proc;
  return ($proc ??= GL::getProcAddress('getConvolutionParameterivEXT'))($target, $pname, $params);
}

function glGetConvolutionParameterxvOES(int $target, int $pname, $params) {
  static $proc;
  return ($proc ??= GL::getProcAddress('getConvolutionParameterxvOES'))($target, $pname, $params);
}

function glGetCoverageModulationTableNV(int $bufsize, $v) {
  static $proc;
  return ($proc ??= GL::getProcAddress('getCoverageModulationTableNV'))($bufsize, $v);
}

function glGetDebugMessageLog(int $count, int $bufSize, $sources, $types, $ids, $severities, $lengths, $messageLog) {
  static $proc;
  return ($proc ??= GL::getProcAddress('getDebugMessageLog'))($count, $bufSize, $sources, $types, $ids, $severities, $lengths, $messageLog);
}

function glGetDebugMessageLogAMD(int $count, int $bufsize, $categories, $severities, $ids, $lengths, $message) {
  static $proc;
  return ($proc ??= GL::getProcAddress('getDebugMessageLogAMD'))($count, $bufsize, $categories, $severities, $ids, $lengths, $message);
}

function glGetDebugMessageLogARB(int $count, int $bufSize, $sources, $types, $ids, $severities, $lengths, $messageLog) {
  static $proc;
  return ($proc ??= GL::getProcAddress('getDebugMessageLogARB'))($count, $bufSize, $sources, $types, $ids, $severities, $lengths, $messageLog);
}

function glGetDebugMessageLogKHR(int $count, int $bufSize, $sources, $types, $ids, $severities, $lengths, $messageLog) {
  static $proc;
  return ($proc ??= GL::getProcAddress('getDebugMessageLogKHR'))($count, $bufSize, $sources, $types, $ids, $severities, $lengths, $messageLog);
}

function glGetDetailTexFuncSGIS(int $target, $points) {
  static $proc;
  return ($proc ??= GL::getProcAddress('getDetailTexFuncSGIS'))($target, $points);
}

function glGetDoubleIndexedvEXT(int $target, int $index, $data) {
  static $proc;
  return ($proc ??= GL::getProcAddress('getDoubleIndexedvEXT'))($target, $index, $data);
}

function glGetDoublei_v(int $target, int $index, $data) {
  static $proc;
  return ($proc ??= GL::getProcAddress('getDoublei_v'))($target, $index, $data);
}

function glGetDoublei_vEXT(int $pname, int $index, $params) {
  static $proc;
  return ($proc ??= GL::getProcAddress('getDoublei_vEXT'))($pname, $index, $params);
}

function glGetDoublev(int $pname, $data) {
  static $proc;
  return ($proc ??= GL::getProcAddress('getDoublev'))($pname, $data);
}

function glGetDriverControlStringQCOM(int $driverControl, int $bufSize, $length, $driverControlString) {
  static $proc;
  return ($proc ??= GL::getProcAddress('getDriverControlStringQCOM'))($driverControl, $bufSize, $length, $driverControlString);
}

function glGetDriverControlsQCOM($num, int $size, $driverControls) {
  static $proc;
  return ($proc ??= GL::getProcAddress('getDriverControlsQCOM'))($num, $size, $driverControls);
}

function glGetError() {
  static $proc;
  return ($proc ??= GL::getProcAddress('getError'))();
}

function glGetFenceivNV(int $fence, int $pname, $params) {
  static $proc;
  return ($proc ??= GL::getProcAddress('getFenceivNV'))($fence, $pname, $params);
}

function glGetFinalCombinerInputParameterfvNV(int $variable, int $pname, $params) {
  static $proc;
  return ($proc ??= GL::getProcAddress('getFinalCombinerInputParameterfvNV'))($variable, $pname, $params);
}

function glGetFinalCombinerInputParameterivNV(int $variable, int $pname, $params) {
  static $proc;
  return ($proc ??= GL::getProcAddress('getFinalCombinerInputParameterivNV'))($variable, $pname, $params);
}

function glGetFirstPerfQueryIdINTEL($queryId) {
  static $proc;
  return ($proc ??= GL::getProcAddress('getFirstPerfQueryIdINTEL'))($queryId);
}

function glGetFixedv(int $pname, $params) {
  static $proc;
  return ($proc ??= GL::getProcAddress('getFixedv'))($pname, $params);
}

function glGetFixedvOES(int $pname, $params) {
  static $proc;
  return ($proc ??= GL::getProcAddress('getFixedvOES'))($pname, $params);
}

function glGetFloatIndexedvEXT(int $target, int $index, $data) {
  static $proc;
  return ($proc ??= GL::getProcAddress('getFloatIndexedvEXT'))($target, $index, $data);
}

function glGetFloati_v(int $target, int $index, $data) {
  static $proc;
  return ($proc ??= GL::getProcAddress('getFloati_v'))($target, $index, $data);
}

function glGetFloati_vEXT(int $pname, int $index, $params) {
  static $proc;
  return ($proc ??= GL::getProcAddress('getFloati_vEXT'))($pname, $index, $params);
}

function glGetFloati_vNV(int $target, int $index, $data) {
  static $proc;
  return ($proc ??= GL::getProcAddress('getFloati_vNV'))($target, $index, $data);
}

function glGetFloati_vOES(int $target, int $index, $data) {
  static $proc;
  return ($proc ??= GL::getProcAddress('getFloati_vOES'))($target, $index, $data);
}

function glGetFloatv(int $pname, $data) {
  static $proc;
  return ($proc ??= GL::getProcAddress('getFloatv'))($pname, $data);
}

function glGetFogFuncSGIS($points) {
  static $proc;
  return ($proc ??= GL::getProcAddress('getFogFuncSGIS'))($points);
}

function glGetFragDataIndex(int $program, $name) {
  static $proc;
  return ($proc ??= GL::getProcAddress('getFragDataIndex'))($program, $name);
}

function glGetFragDataIndexEXT(int $program, $name) {
  static $proc;
  return ($proc ??= GL::getProcAddress('getFragDataIndexEXT'))($program, $name);
}

function glGetFragDataLocation(int $program, $name) {
  static $proc;
  return ($proc ??= GL::getProcAddress('getFragDataLocation'))($program, $name);
}

function glGetFragDataLocationEXT(int $program, $name) {
  static $proc;
  return ($proc ??= GL::getProcAddress('getFragDataLocationEXT'))($program, $name);
}

function glGetFragmentLightfvSGIX(int $light, int $pname, $params) {
  static $proc;
  return ($proc ??= GL::getProcAddress('getFragmentLightfvSGIX'))($light, $pname, $params);
}

function glGetFragmentLightivSGIX(int $light, int $pname, $params) {
  static $proc;
  return ($proc ??= GL::getProcAddress('getFragmentLightivSGIX'))($light, $pname, $params);
}

function glGetFragmentMaterialfvSGIX(int $face, int $pname, $params) {
  static $proc;
  return ($proc ??= GL::getProcAddress('getFragmentMaterialfvSGIX'))($face, $pname, $params);
}

function glGetFragmentMaterialivSGIX(int $face, int $pname, $params) {
  static $proc;
  return ($proc ??= GL::getProcAddress('getFragmentMaterialivSGIX'))($face, $pname, $params);
}

function glGetFramebufferAttachmentParameteriv(int $target, int $attachment, int $pname, $params) {
  static $proc;
  return ($proc ??= GL::getProcAddress('getFramebufferAttachmentParameteriv'))($target, $attachment, $pname, $params);
}

function glGetFramebufferAttachmentParameterivEXT(int $target, int $attachment, int $pname, $params) {
  static $proc;
  return ($proc ??= GL::getProcAddress('getFramebufferAttachmentParameterivEXT'))($target, $attachment, $pname, $params);
}

function glGetFramebufferAttachmentParameterivOES(int $target, int $attachment, int $pname, $params) {
  static $proc;
  return ($proc ??= GL::getProcAddress('getFramebufferAttachmentParameterivOES'))($target, $attachment, $pname, $params);
}

function glGetFramebufferParameterfvAMD(int $target, int $pname, int $numsamples, int $pixelindex, int $size, $values) {
  static $proc;
  return ($proc ??= GL::getProcAddress('getFramebufferParameterfvAMD'))($target, $pname, $numsamples, $pixelindex, $size, $values);
}

function glGetFramebufferParameteriv(int $target, int $pname, $params) {
  static $proc;
  return ($proc ??= GL::getProcAddress('getFramebufferParameteriv'))($target, $pname, $params);
}

function glGetFramebufferParameterivEXT(int $framebuffer, int $pname, $params) {
  static $proc;
  return ($proc ??= GL::getProcAddress('getFramebufferParameterivEXT'))($framebuffer, $pname, $params);
}

function glGetFramebufferPixelLocalStorageSizeEXT(int $target) {
  static $proc;
  return ($proc ??= GL::getProcAddress('getFramebufferPixelLocalStorageSizeEXT'))($target);
}

function glGetGraphicsResetStatus() {
  static $proc;
  return ($proc ??= GL::getProcAddress('getGraphicsResetStatus'))();
}

function glGetGraphicsResetStatusARB() {
  static $proc;
  return ($proc ??= GL::getProcAddress('getGraphicsResetStatusARB'))();
}

function glGetGraphicsResetStatusEXT() {
  static $proc;
  return ($proc ??= GL::getProcAddress('getGraphicsResetStatusEXT'))();
}

function glGetGraphicsResetStatusKHR() {
  static $proc;
  return ($proc ??= GL::getProcAddress('getGraphicsResetStatusKHR'))();
}

function glGetHandleARB(int $pname) {
  static $proc;
  return ($proc ??= GL::getProcAddress('getHandleARB'))($pname);
}

function glGetHistogram(int $target, int $reset, int $format, int $type, $values) {
  static $proc;
  return ($proc ??= GL::getProcAddress('getHistogram'))($target, $reset, $format, $type, $values);
}

function glGetHistogramEXT(int $target, int $reset, int $format, int $type, $values) {
  static $proc;
  return ($proc ??= GL::getProcAddress('getHistogramEXT'))($target, $reset, $format, $type, $values);
}

function glGetHistogramParameterfv(int $target, int $pname, $params) {
  static $proc;
  return ($proc ??= GL::getProcAddress('getHistogramParameterfv'))($target, $pname, $params);
}

function glGetHistogramParameterfvEXT(int $target, int $pname, $params) {
  static $proc;
  return ($proc ??= GL::getProcAddress('getHistogramParameterfvEXT'))($target, $pname, $params);
}

function glGetHistogramParameteriv(int $target, int $pname, $params) {
  static $proc;
  return ($proc ??= GL::getProcAddress('getHistogramParameteriv'))($target, $pname, $params);
}

function glGetHistogramParameterivEXT(int $target, int $pname, $params) {
  static $proc;
  return ($proc ??= GL::getProcAddress('getHistogramParameterivEXT'))($target, $pname, $params);
}

function glGetHistogramParameterxvOES(int $target, int $pname, $params) {
  static $proc;
  return ($proc ??= GL::getProcAddress('getHistogramParameterxvOES'))($target, $pname, $params);
}

function glGetImageHandleARB(int $texture, int $level, int $layered, int $layer, int $format) {
  static $proc;
  return ($proc ??= GL::getProcAddress('getImageHandleARB'))($texture, $level, $layered, $layer, $format);
}

function glGetImageHandleNV(int $texture, int $level, int $layered, int $layer, int $format) {
  static $proc;
  return ($proc ??= GL::getProcAddress('getImageHandleNV'))($texture, $level, $layered, $layer, $format);
}

function glGetImageTransformParameterfvHP(int $target, int $pname, $params) {
  static $proc;
  return ($proc ??= GL::getProcAddress('getImageTransformParameterfvHP'))($target, $pname, $params);
}

function glGetImageTransformParameterivHP(int $target, int $pname, $params) {
  static $proc;
  return ($proc ??= GL::getProcAddress('getImageTransformParameterivHP'))($target, $pname, $params);
}

function glGetInfoLogARB(int $obj, int $maxLength, $length, $infoLog) {
  static $proc;
  return ($proc ??= GL::getProcAddress('getInfoLogARB'))($obj, $maxLength, $length, $infoLog);
}

function glGetInstrumentsSGIX() {
  static $proc;
  return ($proc ??= GL::getProcAddress('getInstrumentsSGIX'))();
}

function glGetInteger64i_v(int $target, int $index, $data) {
  static $proc;
  return ($proc ??= GL::getProcAddress('getInteger64i_v'))($target, $index, $data);
}

function glGetInteger64v(int $pname, $data) {
  static $proc;
  return ($proc ??= GL::getProcAddress('getInteger64v'))($pname, $data);
}

function glGetInteger64vAPPLE(int $pname, $params) {
  static $proc;
  return ($proc ??= GL::getProcAddress('getInteger64vAPPLE'))($pname, $params);
}

function glGetIntegerIndexedvEXT(int $target, int $index, $data) {
  static $proc;
  return ($proc ??= GL::getProcAddress('getIntegerIndexedvEXT'))($target, $index, $data);
}

function glGetIntegeri_v(int $target, int $index, $data) {
  static $proc;
  return ($proc ??= GL::getProcAddress('getIntegeri_v'))($target, $index, $data);
}

function glGetIntegeri_vEXT(int $target, int $index, $data) {
  static $proc;
  return ($proc ??= GL::getProcAddress('getIntegeri_vEXT'))($target, $index, $data);
}

function glGetIntegerui64i_vNV(int $value, int $index, $result) {
  static $proc;
  return ($proc ??= GL::getProcAddress('getIntegerui64i_vNV'))($value, $index, $result);
}

function glGetIntegerui64vNV(int $value, $result) {
  static $proc;
  return ($proc ??= GL::getProcAddress('getIntegerui64vNV'))($value, $result);
}

function glGetIntegerv(int $pname, $data) {
  static $proc;
  return ($proc ??= GL::getProcAddress('getIntegerv'))($pname, $data);
}

function glGetInternalformatSampleivNV(int $target, int $internalformat, int $samples, int $pname, int $bufSize, $params) {
  static $proc;
  return ($proc ??= GL::getProcAddress('getInternalformatSampleivNV'))($target, $internalformat, $samples, $pname, $bufSize, $params);
}

function glGetInternalformati64v(int $target, int $internalformat, int $pname, int $bufSize, $params) {
  static $proc;
  return ($proc ??= GL::getProcAddress('getInternalformati64v'))($target, $internalformat, $pname, $bufSize, $params);
}

function glGetInternalformativ(int $target, int $internalformat, int $pname, int $bufSize, $params) {
  static $proc;
  return ($proc ??= GL::getProcAddress('getInternalformativ'))($target, $internalformat, $pname, $bufSize, $params);
}

function glGetInvariantBooleanvEXT(int $id, int $value, $data) {
  static $proc;
  return ($proc ??= GL::getProcAddress('getInvariantBooleanvEXT'))($id, $value, $data);
}

function glGetInvariantFloatvEXT(int $id, int $value, $data) {
  static $proc;
  return ($proc ??= GL::getProcAddress('getInvariantFloatvEXT'))($id, $value, $data);
}

function glGetInvariantIntegervEXT(int $id, int $value, $data) {
  static $proc;
  return ($proc ??= GL::getProcAddress('getInvariantIntegervEXT'))($id, $value, $data);
}

function glGetLightfv(int $light, int $pname, $params) {
  static $proc;
  return ($proc ??= GL::getProcAddress('getLightfv'))($light, $pname, $params);
}

function glGetLightiv(int $light, int $pname, $params) {
  static $proc;
  return ($proc ??= GL::getProcAddress('getLightiv'))($light, $pname, $params);
}

function glGetLightxOES(int $light, int $pname, $params) {
  static $proc;
  return ($proc ??= GL::getProcAddress('getLightxOES'))($light, $pname, $params);
}

function glGetLightxv(int $light, int $pname, $params) {
  static $proc;
  return ($proc ??= GL::getProcAddress('getLightxv'))($light, $pname, $params);
}

function glGetLightxvOES(int $light, int $pname, $params) {
  static $proc;
  return ($proc ??= GL::getProcAddress('getLightxvOES'))($light, $pname, $params);
}

function glGetListParameterfvSGIX(int $list, int $pname, $params) {
  static $proc;
  return ($proc ??= GL::getProcAddress('getListParameterfvSGIX'))($list, $pname, $params);
}

function glGetListParameterivSGIX(int $list, int $pname, $params) {
  static $proc;
  return ($proc ??= GL::getProcAddress('getListParameterivSGIX'))($list, $pname, $params);
}

function glGetLocalConstantBooleanvEXT(int $id, int $value, $data) {
  static $proc;
  return ($proc ??= GL::getProcAddress('getLocalConstantBooleanvEXT'))($id, $value, $data);
}

function glGetLocalConstantFloatvEXT(int $id, int $value, $data) {
  static $proc;
  return ($proc ??= GL::getProcAddress('getLocalConstantFloatvEXT'))($id, $value, $data);
}

function glGetLocalConstantIntegervEXT(int $id, int $value, $data) {
  static $proc;
  return ($proc ??= GL::getProcAddress('getLocalConstantIntegervEXT'))($id, $value, $data);
}

function glGetMapAttribParameterfvNV(int $target, int $index, int $pname, $params) {
  static $proc;
  return ($proc ??= GL::getProcAddress('getMapAttribParameterfvNV'))($target, $index, $pname, $params);
}

function glGetMapAttribParameterivNV(int $target, int $index, int $pname, $params) {
  static $proc;
  return ($proc ??= GL::getProcAddress('getMapAttribParameterivNV'))($target, $index, $pname, $params);
}

function glGetMapControlPointsNV(int $target, int $index, int $type, int $ustride, int $vstride, int $packed, $points) {
  static $proc;
  return ($proc ??= GL::getProcAddress('getMapControlPointsNV'))($target, $index, $type, $ustride, $vstride, $packed, $points);
}

function glGetMapParameterfvNV(int $target, int $pname, $params) {
  static $proc;
  return ($proc ??= GL::getProcAddress('getMapParameterfvNV'))($target, $pname, $params);
}

function glGetMapParameterivNV(int $target, int $pname, $params) {
  static $proc;
  return ($proc ??= GL::getProcAddress('getMapParameterivNV'))($target, $pname, $params);
}

function glGetMapdv(int $target, int $query, $v) {
  static $proc;
  return ($proc ??= GL::getProcAddress('getMapdv'))($target, $query, $v);
}

function glGetMapfv(int $target, int $query, $v) {
  static $proc;
  return ($proc ??= GL::getProcAddress('getMapfv'))($target, $query, $v);
}

function glGetMapiv(int $target, int $query, $v) {
  static $proc;
  return ($proc ??= GL::getProcAddress('getMapiv'))($target, $query, $v);
}

function glGetMapxvOES(int $target, int $query, $v) {
  static $proc;
  return ($proc ??= GL::getProcAddress('getMapxvOES'))($target, $query, $v);
}

function glGetMaterialfv(int $face, int $pname, $params) {
  static $proc;
  return ($proc ??= GL::getProcAddress('getMaterialfv'))($face, $pname, $params);
}

function glGetMaterialiv(int $face, int $pname, $params) {
  static $proc;
  return ($proc ??= GL::getProcAddress('getMaterialiv'))($face, $pname, $params);
}

function glGetMaterialxOES(int $face, int $pname, int $param) {
  static $proc;
  return ($proc ??= GL::getProcAddress('getMaterialxOES'))($face, $pname, $param);
}

function glGetMaterialxv(int $face, int $pname, $params) {
  static $proc;
  return ($proc ??= GL::getProcAddress('getMaterialxv'))($face, $pname, $params);
}

function glGetMaterialxvOES(int $face, int $pname, $params) {
  static $proc;
  return ($proc ??= GL::getProcAddress('getMaterialxvOES'))($face, $pname, $params);
}

function glGetMinmax(int $target, int $reset, int $format, int $type, $values) {
  static $proc;
  return ($proc ??= GL::getProcAddress('getMinmax'))($target, $reset, $format, $type, $values);
}

function glGetMinmaxEXT(int $target, int $reset, int $format, int $type, $values) {
  static $proc;
  return ($proc ??= GL::getProcAddress('getMinmaxEXT'))($target, $reset, $format, $type, $values);
}

function glGetMinmaxParameterfv(int $target, int $pname, $params) {
  static $proc;
  return ($proc ??= GL::getProcAddress('getMinmaxParameterfv'))($target, $pname, $params);
}

function glGetMinmaxParameterfvEXT(int $target, int $pname, $params) {
  static $proc;
  return ($proc ??= GL::getProcAddress('getMinmaxParameterfvEXT'))($target, $pname, $params);
}

function glGetMinmaxParameteriv(int $target, int $pname, $params) {
  static $proc;
  return ($proc ??= GL::getProcAddress('getMinmaxParameteriv'))($target, $pname, $params);
}

function glGetMinmaxParameterivEXT(int $target, int $pname, $params) {
  static $proc;
  return ($proc ??= GL::getProcAddress('getMinmaxParameterivEXT'))($target, $pname, $params);
}

function glGetMultiTexEnvfvEXT(int $texunit, int $target, int $pname, $params) {
  static $proc;
  return ($proc ??= GL::getProcAddress('getMultiTexEnvfvEXT'))($texunit, $target, $pname, $params);
}

function glGetMultiTexEnvivEXT(int $texunit, int $target, int $pname, $params) {
  static $proc;
  return ($proc ??= GL::getProcAddress('getMultiTexEnvivEXT'))($texunit, $target, $pname, $params);
}

function glGetMultiTexGendvEXT(int $texunit, int $coord, int $pname, $params) {
  static $proc;
  return ($proc ??= GL::getProcAddress('getMultiTexGendvEXT'))($texunit, $coord, $pname, $params);
}

function glGetMultiTexGenfvEXT(int $texunit, int $coord, int $pname, $params) {
  static $proc;
  return ($proc ??= GL::getProcAddress('getMultiTexGenfvEXT'))($texunit, $coord, $pname, $params);
}

function glGetMultiTexGenivEXT(int $texunit, int $coord, int $pname, $params) {
  static $proc;
  return ($proc ??= GL::getProcAddress('getMultiTexGenivEXT'))($texunit, $coord, $pname, $params);
}

function glGetMultiTexImageEXT(int $texunit, int $target, int $level, int $format, int $type, $pixels) {
  static $proc;
  return ($proc ??= GL::getProcAddress('getMultiTexImageEXT'))($texunit, $target, $level, $format, $type, $pixels);
}

function glGetMultiTexLevelParameterfvEXT(int $texunit, int $target, int $level, int $pname, $params) {
  static $proc;
  return ($proc ??= GL::getProcAddress('getMultiTexLevelParameterfvEXT'))($texunit, $target, $level, $pname, $params);
}

function glGetMultiTexLevelParameterivEXT(int $texunit, int $target, int $level, int $pname, $params) {
  static $proc;
  return ($proc ??= GL::getProcAddress('getMultiTexLevelParameterivEXT'))($texunit, $target, $level, $pname, $params);
}

function glGetMultiTexParameterIivEXT(int $texunit, int $target, int $pname, $params) {
  static $proc;
  return ($proc ??= GL::getProcAddress('getMultiTexParameterIivEXT'))($texunit, $target, $pname, $params);
}

function glGetMultiTexParameterIuivEXT(int $texunit, int $target, int $pname, $params) {
  static $proc;
  return ($proc ??= GL::getProcAddress('getMultiTexParameterIuivEXT'))($texunit, $target, $pname, $params);
}

function glGetMultiTexParameterfvEXT(int $texunit, int $target, int $pname, $params) {
  static $proc;
  return ($proc ??= GL::getProcAddress('getMultiTexParameterfvEXT'))($texunit, $target, $pname, $params);
}

function glGetMultiTexParameterivEXT(int $texunit, int $target, int $pname, $params) {
  static $proc;
  return ($proc ??= GL::getProcAddress('getMultiTexParameterivEXT'))($texunit, $target, $pname, $params);
}

function glGetMultisamplefv(int $pname, int $index, $val) {
  static $proc;
  return ($proc ??= GL::getProcAddress('getMultisamplefv'))($pname, $index, $val);
}

function glGetMultisamplefvNV(int $pname, int $index, $val) {
  static $proc;
  return ($proc ??= GL::getProcAddress('getMultisamplefvNV'))($pname, $index, $val);
}

function glGetNamedBufferParameteri64v(int $buffer, int $pname, $params) {
  static $proc;
  return ($proc ??= GL::getProcAddress('getNamedBufferParameteri64v'))($buffer, $pname, $params);
}

function glGetNamedBufferParameteriv(int $buffer, int $pname, $params) {
  static $proc;
  return ($proc ??= GL::getProcAddress('getNamedBufferParameteriv'))($buffer, $pname, $params);
}

function glGetNamedBufferParameterivEXT(int $buffer, int $pname, $params) {
  static $proc;
  return ($proc ??= GL::getProcAddress('getNamedBufferParameterivEXT'))($buffer, $pname, $params);
}

function glGetNamedBufferParameterui64vNV(int $buffer, int $pname, $params) {
  static $proc;
  return ($proc ??= GL::getProcAddress('getNamedBufferParameterui64vNV'))($buffer, $pname, $params);
}

function glGetNamedBufferPointerv(int $buffer, int $pname, $params) {
  static $proc;
  return ($proc ??= GL::getProcAddress('getNamedBufferPointerv'))($buffer, $pname, $params);
}

function glGetNamedBufferPointervEXT(int $buffer, int $pname, $params) {
  static $proc;
  return ($proc ??= GL::getProcAddress('getNamedBufferPointervEXT'))($buffer, $pname, $params);
}

function glGetNamedBufferSubData(int $buffer, int $offset, int $size, $data) {
  static $proc;
  return ($proc ??= GL::getProcAddress('getNamedBufferSubData'))($buffer, $offset, $size, $data);
}

function glGetNamedBufferSubDataEXT(int $buffer, int $offset, int $size, $data) {
  static $proc;
  return ($proc ??= GL::getProcAddress('getNamedBufferSubDataEXT'))($buffer, $offset, $size, $data);
}

function glGetNamedFramebufferParameterfvAMD(int $framebuffer, int $pname, int $numsamples, int $pixelindex, int $size, $values) {
  static $proc;
  return ($proc ??= GL::getProcAddress('getNamedFramebufferParameterfvAMD'))($framebuffer, $pname, $numsamples, $pixelindex, $size, $values);
}

function glGetNamedFramebufferAttachmentParameteriv(int $framebuffer, int $attachment, int $pname, $params) {
  static $proc;
  return ($proc ??= GL::getProcAddress('getNamedFramebufferAttachmentParameteriv'))($framebuffer, $attachment, $pname, $params);
}

function glGetNamedFramebufferAttachmentParameterivEXT(int $framebuffer, int $attachment, int $pname, $params) {
  static $proc;
  return ($proc ??= GL::getProcAddress('getNamedFramebufferAttachmentParameterivEXT'))($framebuffer, $attachment, $pname, $params);
}

function glGetNamedFramebufferParameteriv(int $framebuffer, int $pname, $param) {
  static $proc;
  return ($proc ??= GL::getProcAddress('getNamedFramebufferParameteriv'))($framebuffer, $pname, $param);
}

function glGetNamedFramebufferParameterivEXT(int $framebuffer, int $pname, $params) {
  static $proc;
  return ($proc ??= GL::getProcAddress('getNamedFramebufferParameterivEXT'))($framebuffer, $pname, $params);
}

function glGetNamedProgramLocalParameterIivEXT(int $program, int $target, int $index, $params) {
  static $proc;
  return ($proc ??= GL::getProcAddress('getNamedProgramLocalParameterIivEXT'))($program, $target, $index, $params);
}

function glGetNamedProgramLocalParameterIuivEXT(int $program, int $target, int $index, $params) {
  static $proc;
  return ($proc ??= GL::getProcAddress('getNamedProgramLocalParameterIuivEXT'))($program, $target, $index, $params);
}

function glGetNamedProgramLocalParameterdvEXT(int $program, int $target, int $index, $params) {
  static $proc;
  return ($proc ??= GL::getProcAddress('getNamedProgramLocalParameterdvEXT'))($program, $target, $index, $params);
}

function glGetNamedProgramLocalParameterfvEXT(int $program, int $target, int $index, $params) {
  static $proc;
  return ($proc ??= GL::getProcAddress('getNamedProgramLocalParameterfvEXT'))($program, $target, $index, $params);
}

function glGetNamedProgramStringEXT(int $program, int $target, int $pname, $string) {
  static $proc;
  return ($proc ??= GL::getProcAddress('getNamedProgramStringEXT'))($program, $target, $pname, $string);
}

function glGetNamedProgramivEXT(int $program, int $target, int $pname, $params) {
  static $proc;
  return ($proc ??= GL::getProcAddress('getNamedProgramivEXT'))($program, $target, $pname, $params);
}

function glGetNamedRenderbufferParameteriv(int $renderbuffer, int $pname, $params) {
  static $proc;
  return ($proc ??= GL::getProcAddress('getNamedRenderbufferParameteriv'))($renderbuffer, $pname, $params);
}

function glGetNamedRenderbufferParameterivEXT(int $renderbuffer, int $pname, $params) {
  static $proc;
  return ($proc ??= GL::getProcAddress('getNamedRenderbufferParameterivEXT'))($renderbuffer, $pname, $params);
}

function glGetNamedStringARB(int $namelen, $name, int $bufSize, $stringlen, $string) {
  static $proc;
  return ($proc ??= GL::getProcAddress('getNamedStringARB'))($namelen, $name, $bufSize, $stringlen, $string);
}

function glGetNamedStringivARB(int $namelen, $name, int $pname, $params) {
  static $proc;
  return ($proc ??= GL::getProcAddress('getNamedStringivARB'))($namelen, $name, $pname, $params);
}

function glGetNextPerfQueryIdINTEL(int $queryId, $nextQueryId) {
  static $proc;
  return ($proc ??= GL::getProcAddress('getNextPerfQueryIdINTEL'))($queryId, $nextQueryId);
}

function glGetObjectBufferfvATI(int $buffer, int $pname, $params) {
  static $proc;
  return ($proc ??= GL::getProcAddress('getObjectBufferfvATI'))($buffer, $pname, $params);
}

function glGetObjectBufferivATI(int $buffer, int $pname, $params) {
  static $proc;
  return ($proc ??= GL::getProcAddress('getObjectBufferivATI'))($buffer, $pname, $params);
}

function glGetObjectLabel(int $identifier, int $name, int $bufSize, $length, $label) {
  static $proc;
  return ($proc ??= GL::getProcAddress('getObjectLabel'))($identifier, $name, $bufSize, $length, $label);
}

function glGetObjectLabelEXT(int $type, int $object, int $bufSize, $length, $label) {
  static $proc;
  return ($proc ??= GL::getProcAddress('getObjectLabelEXT'))($type, $object, $bufSize, $length, $label);
}

function glGetObjectLabelKHR(int $identifier, int $name, int $bufSize, $length, $label) {
  static $proc;
  return ($proc ??= GL::getProcAddress('getObjectLabelKHR'))($identifier, $name, $bufSize, $length, $label);
}

function glGetObjectParameterfvARB(int $obj, int $pname, $params) {
  static $proc;
  return ($proc ??= GL::getProcAddress('getObjectParameterfvARB'))($obj, $pname, $params);
}

function glGetObjectParameterivAPPLE(int $objectType, int $name, int $pname, $params) {
  static $proc;
  return ($proc ??= GL::getProcAddress('getObjectParameterivAPPLE'))($objectType, $name, $pname, $params);
}

function glGetObjectParameterivARB(int $obj, int $pname, $params) {
  static $proc;
  return ($proc ??= GL::getProcAddress('getObjectParameterivARB'))($obj, $pname, $params);
}

function glGetObjectPtrLabel($ptr, int $bufSize, $length, $label) {
  static $proc;
  return ($proc ??= GL::getProcAddress('getObjectPtrLabel'))($ptr, $bufSize, $length, $label);
}

function glGetObjectPtrLabelKHR($ptr, int $bufSize, $length, $label) {
  static $proc;
  return ($proc ??= GL::getProcAddress('getObjectPtrLabelKHR'))($ptr, $bufSize, $length, $label);
}

function glGetOcclusionQueryivNV(int $id, int $pname, $params) {
  static $proc;
  return ($proc ??= GL::getProcAddress('getOcclusionQueryivNV'))($id, $pname, $params);
}

function glGetOcclusionQueryuivNV(int $id, int $pname, $params) {
  static $proc;
  return ($proc ??= GL::getProcAddress('getOcclusionQueryuivNV'))($id, $pname, $params);
}

function glGetPathColorGenfvNV(int $color, int $pname, $value) {
  static $proc;
  return ($proc ??= GL::getProcAddress('getPathColorGenfvNV'))($color, $pname, $value);
}

function glGetPathColorGenivNV(int $color, int $pname, $value) {
  static $proc;
  return ($proc ??= GL::getProcAddress('getPathColorGenivNV'))($color, $pname, $value);
}

function glGetPathCommandsNV(int $path, $commands) {
  static $proc;
  return ($proc ??= GL::getProcAddress('getPathCommandsNV'))($path, $commands);
}

function glGetPathCoordsNV(int $path, $coords) {
  static $proc;
  return ($proc ??= GL::getProcAddress('getPathCoordsNV'))($path, $coords);
}

function glGetPathDashArrayNV(int $path, $dashArray) {
  static $proc;
  return ($proc ??= GL::getProcAddress('getPathDashArrayNV'))($path, $dashArray);
}

function glGetPathLengthNV(int $path, int $startSegment, int $numSegments) {
  static $proc;
  return ($proc ??= GL::getProcAddress('getPathLengthNV'))($path, $startSegment, $numSegments);
}

function glGetPathMetricRangeNV(int $metricQueryMask, int $firstPathName, int $numPaths, int $stride, $metrics) {
  static $proc;
  return ($proc ??= GL::getProcAddress('getPathMetricRangeNV'))($metricQueryMask, $firstPathName, $numPaths, $stride, $metrics);
}

function glGetPathMetricsNV(int $metricQueryMask, int $numPaths, int $pathNameType, $paths, int $pathBase, int $stride, $metrics) {
  static $proc;
  return ($proc ??= GL::getProcAddress('getPathMetricsNV'))($metricQueryMask, $numPaths, $pathNameType, $paths, $pathBase, $stride, $metrics);
}

function glGetPathParameterfvNV(int $path, int $pname, $value) {
  static $proc;
  return ($proc ??= GL::getProcAddress('getPathParameterfvNV'))($path, $pname, $value);
}

function glGetPathParameterivNV(int $path, int $pname, $value) {
  static $proc;
  return ($proc ??= GL::getProcAddress('getPathParameterivNV'))($path, $pname, $value);
}

function glGetPathSpacingNV(int $pathListMode, int $numPaths, int $pathNameType, $paths, int $pathBase, float $advanceScale, float $kerningScale, int $transformType, $returnedSpacing) {
  static $proc;
  return ($proc ??= GL::getProcAddress('getPathSpacingNV'))($pathListMode, $numPaths, $pathNameType, $paths, $pathBase, $advanceScale, $kerningScale, $transformType, $returnedSpacing);
}

function glGetPathTexGenfvNV(int $texCoordSet, int $pname, $value) {
  static $proc;
  return ($proc ??= GL::getProcAddress('getPathTexGenfvNV'))($texCoordSet, $pname, $value);
}

function glGetPathTexGenivNV(int $texCoordSet, int $pname, $value) {
  static $proc;
  return ($proc ??= GL::getProcAddress('getPathTexGenivNV'))($texCoordSet, $pname, $value);
}

function glGetPerfCounterInfoINTEL(int $queryId, int $counterId, int $counterNameLength, $counterName, int $counterDescLength, $counterDesc, $counterOffset, $counterDataSize, $counterTypeEnum, $counterDataTypeEnum, $rawCounterMaxValue) {
  static $proc;
  return ($proc ??= GL::getProcAddress('getPerfCounterInfoINTEL'))($queryId, $counterId, $counterNameLength, $counterName, $counterDescLength, $counterDesc, $counterOffset, $counterDataSize, $counterTypeEnum, $counterDataTypeEnum, $rawCounterMaxValue);
}

function glGetPerfMonitorCounterDataAMD(int $monitor, int $pname, int $dataSize, $data, $bytesWritten) {
  static $proc;
  return ($proc ??= GL::getProcAddress('getPerfMonitorCounterDataAMD'))($monitor, $pname, $dataSize, $data, $bytesWritten);
}

function glGetPerfMonitorCounterInfoAMD(int $group, int $counter, int $pname, $data) {
  static $proc;
  return ($proc ??= GL::getProcAddress('getPerfMonitorCounterInfoAMD'))($group, $counter, $pname, $data);
}

function glGetPerfMonitorCounterStringAMD(int $group, int $counter, int $bufSize, $length, $counterString) {
  static $proc;
  return ($proc ??= GL::getProcAddress('getPerfMonitorCounterStringAMD'))($group, $counter, $bufSize, $length, $counterString);
}

function glGetPerfMonitorCountersAMD(int $group, $numCounters, $maxActiveCounters, int $counterSize, $counters) {
  static $proc;
  return ($proc ??= GL::getProcAddress('getPerfMonitorCountersAMD'))($group, $numCounters, $maxActiveCounters, $counterSize, $counters);
}

function glGetPerfMonitorGroupStringAMD(int $group, int $bufSize, $length, $groupString) {
  static $proc;
  return ($proc ??= GL::getProcAddress('getPerfMonitorGroupStringAMD'))($group, $bufSize, $length, $groupString);
}

function glGetPerfMonitorGroupsAMD($numGroups, int $groupsSize, $groups) {
  static $proc;
  return ($proc ??= GL::getProcAddress('getPerfMonitorGroupsAMD'))($numGroups, $groupsSize, $groups);
}

function glGetPerfQueryDataINTEL(int $queryHandle, int $flags, int $dataSize, $data, $bytesWritten) {
  static $proc;
  return ($proc ??= GL::getProcAddress('getPerfQueryDataINTEL'))($queryHandle, $flags, $dataSize, $data, $bytesWritten);
}

function glGetPerfQueryIdByNameINTEL($queryName, $queryId) {
  static $proc;
  return ($proc ??= GL::getProcAddress('getPerfQueryIdByNameINTEL'))($queryName, $queryId);
}

function glGetPerfQueryInfoINTEL(int $queryId, int $queryNameLength, $queryName, $dataSize, $noCounters, $noInstances, $capsMask) {
  static $proc;
  return ($proc ??= GL::getProcAddress('getPerfQueryInfoINTEL'))($queryId, $queryNameLength, $queryName, $dataSize, $noCounters, $noInstances, $capsMask);
}

function glGetPixelMapfv(int $map, $values) {
  static $proc;
  return ($proc ??= GL::getProcAddress('getPixelMapfv'))($map, $values);
}

function glGetPixelMapuiv(int $map, $values) {
  static $proc;
  return ($proc ??= GL::getProcAddress('getPixelMapuiv'))($map, $values);
}

function glGetPixelMapusv(int $map, $values) {
  static $proc;
  return ($proc ??= GL::getProcAddress('getPixelMapusv'))($map, $values);
}

function glGetPixelMapxv(int $map, int $size, $values) {
  static $proc;
  return ($proc ??= GL::getProcAddress('getPixelMapxv'))($map, $size, $values);
}

function glGetPixelTexGenParameterfvSGIS(int $pname, $params) {
  static $proc;
  return ($proc ??= GL::getProcAddress('getPixelTexGenParameterfvSGIS'))($pname, $params);
}

function glGetPixelTexGenParameterivSGIS(int $pname, $params) {
  static $proc;
  return ($proc ??= GL::getProcAddress('getPixelTexGenParameterivSGIS'))($pname, $params);
}

function glGetPixelTransformParameterfvEXT(int $target, int $pname, $params) {
  static $proc;
  return ($proc ??= GL::getProcAddress('getPixelTransformParameterfvEXT'))($target, $pname, $params);
}

function glGetPixelTransformParameterivEXT(int $target, int $pname, $params) {
  static $proc;
  return ($proc ??= GL::getProcAddress('getPixelTransformParameterivEXT'))($target, $pname, $params);
}

function glGetPointerIndexedvEXT(int $target, int $index, $data) {
  static $proc;
  return ($proc ??= GL::getProcAddress('getPointerIndexedvEXT'))($target, $index, $data);
}

function glGetPointeri_vEXT(int $pname, int $index, $params) {
  static $proc;
  return ($proc ??= GL::getProcAddress('getPointeri_vEXT'))($pname, $index, $params);
}

function glGetPointerv(int $pname, $params) {
  static $proc;
  return ($proc ??= GL::getProcAddress('getPointerv'))($pname, $params);
}

function glGetPointervEXT(int $pname, $params) {
  static $proc;
  return ($proc ??= GL::getProcAddress('getPointervEXT'))($pname, $params);
}

function glGetPointervKHR(int $pname, $params) {
  static $proc;
  return ($proc ??= GL::getProcAddress('getPointervKHR'))($pname, $params);
}

function glGetPolygonStipple($mask) {
  static $proc;
  return ($proc ??= GL::getProcAddress('getPolygonStipple'))($mask);
}

function glGetProgramBinary(int $program, int $bufSize, $length, $binaryFormat, $binary) {
  static $proc;
  return ($proc ??= GL::getProcAddress('getProgramBinary'))($program, $bufSize, $length, $binaryFormat, $binary);
}

function glGetProgramBinaryOES(int $program, int $bufSize, $length, $binaryFormat, $binary) {
  static $proc;
  return ($proc ??= GL::getProcAddress('getProgramBinaryOES'))($program, $bufSize, $length, $binaryFormat, $binary);
}

function glGetProgramEnvParameterIivNV(int $target, int $index, $params) {
  static $proc;
  return ($proc ??= GL::getProcAddress('getProgramEnvParameterIivNV'))($target, $index, $params);
}

function glGetProgramEnvParameterIuivNV(int $target, int $index, $params) {
  static $proc;
  return ($proc ??= GL::getProcAddress('getProgramEnvParameterIuivNV'))($target, $index, $params);
}

function glGetProgramEnvParameterdvARB(int $target, int $index, $params) {
  static $proc;
  return ($proc ??= GL::getProcAddress('getProgramEnvParameterdvARB'))($target, $index, $params);
}

function glGetProgramEnvParameterfvARB(int $target, int $index, $params) {
  static $proc;
  return ($proc ??= GL::getProcAddress('getProgramEnvParameterfvARB'))($target, $index, $params);
}

function glGetProgramInfoLog(int $program, int $bufSize, $length, $infoLog) {
  static $proc;
  return ($proc ??= GL::getProcAddress('getProgramInfoLog'))($program, $bufSize, $length, $infoLog);
}

function glGetProgramInterfaceiv(int $program, int $programInterface, int $pname, $params) {
  static $proc;
  return ($proc ??= GL::getProcAddress('getProgramInterfaceiv'))($program, $programInterface, $pname, $params);
}

function glGetProgramLocalParameterIivNV(int $target, int $index, $params) {
  static $proc;
  return ($proc ??= GL::getProcAddress('getProgramLocalParameterIivNV'))($target, $index, $params);
}

function glGetProgramLocalParameterIuivNV(int $target, int $index, $params) {
  static $proc;
  return ($proc ??= GL::getProcAddress('getProgramLocalParameterIuivNV'))($target, $index, $params);
}

function glGetProgramLocalParameterdvARB(int $target, int $index, $params) {
  static $proc;
  return ($proc ??= GL::getProcAddress('getProgramLocalParameterdvARB'))($target, $index, $params);
}

function glGetProgramLocalParameterfvARB(int $target, int $index, $params) {
  static $proc;
  return ($proc ??= GL::getProcAddress('getProgramLocalParameterfvARB'))($target, $index, $params);
}

function glGetProgramNamedParameterdvNV(int $id, int $len, $name, $params) {
  static $proc;
  return ($proc ??= GL::getProcAddress('getProgramNamedParameterdvNV'))($id, $len, $name, $params);
}

function glGetProgramNamedParameterfvNV(int $id, int $len, $name, $params) {
  static $proc;
  return ($proc ??= GL::getProcAddress('getProgramNamedParameterfvNV'))($id, $len, $name, $params);
}

function glGetProgramParameterdvNV(int $target, int $index, int $pname, $params) {
  static $proc;
  return ($proc ??= GL::getProcAddress('getProgramParameterdvNV'))($target, $index, $pname, $params);
}

function glGetProgramParameterfvNV(int $target, int $index, int $pname, $params) {
  static $proc;
  return ($proc ??= GL::getProcAddress('getProgramParameterfvNV'))($target, $index, $pname, $params);
}

function glGetProgramPipelineInfoLog(int $pipeline, int $bufSize, $length, $infoLog) {
  static $proc;
  return ($proc ??= GL::getProcAddress('getProgramPipelineInfoLog'))($pipeline, $bufSize, $length, $infoLog);
}

function glGetProgramPipelineInfoLogEXT(int $pipeline, int $bufSize, $length, $infoLog) {
  static $proc;
  return ($proc ??= GL::getProcAddress('getProgramPipelineInfoLogEXT'))($pipeline, $bufSize, $length, $infoLog);
}

function glGetProgramPipelineiv(int $pipeline, int $pname, $params) {
  static $proc;
  return ($proc ??= GL::getProcAddress('getProgramPipelineiv'))($pipeline, $pname, $params);
}

function glGetProgramPipelineivEXT(int $pipeline, int $pname, $params) {
  static $proc;
  return ($proc ??= GL::getProcAddress('getProgramPipelineivEXT'))($pipeline, $pname, $params);
}

function glGetProgramResourceIndex(int $program, int $programInterface, $name) {
  static $proc;
  return ($proc ??= GL::getProcAddress('getProgramResourceIndex'))($program, $programInterface, $name);
}

function glGetProgramResourceLocation(int $program, int $programInterface, $name) {
  static $proc;
  return ($proc ??= GL::getProcAddress('getProgramResourceLocation'))($program, $programInterface, $name);
}

function glGetProgramResourceLocationIndex(int $program, int $programInterface, $name) {
  static $proc;
  return ($proc ??= GL::getProcAddress('getProgramResourceLocationIndex'))($program, $programInterface, $name);
}

function glGetProgramResourceLocationIndexEXT(int $program, int $programInterface, $name) {
  static $proc;
  return ($proc ??= GL::getProcAddress('getProgramResourceLocationIndexEXT'))($program, $programInterface, $name);
}

function glGetProgramResourceName(int $program, int $programInterface, int $index, int $bufSize, $length, $name) {
  static $proc;
  return ($proc ??= GL::getProcAddress('getProgramResourceName'))($program, $programInterface, $index, $bufSize, $length, $name);
}

function glGetProgramResourcefvNV(int $program, int $programInterface, int $index, int $propCount, $props, int $bufSize, $length, $params) {
  static $proc;
  return ($proc ??= GL::getProcAddress('getProgramResourcefvNV'))($program, $programInterface, $index, $propCount, $props, $bufSize, $length, $params);
}

function glGetProgramResourceiv(int $program, int $programInterface, int $index, int $propCount, $props, int $bufSize, $length, $params) {
  static $proc;
  return ($proc ??= GL::getProcAddress('getProgramResourceiv'))($program, $programInterface, $index, $propCount, $props, $bufSize, $length, $params);
}

function glGetProgramStageiv(int $program, int $shadertype, int $pname, $values) {
  static $proc;
  return ($proc ??= GL::getProcAddress('getProgramStageiv'))($program, $shadertype, $pname, $values);
}

function glGetProgramStringARB(int $target, int $pname, $string) {
  static $proc;
  return ($proc ??= GL::getProcAddress('getProgramStringARB'))($target, $pname, $string);
}

function glGetProgramStringNV(int $id, int $pname, $program) {
  static $proc;
  return ($proc ??= GL::getProcAddress('getProgramStringNV'))($id, $pname, $program);
}

function glGetProgramSubroutineParameteruivNV(int $target, int $index, $param) {
  static $proc;
  return ($proc ??= GL::getProcAddress('getProgramSubroutineParameteruivNV'))($target, $index, $param);
}

function glGetProgramiv(int $program, int $pname, $params) {
  static $proc;
  return ($proc ??= GL::getProcAddress('getProgramiv'))($program, $pname, $params);
}

function glGetProgramivARB(int $target, int $pname, $params) {
  static $proc;
  return ($proc ??= GL::getProcAddress('getProgramivARB'))($target, $pname, $params);
}

function glGetProgramivNV(int $id, int $pname, $params) {
  static $proc;
  return ($proc ??= GL::getProcAddress('getProgramivNV'))($id, $pname, $params);
}

function glGetQueryBufferObjecti64v(int $id, int $buffer, int $pname, int $offset) {
  static $proc;
  return ($proc ??= GL::getProcAddress('getQueryBufferObjecti64v'))($id, $buffer, $pname, $offset);
}

function glGetQueryBufferObjectiv(int $id, int $buffer, int $pname, int $offset) {
  static $proc;
  return ($proc ??= GL::getProcAddress('getQueryBufferObjectiv'))($id, $buffer, $pname, $offset);
}

function glGetQueryBufferObjectui64v(int $id, int $buffer, int $pname, int $offset) {
  static $proc;
  return ($proc ??= GL::getProcAddress('getQueryBufferObjectui64v'))($id, $buffer, $pname, $offset);
}

function glGetQueryBufferObjectuiv(int $id, int $buffer, int $pname, int $offset) {
  static $proc;
  return ($proc ??= GL::getProcAddress('getQueryBufferObjectuiv'))($id, $buffer, $pname, $offset);
}

function glGetQueryIndexediv(int $target, int $index, int $pname, $params) {
  static $proc;
  return ($proc ??= GL::getProcAddress('getQueryIndexediv'))($target, $index, $pname, $params);
}

function glGetQueryObjecti64v(int $id, int $pname, $params) {
  static $proc;
  return ($proc ??= GL::getProcAddress('getQueryObjecti64v'))($id, $pname, $params);
}

function glGetQueryObjecti64vEXT(int $id, int $pname, $params) {
  static $proc;
  return ($proc ??= GL::getProcAddress('getQueryObjecti64vEXT'))($id, $pname, $params);
}

function glGetQueryObjectiv(int $id, int $pname, $params) {
  static $proc;
  return ($proc ??= GL::getProcAddress('getQueryObjectiv'))($id, $pname, $params);
}

function glGetQueryObjectivARB(int $id, int $pname, $params) {
  static $proc;
  return ($proc ??= GL::getProcAddress('getQueryObjectivARB'))($id, $pname, $params);
}

function glGetQueryObjectivEXT(int $id, int $pname, $params) {
  static $proc;
  return ($proc ??= GL::getProcAddress('getQueryObjectivEXT'))($id, $pname, $params);
}

function glGetQueryObjectui64v(int $id, int $pname, $params) {
  static $proc;
  return ($proc ??= GL::getProcAddress('getQueryObjectui64v'))($id, $pname, $params);
}

function glGetQueryObjectui64vEXT(int $id, int $pname, $params) {
  static $proc;
  return ($proc ??= GL::getProcAddress('getQueryObjectui64vEXT'))($id, $pname, $params);
}

function glGetQueryObjectuiv(int $id, int $pname, $params) {
  static $proc;
  return ($proc ??= GL::getProcAddress('getQueryObjectuiv'))($id, $pname, $params);
}

function glGetQueryObjectuivARB(int $id, int $pname, $params) {
  static $proc;
  return ($proc ??= GL::getProcAddress('getQueryObjectuivARB'))($id, $pname, $params);
}

function glGetQueryObjectuivEXT(int $id, int $pname, $params) {
  static $proc;
  return ($proc ??= GL::getProcAddress('getQueryObjectuivEXT'))($id, $pname, $params);
}

function glGetQueryiv(int $target, int $pname, $params) {
  static $proc;
  return ($proc ??= GL::getProcAddress('getQueryiv'))($target, $pname, $params);
}

function glGetQueryivARB(int $target, int $pname, $params) {
  static $proc;
  return ($proc ??= GL::getProcAddress('getQueryivARB'))($target, $pname, $params);
}

function glGetQueryivEXT(int $target, int $pname, $params) {
  static $proc;
  return ($proc ??= GL::getProcAddress('getQueryivEXT'))($target, $pname, $params);
}

function glGetRenderbufferParameteriv(int $target, int $pname, $params) {
  static $proc;
  return ($proc ??= GL::getProcAddress('getRenderbufferParameteriv'))($target, $pname, $params);
}

function glGetRenderbufferParameterivEXT(int $target, int $pname, $params) {
  static $proc;
  return ($proc ??= GL::getProcAddress('getRenderbufferParameterivEXT'))($target, $pname, $params);
}

function glGetRenderbufferParameterivOES(int $target, int $pname, $params) {
  static $proc;
  return ($proc ??= GL::getProcAddress('getRenderbufferParameterivOES'))($target, $pname, $params);
}

function glGetSamplerParameterIiv(int $sampler, int $pname, $params) {
  static $proc;
  return ($proc ??= GL::getProcAddress('getSamplerParameterIiv'))($sampler, $pname, $params);
}

function glGetSamplerParameterIivEXT(int $sampler, int $pname, $params) {
  static $proc;
  return ($proc ??= GL::getProcAddress('getSamplerParameterIivEXT'))($sampler, $pname, $params);
}

function glGetSamplerParameterIivOES(int $sampler, int $pname, $params) {
  static $proc;
  return ($proc ??= GL::getProcAddress('getSamplerParameterIivOES'))($sampler, $pname, $params);
}

function glGetSamplerParameterIuiv(int $sampler, int $pname, $params) {
  static $proc;
  return ($proc ??= GL::getProcAddress('getSamplerParameterIuiv'))($sampler, $pname, $params);
}

function glGetSamplerParameterIuivEXT(int $sampler, int $pname, $params) {
  static $proc;
  return ($proc ??= GL::getProcAddress('getSamplerParameterIuivEXT'))($sampler, $pname, $params);
}

function glGetSamplerParameterIuivOES(int $sampler, int $pname, $params) {
  static $proc;
  return ($proc ??= GL::getProcAddress('getSamplerParameterIuivOES'))($sampler, $pname, $params);
}

function glGetSamplerParameterfv(int $sampler, int $pname, $params) {
  static $proc;
  return ($proc ??= GL::getProcAddress('getSamplerParameterfv'))($sampler, $pname, $params);
}

function glGetSamplerParameteriv(int $sampler, int $pname, $params) {
  static $proc;
  return ($proc ??= GL::getProcAddress('getSamplerParameteriv'))($sampler, $pname, $params);
}

function glGetSeparableFilter(int $target, int $format, int $type, $row, $column, $span) {
  static $proc;
  return ($proc ??= GL::getProcAddress('getSeparableFilter'))($target, $format, $type, $row, $column, $span);
}

function glGetSeparableFilterEXT(int $target, int $format, int $type, $row, $column, $span) {
  static $proc;
  return ($proc ??= GL::getProcAddress('getSeparableFilterEXT'))($target, $format, $type, $row, $column, $span);
}

function glGetShaderInfoLog(int $shader, int $bufSize, $length, $infoLog) {
  static $proc;
  return ($proc ??= GL::getProcAddress('getShaderInfoLog'))($shader, $bufSize, $length, $infoLog);
}

function glGetShaderPrecisionFormat(int $shadertype, int $precisiontype, $range, $precision) {
  static $proc;
  return ($proc ??= GL::getProcAddress('getShaderPrecisionFormat'))($shadertype, $precisiontype, $range, $precision);
}

function glGetShaderSource(int $shader, int $bufSize, $length, $source) {
  static $proc;
  return ($proc ??= GL::getProcAddress('getShaderSource'))($shader, $bufSize, $length, $source);
}

function glGetShaderSourceARB(int $obj, int $maxLength, $length, $source) {
  static $proc;
  return ($proc ??= GL::getProcAddress('getShaderSourceARB'))($obj, $maxLength, $length, $source);
}

function glGetShaderiv(int $shader, int $pname, $params) {
  static $proc;
  return ($proc ??= GL::getProcAddress('getShaderiv'))($shader, $pname, $params);
}

function glGetSharpenTexFuncSGIS(int $target, $points) {
  static $proc;
  return ($proc ??= GL::getProcAddress('getSharpenTexFuncSGIS'))($target, $points);
}

function glGetStageIndexNV(int $shadertype) {
  static $proc;
  return ($proc ??= GL::getProcAddress('getStageIndexNV'))($shadertype);
}

function glGetString(int $name) {
  static $proc;
  return ($proc ??= GL::getProcAddress('getString'))($name);
}

function glGetStringi(int $name, int $index) {
  static $proc;
  return ($proc ??= GL::getProcAddress('getStringi'))($name, $index);
}

function glGetSubroutineIndex(int $program, int $shadertype, $name) {
  static $proc;
  return ($proc ??= GL::getProcAddress('getSubroutineIndex'))($program, $shadertype, $name);
}

function glGetSubroutineUniformLocation(int $program, int $shadertype, $name) {
  static $proc;
  return ($proc ??= GL::getProcAddress('getSubroutineUniformLocation'))($program, $shadertype, $name);
}

function glGetSynciv(int $sync, int $pname, int $bufSize, $length, $values) {
  static $proc;
  return ($proc ??= GL::getProcAddress('getSynciv'))($sync, $pname, $bufSize, $length, $values);
}

function glGetSyncivAPPLE(int $sync, int $pname, int $bufSize, $length, $values) {
  static $proc;
  return ($proc ??= GL::getProcAddress('getSyncivAPPLE'))($sync, $pname, $bufSize, $length, $values);
}

function glGetTexBumpParameterfvATI(int $pname, $param) {
  static $proc;
  return ($proc ??= GL::getProcAddress('getTexBumpParameterfvATI'))($pname, $param);
}

function glGetTexBumpParameterivATI(int $pname, $param) {
  static $proc;
  return ($proc ??= GL::getProcAddress('getTexBumpParameterivATI'))($pname, $param);
}

function glGetTexEnvfv(int $target, int $pname, $params) {
  static $proc;
  return ($proc ??= GL::getProcAddress('getTexEnvfv'))($target, $pname, $params);
}

function glGetTexEnviv(int $target, int $pname, $params) {
  static $proc;
  return ($proc ??= GL::getProcAddress('getTexEnviv'))($target, $pname, $params);
}

function glGetTexEnvxv(int $target, int $pname, $params) {
  static $proc;
  return ($proc ??= GL::getProcAddress('getTexEnvxv'))($target, $pname, $params);
}

function glGetTexEnvxvOES(int $target, int $pname, $params) {
  static $proc;
  return ($proc ??= GL::getProcAddress('getTexEnvxvOES'))($target, $pname, $params);
}

function glGetTexFilterFuncSGIS(int $target, int $filter, $weights) {
  static $proc;
  return ($proc ??= GL::getProcAddress('getTexFilterFuncSGIS'))($target, $filter, $weights);
}

function glGetTexGendv(int $coord, int $pname, $params) {
  static $proc;
  return ($proc ??= GL::getProcAddress('getTexGendv'))($coord, $pname, $params);
}

function glGetTexGenfv(int $coord, int $pname, $params) {
  static $proc;
  return ($proc ??= GL::getProcAddress('getTexGenfv'))($coord, $pname, $params);
}

function glGetTexGenfvOES(int $coord, int $pname, $params) {
  static $proc;
  return ($proc ??= GL::getProcAddress('getTexGenfvOES'))($coord, $pname, $params);
}

function glGetTexGeniv(int $coord, int $pname, $params) {
  static $proc;
  return ($proc ??= GL::getProcAddress('getTexGeniv'))($coord, $pname, $params);
}

function glGetTexGenivOES(int $coord, int $pname, $params) {
  static $proc;
  return ($proc ??= GL::getProcAddress('getTexGenivOES'))($coord, $pname, $params);
}

function glGetTexGenxvOES(int $coord, int $pname, $params) {
  static $proc;
  return ($proc ??= GL::getProcAddress('getTexGenxvOES'))($coord, $pname, $params);
}

function glGetTexImage(int $target, int $level, int $format, int $type, $pixels) {
  static $proc;
  return ($proc ??= GL::getProcAddress('getTexImage'))($target, $level, $format, $type, $pixels);
}

function glGetTexLevelParameterfv(int $target, int $level, int $pname, $params) {
  static $proc;
  return ($proc ??= GL::getProcAddress('getTexLevelParameterfv'))($target, $level, $pname, $params);
}

function glGetTexLevelParameteriv(int $target, int $level, int $pname, $params) {
  static $proc;
  return ($proc ??= GL::getProcAddress('getTexLevelParameteriv'))($target, $level, $pname, $params);
}

function glGetTexLevelParameterxvOES(int $target, int $level, int $pname, $params) {
  static $proc;
  return ($proc ??= GL::getProcAddress('getTexLevelParameterxvOES'))($target, $level, $pname, $params);
}

function glGetTexParameterIiv(int $target, int $pname, $params) {
  static $proc;
  return ($proc ??= GL::getProcAddress('getTexParameterIiv'))($target, $pname, $params);
}

function glGetTexParameterIivEXT(int $target, int $pname, $params) {
  static $proc;
  return ($proc ??= GL::getProcAddress('getTexParameterIivEXT'))($target, $pname, $params);
}

function glGetTexParameterIivOES(int $target, int $pname, $params) {
  static $proc;
  return ($proc ??= GL::getProcAddress('getTexParameterIivOES'))($target, $pname, $params);
}

function glGetTexParameterIuiv(int $target, int $pname, $params) {
  static $proc;
  return ($proc ??= GL::getProcAddress('getTexParameterIuiv'))($target, $pname, $params);
}

function glGetTexParameterIuivEXT(int $target, int $pname, $params) {
  static $proc;
  return ($proc ??= GL::getProcAddress('getTexParameterIuivEXT'))($target, $pname, $params);
}

function glGetTexParameterIuivOES(int $target, int $pname, $params) {
  static $proc;
  return ($proc ??= GL::getProcAddress('getTexParameterIuivOES'))($target, $pname, $params);
}

function glGetTexParameterPointervAPPLE(int $target, int $pname, $params) {
  static $proc;
  return ($proc ??= GL::getProcAddress('getTexParameterPointervAPPLE'))($target, $pname, $params);
}

function glGetTexParameterfv(int $target, int $pname, $params) {
  static $proc;
  return ($proc ??= GL::getProcAddress('getTexParameterfv'))($target, $pname, $params);
}

function glGetTexParameteriv(int $target, int $pname, $params) {
  static $proc;
  return ($proc ??= GL::getProcAddress('getTexParameteriv'))($target, $pname, $params);
}

function glGetTexParameterxv(int $target, int $pname, $params) {
  static $proc;
  return ($proc ??= GL::getProcAddress('getTexParameterxv'))($target, $pname, $params);
}

function glGetTexParameterxvOES(int $target, int $pname, $params) {
  static $proc;
  return ($proc ??= GL::getProcAddress('getTexParameterxvOES'))($target, $pname, $params);
}

function glGetTextureHandleARB(int $texture) {
  static $proc;
  return ($proc ??= GL::getProcAddress('getTextureHandleARB'))($texture);
}

function glGetTextureHandleIMG(int $texture) {
  static $proc;
  return ($proc ??= GL::getProcAddress('getTextureHandleIMG'))($texture);
}

function glGetTextureHandleNV(int $texture) {
  static $proc;
  return ($proc ??= GL::getProcAddress('getTextureHandleNV'))($texture);
}

function glGetTextureImage(int $texture, int $level, int $format, int $type, int $bufSize, $pixels) {
  static $proc;
  return ($proc ??= GL::getProcAddress('getTextureImage'))($texture, $level, $format, $type, $bufSize, $pixels);
}

function glGetTextureImageEXT(int $texture, int $target, int $level, int $format, int $type, $pixels) {
  static $proc;
  return ($proc ??= GL::getProcAddress('getTextureImageEXT'))($texture, $target, $level, $format, $type, $pixels);
}

function glGetTextureLevelParameterfv(int $texture, int $level, int $pname, $params) {
  static $proc;
  return ($proc ??= GL::getProcAddress('getTextureLevelParameterfv'))($texture, $level, $pname, $params);
}

function glGetTextureLevelParameterfvEXT(int $texture, int $target, int $level, int $pname, $params) {
  static $proc;
  return ($proc ??= GL::getProcAddress('getTextureLevelParameterfvEXT'))($texture, $target, $level, $pname, $params);
}

function glGetTextureLevelParameteriv(int $texture, int $level, int $pname, $params) {
  static $proc;
  return ($proc ??= GL::getProcAddress('getTextureLevelParameteriv'))($texture, $level, $pname, $params);
}

function glGetTextureLevelParameterivEXT(int $texture, int $target, int $level, int $pname, $params) {
  static $proc;
  return ($proc ??= GL::getProcAddress('getTextureLevelParameterivEXT'))($texture, $target, $level, $pname, $params);
}

function glGetTextureParameterIiv(int $texture, int $pname, $params) {
  static $proc;
  return ($proc ??= GL::getProcAddress('getTextureParameterIiv'))($texture, $pname, $params);
}

function glGetTextureParameterIivEXT(int $texture, int $target, int $pname, $params) {
  static $proc;
  return ($proc ??= GL::getProcAddress('getTextureParameterIivEXT'))($texture, $target, $pname, $params);
}

function glGetTextureParameterIuiv(int $texture, int $pname, $params) {
  static $proc;
  return ($proc ??= GL::getProcAddress('getTextureParameterIuiv'))($texture, $pname, $params);
}

function glGetTextureParameterIuivEXT(int $texture, int $target, int $pname, $params) {
  static $proc;
  return ($proc ??= GL::getProcAddress('getTextureParameterIuivEXT'))($texture, $target, $pname, $params);
}

function glGetTextureParameterfv(int $texture, int $pname, $params) {
  static $proc;
  return ($proc ??= GL::getProcAddress('getTextureParameterfv'))($texture, $pname, $params);
}

function glGetTextureParameterfvEXT(int $texture, int $target, int $pname, $params) {
  static $proc;
  return ($proc ??= GL::getProcAddress('getTextureParameterfvEXT'))($texture, $target, $pname, $params);
}

function glGetTextureParameteriv(int $texture, int $pname, $params) {
  static $proc;
  return ($proc ??= GL::getProcAddress('getTextureParameteriv'))($texture, $pname, $params);
}

function glGetTextureParameterivEXT(int $texture, int $target, int $pname, $params) {
  static $proc;
  return ($proc ??= GL::getProcAddress('getTextureParameterivEXT'))($texture, $target, $pname, $params);
}

function glGetTextureSamplerHandleARB(int $texture, int $sampler) {
  static $proc;
  return ($proc ??= GL::getProcAddress('getTextureSamplerHandleARB'))($texture, $sampler);
}

function glGetTextureSamplerHandleIMG(int $texture, int $sampler) {
  static $proc;
  return ($proc ??= GL::getProcAddress('getTextureSamplerHandleIMG'))($texture, $sampler);
}

function glGetTextureSamplerHandleNV(int $texture, int $sampler) {
  static $proc;
  return ($proc ??= GL::getProcAddress('getTextureSamplerHandleNV'))($texture, $sampler);
}

function glGetTextureSubImage(int $texture, int $level, int $xoffset, int $yoffset, int $zoffset, int $width, int $height, int $depth, int $format, int $type, int $bufSize, $pixels) {
  static $proc;
  return ($proc ??= GL::getProcAddress('getTextureSubImage'))($texture, $level, $xoffset, $yoffset, $zoffset, $width, $height, $depth, $format, $type, $bufSize, $pixels);
}

function glGetTrackMatrixivNV(int $target, int $address, int $pname, $params) {
  static $proc;
  return ($proc ??= GL::getProcAddress('getTrackMatrixivNV'))($target, $address, $pname, $params);
}

function glGetTransformFeedbackVarying(int $program, int $index, int $bufSize, $length, $size, $type, $name) {
  static $proc;
  return ($proc ??= GL::getProcAddress('getTransformFeedbackVarying'))($program, $index, $bufSize, $length, $size, $type, $name);
}

function glGetTransformFeedbackVaryingEXT(int $program, int $index, int $bufSize, $length, $size, $type, $name) {
  static $proc;
  return ($proc ??= GL::getProcAddress('getTransformFeedbackVaryingEXT'))($program, $index, $bufSize, $length, $size, $type, $name);
}

function glGetTransformFeedbackVaryingNV(int $program, int $index, $location) {
  static $proc;
  return ($proc ??= GL::getProcAddress('getTransformFeedbackVaryingNV'))($program, $index, $location);
}

function glGetTransformFeedbacki64_v(int $xfb, int $pname, int $index, $param) {
  static $proc;
  return ($proc ??= GL::getProcAddress('getTransformFeedbacki64_v'))($xfb, $pname, $index, $param);
}

function glGetTransformFeedbacki_v(int $xfb, int $pname, int $index, $param) {
  static $proc;
  return ($proc ??= GL::getProcAddress('getTransformFeedbacki_v'))($xfb, $pname, $index, $param);
}

function glGetTransformFeedbackiv(int $xfb, int $pname, $param) {
  static $proc;
  return ($proc ??= GL::getProcAddress('getTransformFeedbackiv'))($xfb, $pname, $param);
}

function glGetTranslatedShaderSourceANGLE(int $shader, int $bufsize, $length, $source) {
  static $proc;
  return ($proc ??= GL::getProcAddress('getTranslatedShaderSourceANGLE'))($shader, $bufsize, $length, $source);
}

function glGetUniformBlockIndex(int $program, $uniformBlockName) {
  static $proc;
  return ($proc ??= GL::getProcAddress('getUniformBlockIndex'))($program, $uniformBlockName);
}

function glGetUniformBufferSizeEXT(int $program, int $location) {
  static $proc;
  return ($proc ??= GL::getProcAddress('getUniformBufferSizeEXT'))($program, $location);
}

function glGetUniformIndices(int $program, int $uniformCount, $uniformNames, $uniformIndices) {
  static $proc;
  return ($proc ??= GL::getProcAddress('getUniformIndices'))($program, $uniformCount, $uniformNames, $uniformIndices);
}

function glGetUniformLocation(int $program, $name) {
  static $proc;
  return ($proc ??= GL::getProcAddress('getUniformLocation'))($program, $name);
}

function glGetUniformLocationARB(int $programObj, $name) {
  static $proc;
  return ($proc ??= GL::getProcAddress('getUniformLocationARB'))($programObj, $name);
}

function glGetUniformOffsetEXT(int $program, int $location) {
  static $proc;
  return ($proc ??= GL::getProcAddress('getUniformOffsetEXT'))($program, $location);
}

function glGetUniformSubroutineuiv(int $shadertype, int $location, $params) {
  static $proc;
  return ($proc ??= GL::getProcAddress('getUniformSubroutineuiv'))($shadertype, $location, $params);
}

function glGetUniformdv(int $program, int $location, $params) {
  static $proc;
  return ($proc ??= GL::getProcAddress('getUniformdv'))($program, $location, $params);
}

function glGetUniformfv(int $program, int $location, $params) {
  static $proc;
  return ($proc ??= GL::getProcAddress('getUniformfv'))($program, $location, $params);
}

function glGetUniformfvARB(int $programObj, int $location, $params) {
  static $proc;
  return ($proc ??= GL::getProcAddress('getUniformfvARB'))($programObj, $location, $params);
}

function glGetUniformi64vARB(int $program, int $location, $params) {
  static $proc;
  return ($proc ??= GL::getProcAddress('getUniformi64vARB'))($program, $location, $params);
}

function glGetUniformi64vNV(int $program, int $location, $params) {
  static $proc;
  return ($proc ??= GL::getProcAddress('getUniformi64vNV'))($program, $location, $params);
}

function glGetUniformiv(int $program, int $location, $params) {
  static $proc;
  return ($proc ??= GL::getProcAddress('getUniformiv'))($program, $location, $params);
}

function glGetUniformivARB(int $programObj, int $location, $params) {
  static $proc;
  return ($proc ??= GL::getProcAddress('getUniformivARB'))($programObj, $location, $params);
}

function glGetUniformui64vARB(int $program, int $location, $params) {
  static $proc;
  return ($proc ??= GL::getProcAddress('getUniformui64vARB'))($program, $location, $params);
}

function glGetUniformui64vNV(int $program, int $location, $params) {
  static $proc;
  return ($proc ??= GL::getProcAddress('getUniformui64vNV'))($program, $location, $params);
}

function glGetUniformuiv(int $program, int $location, $params) {
  static $proc;
  return ($proc ??= GL::getProcAddress('getUniformuiv'))($program, $location, $params);
}

function glGetUniformuivEXT(int $program, int $location, $params) {
  static $proc;
  return ($proc ??= GL::getProcAddress('getUniformuivEXT'))($program, $location, $params);
}

function glGetVariantArrayObjectfvATI(int $id, int $pname, $params) {
  static $proc;
  return ($proc ??= GL::getProcAddress('getVariantArrayObjectfvATI'))($id, $pname, $params);
}

function glGetVariantArrayObjectivATI(int $id, int $pname, $params) {
  static $proc;
  return ($proc ??= GL::getProcAddress('getVariantArrayObjectivATI'))($id, $pname, $params);
}

function glGetVariantBooleanvEXT(int $id, int $value, $data) {
  static $proc;
  return ($proc ??= GL::getProcAddress('getVariantBooleanvEXT'))($id, $value, $data);
}

function glGetVariantFloatvEXT(int $id, int $value, $data) {
  static $proc;
  return ($proc ??= GL::getProcAddress('getVariantFloatvEXT'))($id, $value, $data);
}

function glGetVariantIntegervEXT(int $id, int $value, $data) {
  static $proc;
  return ($proc ??= GL::getProcAddress('getVariantIntegervEXT'))($id, $value, $data);
}

function glGetVariantPointervEXT(int $id, int $value, $data) {
  static $proc;
  return ($proc ??= GL::getProcAddress('getVariantPointervEXT'))($id, $value, $data);
}

function glGetVaryingLocationNV(int $program, $name) {
  static $proc;
  return ($proc ??= GL::getProcAddress('getVaryingLocationNV'))($program, $name);
}

function glGetVertexArrayIndexed64iv(int $vaobj, int $index, int $pname, $param) {
  static $proc;
  return ($proc ??= GL::getProcAddress('getVertexArrayIndexed64iv'))($vaobj, $index, $pname, $param);
}

function glGetVertexArrayIndexediv(int $vaobj, int $index, int $pname, $param) {
  static $proc;
  return ($proc ??= GL::getProcAddress('getVertexArrayIndexediv'))($vaobj, $index, $pname, $param);
}

function glGetVertexArrayIntegeri_vEXT(int $vaobj, int $index, int $pname, $param) {
  static $proc;
  return ($proc ??= GL::getProcAddress('getVertexArrayIntegeri_vEXT'))($vaobj, $index, $pname, $param);
}

function glGetVertexArrayIntegervEXT(int $vaobj, int $pname, $param) {
  static $proc;
  return ($proc ??= GL::getProcAddress('getVertexArrayIntegervEXT'))($vaobj, $pname, $param);
}

function glGetVertexArrayPointeri_vEXT(int $vaobj, int $index, int $pname, $param) {
  static $proc;
  return ($proc ??= GL::getProcAddress('getVertexArrayPointeri_vEXT'))($vaobj, $index, $pname, $param);
}

function glGetVertexArrayPointervEXT(int $vaobj, int $pname, $param) {
  static $proc;
  return ($proc ??= GL::getProcAddress('getVertexArrayPointervEXT'))($vaobj, $pname, $param);
}

function glGetVertexArrayiv(int $vaobj, int $pname, $param) {
  static $proc;
  return ($proc ??= GL::getProcAddress('getVertexArrayiv'))($vaobj, $pname, $param);
}

function glGetVertexAttribArrayObjectfvATI(int $index, int $pname, $params) {
  static $proc;
  return ($proc ??= GL::getProcAddress('getVertexAttribArrayObjectfvATI'))($index, $pname, $params);
}

function glGetVertexAttribArrayObjectivATI(int $index, int $pname, $params) {
  static $proc;
  return ($proc ??= GL::getProcAddress('getVertexAttribArrayObjectivATI'))($index, $pname, $params);
}

function glGetVertexAttribIiv(int $index, int $pname, $params) {
  static $proc;
  return ($proc ??= GL::getProcAddress('getVertexAttribIiv'))($index, $pname, $params);
}

function glGetVertexAttribIivEXT(int $index, int $pname, $params) {
  static $proc;
  return ($proc ??= GL::getProcAddress('getVertexAttribIivEXT'))($index, $pname, $params);
}

function glGetVertexAttribIuiv(int $index, int $pname, $params) {
  static $proc;
  return ($proc ??= GL::getProcAddress('getVertexAttribIuiv'))($index, $pname, $params);
}

function glGetVertexAttribIuivEXT(int $index, int $pname, $params) {
  static $proc;
  return ($proc ??= GL::getProcAddress('getVertexAttribIuivEXT'))($index, $pname, $params);
}

function glGetVertexAttribLdv(int $index, int $pname, $params) {
  static $proc;
  return ($proc ??= GL::getProcAddress('getVertexAttribLdv'))($index, $pname, $params);
}

function glGetVertexAttribLdvEXT(int $index, int $pname, $params) {
  static $proc;
  return ($proc ??= GL::getProcAddress('getVertexAttribLdvEXT'))($index, $pname, $params);
}

function glGetVertexAttribLi64vNV(int $index, int $pname, $params) {
  static $proc;
  return ($proc ??= GL::getProcAddress('getVertexAttribLi64vNV'))($index, $pname, $params);
}

function glGetVertexAttribLui64vARB(int $index, int $pname, $params) {
  static $proc;
  return ($proc ??= GL::getProcAddress('getVertexAttribLui64vARB'))($index, $pname, $params);
}

function glGetVertexAttribLui64vNV(int $index, int $pname, $params) {
  static $proc;
  return ($proc ??= GL::getProcAddress('getVertexAttribLui64vNV'))($index, $pname, $params);
}

function glGetVertexAttribPointerv(int $index, int $pname, $pointer) {
  static $proc;
  return ($proc ??= GL::getProcAddress('getVertexAttribPointerv'))($index, $pname, $pointer);
}

function glGetVertexAttribPointervARB(int $index, int $pname, $pointer) {
  static $proc;
  return ($proc ??= GL::getProcAddress('getVertexAttribPointervARB'))($index, $pname, $pointer);
}

function glGetVertexAttribPointervNV(int $index, int $pname, $pointer) {
  static $proc;
  return ($proc ??= GL::getProcAddress('getVertexAttribPointervNV'))($index, $pname, $pointer);
}

function glGetVertexAttribdv(int $index, int $pname, $params) {
  static $proc;
  return ($proc ??= GL::getProcAddress('getVertexAttribdv'))($index, $pname, $params);
}

function glGetVertexAttribdvARB(int $index, int $pname, $params) {
  static $proc;
  return ($proc ??= GL::getProcAddress('getVertexAttribdvARB'))($index, $pname, $params);
}

function glGetVertexAttribdvNV(int $index, int $pname, $params) {
  static $proc;
  return ($proc ??= GL::getProcAddress('getVertexAttribdvNV'))($index, $pname, $params);
}

function glGetVertexAttribfv(int $index, int $pname, $params) {
  static $proc;
  return ($proc ??= GL::getProcAddress('getVertexAttribfv'))($index, $pname, $params);
}

function glGetVertexAttribfvARB(int $index, int $pname, $params) {
  static $proc;
  return ($proc ??= GL::getProcAddress('getVertexAttribfvARB'))($index, $pname, $params);
}

function glGetVertexAttribfvNV(int $index, int $pname, $params) {
  static $proc;
  return ($proc ??= GL::getProcAddress('getVertexAttribfvNV'))($index, $pname, $params);
}

function glGetVertexAttribiv(int $index, int $pname, $params) {
  static $proc;
  return ($proc ??= GL::getProcAddress('getVertexAttribiv'))($index, $pname, $params);
}

function glGetVertexAttribivARB(int $index, int $pname, $params) {
  static $proc;
  return ($proc ??= GL::getProcAddress('getVertexAttribivARB'))($index, $pname, $params);
}

function glGetVertexAttribivNV(int $index, int $pname, $params) {
  static $proc;
  return ($proc ??= GL::getProcAddress('getVertexAttribivNV'))($index, $pname, $params);
}

function glGetVideoCaptureStreamdvNV(int $video_capture_slot, int $stream, int $pname, $params) {
  static $proc;
  return ($proc ??= GL::getProcAddress('getVideoCaptureStreamdvNV'))($video_capture_slot, $stream, $pname, $params);
}

function glGetVideoCaptureStreamfvNV(int $video_capture_slot, int $stream, int $pname, $params) {
  static $proc;
  return ($proc ??= GL::getProcAddress('getVideoCaptureStreamfvNV'))($video_capture_slot, $stream, $pname, $params);
}

function glGetVideoCaptureStreamivNV(int $video_capture_slot, int $stream, int $pname, $params) {
  static $proc;
  return ($proc ??= GL::getProcAddress('getVideoCaptureStreamivNV'))($video_capture_slot, $stream, $pname, $params);
}

function glGetVideoCaptureivNV(int $video_capture_slot, int $pname, $params) {
  static $proc;
  return ($proc ??= GL::getProcAddress('getVideoCaptureivNV'))($video_capture_slot, $pname, $params);
}

function glGetVideoi64vNV(int $video_slot, int $pname, $params) {
  static $proc;
  return ($proc ??= GL::getProcAddress('getVideoi64vNV'))($video_slot, $pname, $params);
}

function glGetVideoivNV(int $video_slot, int $pname, $params) {
  static $proc;
  return ($proc ??= GL::getProcAddress('getVideoivNV'))($video_slot, $pname, $params);
}

function glGetVideoui64vNV(int $video_slot, int $pname, $params) {
  static $proc;
  return ($proc ??= GL::getProcAddress('getVideoui64vNV'))($video_slot, $pname, $params);
}

function glGetVideouivNV(int $video_slot, int $pname, $params) {
  static $proc;
  return ($proc ??= GL::getProcAddress('getVideouivNV'))($video_slot, $pname, $params);
}

function glGetnColorTable(int $target, int $format, int $type, int $bufSize, $table) {
  static $proc;
  return ($proc ??= GL::getProcAddress('getnColorTable'))($target, $format, $type, $bufSize, $table);
}

function glGetnColorTableARB(int $target, int $format, int $type, int $bufSize, $table) {
  static $proc;
  return ($proc ??= GL::getProcAddress('getnColorTableARB'))($target, $format, $type, $bufSize, $table);
}

function glGetnCompressedTexImage(int $target, int $lod, int $bufSize, $pixels) {
  static $proc;
  return ($proc ??= GL::getProcAddress('getnCompressedTexImage'))($target, $lod, $bufSize, $pixels);
}

function glGetnCompressedTexImageARB(int $target, int $lod, int $bufSize, $img) {
  static $proc;
  return ($proc ??= GL::getProcAddress('getnCompressedTexImageARB'))($target, $lod, $bufSize, $img);
}

function glGetnConvolutionFilter(int $target, int $format, int $type, int $bufSize, $image) {
  static $proc;
  return ($proc ??= GL::getProcAddress('getnConvolutionFilter'))($target, $format, $type, $bufSize, $image);
}

function glGetnConvolutionFilterARB(int $target, int $format, int $type, int $bufSize, $image) {
  static $proc;
  return ($proc ??= GL::getProcAddress('getnConvolutionFilterARB'))($target, $format, $type, $bufSize, $image);
}

function glGetnHistogram(int $target, int $reset, int $format, int $type, int $bufSize, $values) {
  static $proc;
  return ($proc ??= GL::getProcAddress('getnHistogram'))($target, $reset, $format, $type, $bufSize, $values);
}

function glGetnHistogramARB(int $target, int $reset, int $format, int $type, int $bufSize, $values) {
  static $proc;
  return ($proc ??= GL::getProcAddress('getnHistogramARB'))($target, $reset, $format, $type, $bufSize, $values);
}

function glGetnMapdv(int $target, int $query, int $bufSize, $v) {
  static $proc;
  return ($proc ??= GL::getProcAddress('getnMapdv'))($target, $query, $bufSize, $v);
}

function glGetnMapdvARB(int $target, int $query, int $bufSize, $v) {
  static $proc;
  return ($proc ??= GL::getProcAddress('getnMapdvARB'))($target, $query, $bufSize, $v);
}

function glGetnMapfv(int $target, int $query, int $bufSize, $v) {
  static $proc;
  return ($proc ??= GL::getProcAddress('getnMapfv'))($target, $query, $bufSize, $v);
}

function glGetnMapfvARB(int $target, int $query, int $bufSize, $v) {
  static $proc;
  return ($proc ??= GL::getProcAddress('getnMapfvARB'))($target, $query, $bufSize, $v);
}

function glGetnMapiv(int $target, int $query, int $bufSize, $v) {
  static $proc;
  return ($proc ??= GL::getProcAddress('getnMapiv'))($target, $query, $bufSize, $v);
}

function glGetnMapivARB(int $target, int $query, int $bufSize, $v) {
  static $proc;
  return ($proc ??= GL::getProcAddress('getnMapivARB'))($target, $query, $bufSize, $v);
}

function glGetnMinmax(int $target, int $reset, int $format, int $type, int $bufSize, $values) {
  static $proc;
  return ($proc ??= GL::getProcAddress('getnMinmax'))($target, $reset, $format, $type, $bufSize, $values);
}

function glGetnMinmaxARB(int $target, int $reset, int $format, int $type, int $bufSize, $values) {
  static $proc;
  return ($proc ??= GL::getProcAddress('getnMinmaxARB'))($target, $reset, $format, $type, $bufSize, $values);
}

function glGetnPixelMapfv(int $map, int $bufSize, $values) {
  static $proc;
  return ($proc ??= GL::getProcAddress('getnPixelMapfv'))($map, $bufSize, $values);
}

function glGetnPixelMapfvARB(int $map, int $bufSize, $values) {
  static $proc;
  return ($proc ??= GL::getProcAddress('getnPixelMapfvARB'))($map, $bufSize, $values);
}

function glGetnPixelMapuiv(int $map, int $bufSize, $values) {
  static $proc;
  return ($proc ??= GL::getProcAddress('getnPixelMapuiv'))($map, $bufSize, $values);
}

function glGetnPixelMapuivARB(int $map, int $bufSize, $values) {
  static $proc;
  return ($proc ??= GL::getProcAddress('getnPixelMapuivARB'))($map, $bufSize, $values);
}

function glGetnPixelMapusv(int $map, int $bufSize, $values) {
  static $proc;
  return ($proc ??= GL::getProcAddress('getnPixelMapusv'))($map, $bufSize, $values);
}

function glGetnPixelMapusvARB(int $map, int $bufSize, $values) {
  static $proc;
  return ($proc ??= GL::getProcAddress('getnPixelMapusvARB'))($map, $bufSize, $values);
}

function glGetnPolygonStipple(int $bufSize, $pattern) {
  static $proc;
  return ($proc ??= GL::getProcAddress('getnPolygonStipple'))($bufSize, $pattern);
}

function glGetnPolygonStippleARB(int $bufSize, $pattern) {
  static $proc;
  return ($proc ??= GL::getProcAddress('getnPolygonStippleARB'))($bufSize, $pattern);
}

function glGetnSeparableFilter(int $target, int $format, int $type, int $rowBufSize, $row, int $columnBufSize, $column, $span) {
  static $proc;
  return ($proc ??= GL::getProcAddress('getnSeparableFilter'))($target, $format, $type, $rowBufSize, $row, $columnBufSize, $column, $span);
}

function glGetnSeparableFilterARB(int $target, int $format, int $type, int $rowBufSize, $row, int $columnBufSize, $column, $span) {
  static $proc;
  return ($proc ??= GL::getProcAddress('getnSeparableFilterARB'))($target, $format, $type, $rowBufSize, $row, $columnBufSize, $column, $span);
}

function glGetnTexImage(int $target, int $level, int $format, int $type, int $bufSize, $pixels) {
  static $proc;
  return ($proc ??= GL::getProcAddress('getnTexImage'))($target, $level, $format, $type, $bufSize, $pixels);
}

function glGetnTexImageARB(int $target, int $level, int $format, int $type, int $bufSize, $img) {
  static $proc;
  return ($proc ??= GL::getProcAddress('getnTexImageARB'))($target, $level, $format, $type, $bufSize, $img);
}

function glGetnUniformdv(int $program, int $location, int $bufSize, $params) {
  static $proc;
  return ($proc ??= GL::getProcAddress('getnUniformdv'))($program, $location, $bufSize, $params);
}

function glGetnUniformdvARB(int $program, int $location, int $bufSize, $params) {
  static $proc;
  return ($proc ??= GL::getProcAddress('getnUniformdvARB'))($program, $location, $bufSize, $params);
}

function glGetnUniformfv(int $program, int $location, int $bufSize, $params) {
  static $proc;
  return ($proc ??= GL::getProcAddress('getnUniformfv'))($program, $location, $bufSize, $params);
}

function glGetnUniformfvARB(int $program, int $location, int $bufSize, $params) {
  static $proc;
  return ($proc ??= GL::getProcAddress('getnUniformfvARB'))($program, $location, $bufSize, $params);
}

function glGetnUniformfvEXT(int $program, int $location, int $bufSize, $params) {
  static $proc;
  return ($proc ??= GL::getProcAddress('getnUniformfvEXT'))($program, $location, $bufSize, $params);
}

function glGetnUniformfvKHR(int $program, int $location, int $bufSize, $params) {
  static $proc;
  return ($proc ??= GL::getProcAddress('getnUniformfvKHR'))($program, $location, $bufSize, $params);
}

function glGetnUniformi64vARB(int $program, int $location, int $bufSize, $params) {
  static $proc;
  return ($proc ??= GL::getProcAddress('getnUniformi64vARB'))($program, $location, $bufSize, $params);
}

function glGetnUniformiv(int $program, int $location, int $bufSize, $params) {
  static $proc;
  return ($proc ??= GL::getProcAddress('getnUniformiv'))($program, $location, $bufSize, $params);
}

function glGetnUniformivARB(int $program, int $location, int $bufSize, $params) {
  static $proc;
  return ($proc ??= GL::getProcAddress('getnUniformivARB'))($program, $location, $bufSize, $params);
}

function glGetnUniformivEXT(int $program, int $location, int $bufSize, $params) {
  static $proc;
  return ($proc ??= GL::getProcAddress('getnUniformivEXT'))($program, $location, $bufSize, $params);
}

function glGetnUniformivKHR(int $program, int $location, int $bufSize, $params) {
  static $proc;
  return ($proc ??= GL::getProcAddress('getnUniformivKHR'))($program, $location, $bufSize, $params);
}

function glGetnUniformui64vARB(int $program, int $location, int $bufSize, $params) {
  static $proc;
  return ($proc ??= GL::getProcAddress('getnUniformui64vARB'))($program, $location, $bufSize, $params);
}

function glGetnUniformuiv(int $program, int $location, int $bufSize, $params) {
  static $proc;
  return ($proc ??= GL::getProcAddress('getnUniformuiv'))($program, $location, $bufSize, $params);
}

function glGetnUniformuivARB(int $program, int $location, int $bufSize, $params) {
  static $proc;
  return ($proc ??= GL::getProcAddress('getnUniformuivARB'))($program, $location, $bufSize, $params);
}

function glGetnUniformuivKHR(int $program, int $location, int $bufSize, $params) {
  static $proc;
  return ($proc ??= GL::getProcAddress('getnUniformuivKHR'))($program, $location, $bufSize, $params);
}

function glGlobalAlphaFactorbSUN(int $factor) {
  static $proc;
  return ($proc ??= GL::getProcAddress('globalAlphaFactorbSUN'))($factor);
}

function glGlobalAlphaFactordSUN(float $factor) {
  static $proc;
  return ($proc ??= GL::getProcAddress('globalAlphaFactordSUN'))($factor);
}

function glGlobalAlphaFactorfSUN(float $factor) {
  static $proc;
  return ($proc ??= GL::getProcAddress('globalAlphaFactorfSUN'))($factor);
}

function glGlobalAlphaFactoriSUN(int $factor) {
  static $proc;
  return ($proc ??= GL::getProcAddress('globalAlphaFactoriSUN'))($factor);
}

function glGlobalAlphaFactorsSUN(int $factor) {
  static $proc;
  return ($proc ??= GL::getProcAddress('globalAlphaFactorsSUN'))($factor);
}

function glGlobalAlphaFactorubSUN(int $factor) {
  static $proc;
  return ($proc ??= GL::getProcAddress('globalAlphaFactorubSUN'))($factor);
}

function glGlobalAlphaFactoruiSUN(int $factor) {
  static $proc;
  return ($proc ??= GL::getProcAddress('globalAlphaFactoruiSUN'))($factor);
}

function glGlobalAlphaFactorusSUN(int $factor) {
  static $proc;
  return ($proc ??= GL::getProcAddress('globalAlphaFactorusSUN'))($factor);
}

function glHint(int $target, int $mode) {
  static $proc;
  return ($proc ??= GL::getProcAddress('hint'))($target, $mode);
}

function glHintPGI(int $target, int $mode) {
  static $proc;
  return ($proc ??= GL::getProcAddress('hintPGI'))($target, $mode);
}

function glHistogram(int $target, int $width, int $internalformat, int $sink) {
  static $proc;
  return ($proc ??= GL::getProcAddress('histogram'))($target, $width, $internalformat, $sink);
}

function glHistogramEXT(int $target, int $width, int $internalformat, int $sink) {
  static $proc;
  return ($proc ??= GL::getProcAddress('histogramEXT'))($target, $width, $internalformat, $sink);
}

function glIglooInterfaceSGIX(int $pname, $params) {
  static $proc;
  return ($proc ??= GL::getProcAddress('iglooInterfaceSGIX'))($pname, $params);
}

function glImageTransformParameterfHP(int $target, int $pname, float $param) {
  static $proc;
  return ($proc ??= GL::getProcAddress('imageTransformParameterfHP'))($target, $pname, $param);
}

function glImageTransformParameterfvHP(int $target, int $pname, $params) {
  static $proc;
  return ($proc ??= GL::getProcAddress('imageTransformParameterfvHP'))($target, $pname, $params);
}

function glImageTransformParameteriHP(int $target, int $pname, int $param) {
  static $proc;
  return ($proc ??= GL::getProcAddress('imageTransformParameteriHP'))($target, $pname, $param);
}

function glImageTransformParameterivHP(int $target, int $pname, $params) {
  static $proc;
  return ($proc ??= GL::getProcAddress('imageTransformParameterivHP'))($target, $pname, $params);
}

function glImportSyncEXT(int $external_sync_type, int $external_sync, int $flags) {
  static $proc;
  return ($proc ??= GL::getProcAddress('importSyncEXT'))($external_sync_type, $external_sync, $flags);
}

function glIndexFormatNV(int $type, int $stride) {
  static $proc;
  return ($proc ??= GL::getProcAddress('indexFormatNV'))($type, $stride);
}

function glIndexFuncEXT(int $func, $ref) {
  static $proc;
  return ($proc ??= GL::getProcAddress('indexFuncEXT'))($func, $ref);
}

function glIndexMask(int $mask) {
  static $proc;
  return ($proc ??= GL::getProcAddress('indexMask'))($mask);
}

function glIndexMaterialEXT(int $face, int $mode) {
  static $proc;
  return ($proc ??= GL::getProcAddress('indexMaterialEXT'))($face, $mode);
}

function glIndexPointer(int $type, int $stride, $pointer) {
  static $proc;
  return ($proc ??= GL::getProcAddress('indexPointer'))($type, $stride, $pointer);
}

function glIndexPointerEXT(int $type, int $stride, int $count, $pointer) {
  static $proc;
  return ($proc ??= GL::getProcAddress('indexPointerEXT'))($type, $stride, $count, $pointer);
}

function glIndexPointerListIBM(int $type, int $stride, $pointer, int $ptrstride) {
  static $proc;
  return ($proc ??= GL::getProcAddress('indexPointerListIBM'))($type, $stride, $pointer, $ptrstride);
}

function glIndexd(float $c) {
  static $proc;
  return ($proc ??= GL::getProcAddress('indexd'))($c);
}

function glIndexdv($c) {
  static $proc;
  return ($proc ??= GL::getProcAddress('indexdv'))($c);
}

function glIndexf(float $c) {
  static $proc;
  return ($proc ??= GL::getProcAddress('indexf'))($c);
}

function glIndexfv($c) {
  static $proc;
  return ($proc ??= GL::getProcAddress('indexfv'))($c);
}

function glIndexi(int $c) {
  static $proc;
  return ($proc ??= GL::getProcAddress('indexi'))($c);
}

function glIndexiv($c) {
  static $proc;
  return ($proc ??= GL::getProcAddress('indexiv'))($c);
}

function glIndexs(int $c) {
  static $proc;
  return ($proc ??= GL::getProcAddress('indexs'))($c);
}

function glIndexsv($c) {
  static $proc;
  return ($proc ??= GL::getProcAddress('indexsv'))($c);
}

function glIndexub(int $c) {
  static $proc;
  return ($proc ??= GL::getProcAddress('indexub'))($c);
}

function glIndexubv($c) {
  static $proc;
  return ($proc ??= GL::getProcAddress('indexubv'))($c);
}

function glIndexxOES(int $component) {
  static $proc;
  return ($proc ??= GL::getProcAddress('indexxOES'))($component);
}

function glIndexxvOES($component) {
  static $proc;
  return ($proc ??= GL::getProcAddress('indexxvOES'))($component);
}

function glInitNames() {
  static $proc;
  return ($proc ??= GL::getProcAddress('initNames'))();
}

function glInsertComponentEXT(int $res, int $src, int $num) {
  static $proc;
  return ($proc ??= GL::getProcAddress('insertComponentEXT'))($res, $src, $num);
}

function glInsertEventMarkerEXT(int $length, $marker) {
  static $proc;
  return ($proc ??= GL::getProcAddress('insertEventMarkerEXT'))($length, $marker);
}

function glInstrumentsBufferSGIX(int $size, $buffer) {
  static $proc;
  return ($proc ??= GL::getProcAddress('instrumentsBufferSGIX'))($size, $buffer);
}

function glInterleavedArrays(int $format, int $stride, $pointer) {
  static $proc;
  return ($proc ??= GL::getProcAddress('interleavedArrays'))($format, $stride, $pointer);
}

function glInterpolatePathsNV(int $resultPath, int $pathA, int $pathB, float $weight) {
  static $proc;
  return ($proc ??= GL::getProcAddress('interpolatePathsNV'))($resultPath, $pathA, $pathB, $weight);
}

function glInvalidateBufferData(int $buffer) {
  static $proc;
  return ($proc ??= GL::getProcAddress('invalidateBufferData'))($buffer);
}

function glInvalidateBufferSubData(int $buffer, int $offset, int $length) {
  static $proc;
  return ($proc ??= GL::getProcAddress('invalidateBufferSubData'))($buffer, $offset, $length);
}

function glInvalidateFramebuffer(int $target, int $numAttachments, $attachments) {
  static $proc;
  return ($proc ??= GL::getProcAddress('invalidateFramebuffer'))($target, $numAttachments, $attachments);
}

function glInvalidateNamedFramebufferData(int $framebuffer, int $numAttachments, $attachments) {
  static $proc;
  return ($proc ??= GL::getProcAddress('invalidateNamedFramebufferData'))($framebuffer, $numAttachments, $attachments);
}

function glInvalidateNamedFramebufferSubData(int $framebuffer, int $numAttachments, $attachments, int $x, int $y, int $width, int $height) {
  static $proc;
  return ($proc ??= GL::getProcAddress('invalidateNamedFramebufferSubData'))($framebuffer, $numAttachments, $attachments, $x, $y, $width, $height);
}

function glInvalidateSubFramebuffer(int $target, int $numAttachments, $attachments, int $x, int $y, int $width, int $height) {
  static $proc;
  return ($proc ??= GL::getProcAddress('invalidateSubFramebuffer'))($target, $numAttachments, $attachments, $x, $y, $width, $height);
}

function glInvalidateTexImage(int $texture, int $level) {
  static $proc;
  return ($proc ??= GL::getProcAddress('invalidateTexImage'))($texture, $level);
}

function glInvalidateTexSubImage(int $texture, int $level, int $xoffset, int $yoffset, int $zoffset, int $width, int $height, int $depth) {
  static $proc;
  return ($proc ??= GL::getProcAddress('invalidateTexSubImage'))($texture, $level, $xoffset, $yoffset, $zoffset, $width, $height, $depth);
}

function glIsAsyncMarkerSGIX(int $marker) {
  static $proc;
  return ($proc ??= GL::getProcAddress('isAsyncMarkerSGIX'))($marker);
}

function glIsBuffer(int $buffer) {
  static $proc;
  return ($proc ??= GL::getProcAddress('isBuffer'))($buffer);
}

function glIsBufferARB(int $buffer) {
  static $proc;
  return ($proc ??= GL::getProcAddress('isBufferARB'))($buffer);
}

function glIsBufferResidentNV(int $target) {
  static $proc;
  return ($proc ??= GL::getProcAddress('isBufferResidentNV'))($target);
}

function glIsCommandListNV(int $list) {
  static $proc;
  return ($proc ??= GL::getProcAddress('isCommandListNV'))($list);
}

function glIsEnabled(int $cap) {
  static $proc;
  return ($proc ??= GL::getProcAddress('isEnabled'))($cap);
}

function glIsEnabledIndexedEXT(int $target, int $index) {
  static $proc;
  return ($proc ??= GL::getProcAddress('isEnabledIndexedEXT'))($target, $index);
}

function glIsEnabledi(int $target, int $index) {
  static $proc;
  return ($proc ??= GL::getProcAddress('isEnabledi'))($target, $index);
}

function glIsEnablediEXT(int $target, int $index) {
  static $proc;
  return ($proc ??= GL::getProcAddress('isEnablediEXT'))($target, $index);
}

function glIsEnablediNV(int $target, int $index) {
  static $proc;
  return ($proc ??= GL::getProcAddress('isEnablediNV'))($target, $index);
}

function glIsEnablediOES(int $target, int $index) {
  static $proc;
  return ($proc ??= GL::getProcAddress('isEnablediOES'))($target, $index);
}

function glIsFenceAPPLE(int $fence) {
  static $proc;
  return ($proc ??= GL::getProcAddress('isFenceAPPLE'))($fence);
}

function glIsFenceNV(int $fence) {
  static $proc;
  return ($proc ??= GL::getProcAddress('isFenceNV'))($fence);
}

function glIsFramebuffer(int $framebuffer) {
  static $proc;
  return ($proc ??= GL::getProcAddress('isFramebuffer'))($framebuffer);
}

function glIsFramebufferEXT(int $framebuffer) {
  static $proc;
  return ($proc ??= GL::getProcAddress('isFramebufferEXT'))($framebuffer);
}

function glIsFramebufferOES(int $framebuffer) {
  static $proc;
  return ($proc ??= GL::getProcAddress('isFramebufferOES'))($framebuffer);
}

function glIsImageHandleResidentARB(int $handle) {
  static $proc;
  return ($proc ??= GL::getProcAddress('isImageHandleResidentARB'))($handle);
}

function glIsImageHandleResidentNV(int $handle) {
  static $proc;
  return ($proc ??= GL::getProcAddress('isImageHandleResidentNV'))($handle);
}

function glIsList(int $list) {
  static $proc;
  return ($proc ??= GL::getProcAddress('isList'))($list);
}

function glIsNameAMD(int $identifier, int $name) {
  static $proc;
  return ($proc ??= GL::getProcAddress('isNameAMD'))($identifier, $name);
}

function glIsNamedBufferResidentNV(int $buffer) {
  static $proc;
  return ($proc ??= GL::getProcAddress('isNamedBufferResidentNV'))($buffer);
}

function glIsNamedStringARB(int $namelen, $name) {
  static $proc;
  return ($proc ??= GL::getProcAddress('isNamedStringARB'))($namelen, $name);
}

function glIsObjectBufferATI(int $buffer) {
  static $proc;
  return ($proc ??= GL::getProcAddress('isObjectBufferATI'))($buffer);
}

function glIsOcclusionQueryNV(int $id) {
  static $proc;
  return ($proc ??= GL::getProcAddress('isOcclusionQueryNV'))($id);
}

function glIsPathNV(int $path) {
  static $proc;
  return ($proc ??= GL::getProcAddress('isPathNV'))($path);
}

function glIsPointInFillPathNV(int $path, int $mask, float $x, float $y) {
  static $proc;
  return ($proc ??= GL::getProcAddress('isPointInFillPathNV'))($path, $mask, $x, $y);
}

function glIsPointInStrokePathNV(int $path, float $x, float $y) {
  static $proc;
  return ($proc ??= GL::getProcAddress('isPointInStrokePathNV'))($path, $x, $y);
}

function glIsProgram(int $program) {
  static $proc;
  return ($proc ??= GL::getProcAddress('isProgram'))($program);
}

function glIsProgramARB(int $program) {
  static $proc;
  return ($proc ??= GL::getProcAddress('isProgramARB'))($program);
}

function glIsProgramNV(int $id) {
  static $proc;
  return ($proc ??= GL::getProcAddress('isProgramNV'))($id);
}

function glIsProgramPipeline(int $pipeline) {
  static $proc;
  return ($proc ??= GL::getProcAddress('isProgramPipeline'))($pipeline);
}

function glIsProgramPipelineEXT(int $pipeline) {
  static $proc;
  return ($proc ??= GL::getProcAddress('isProgramPipelineEXT'))($pipeline);
}

function glIsQuery(int $id) {
  static $proc;
  return ($proc ??= GL::getProcAddress('isQuery'))($id);
}

function glIsQueryARB(int $id) {
  static $proc;
  return ($proc ??= GL::getProcAddress('isQueryARB'))($id);
}

function glIsQueryEXT(int $id) {
  static $proc;
  return ($proc ??= GL::getProcAddress('isQueryEXT'))($id);
}

function glIsRenderbuffer(int $renderbuffer) {
  static $proc;
  return ($proc ??= GL::getProcAddress('isRenderbuffer'))($renderbuffer);
}

function glIsRenderbufferEXT(int $renderbuffer) {
  static $proc;
  return ($proc ??= GL::getProcAddress('isRenderbufferEXT'))($renderbuffer);
}

function glIsRenderbufferOES(int $renderbuffer) {
  static $proc;
  return ($proc ??= GL::getProcAddress('isRenderbufferOES'))($renderbuffer);
}

function glIsSampler(int $sampler) {
  static $proc;
  return ($proc ??= GL::getProcAddress('isSampler'))($sampler);
}

function glIsShader(int $shader) {
  static $proc;
  return ($proc ??= GL::getProcAddress('isShader'))($shader);
}

function glIsStateNV(int $state) {
  static $proc;
  return ($proc ??= GL::getProcAddress('isStateNV'))($state);
}

function glIsSync(int $sync) {
  static $proc;
  return ($proc ??= GL::getProcAddress('isSync'))($sync);
}

function glIsSyncAPPLE(int $sync) {
  static $proc;
  return ($proc ??= GL::getProcAddress('isSyncAPPLE'))($sync);
}

function glIsTexture(int $texture) {
  static $proc;
  return ($proc ??= GL::getProcAddress('isTexture'))($texture);
}

function glIsTextureEXT(int $texture) {
  static $proc;
  return ($proc ??= GL::getProcAddress('isTextureEXT'))($texture);
}

function glIsTextureHandleResidentARB(int $handle) {
  static $proc;
  return ($proc ??= GL::getProcAddress('isTextureHandleResidentARB'))($handle);
}

function glIsTextureHandleResidentNV(int $handle) {
  static $proc;
  return ($proc ??= GL::getProcAddress('isTextureHandleResidentNV'))($handle);
}

function glIsTransformFeedback(int $id) {
  static $proc;
  return ($proc ??= GL::getProcAddress('isTransformFeedback'))($id);
}

function glIsTransformFeedbackNV(int $id) {
  static $proc;
  return ($proc ??= GL::getProcAddress('isTransformFeedbackNV'))($id);
}

function glIsVariantEnabledEXT(int $id, int $cap) {
  static $proc;
  return ($proc ??= GL::getProcAddress('isVariantEnabledEXT'))($id, $cap);
}

function glIsVertexArray(int $array) {
  static $proc;
  return ($proc ??= GL::getProcAddress('isVertexArray'))($array);
}

function glIsVertexArrayAPPLE(int $array) {
  static $proc;
  return ($proc ??= GL::getProcAddress('isVertexArrayAPPLE'))($array);
}

function glIsVertexArrayOES(int $array) {
  static $proc;
  return ($proc ??= GL::getProcAddress('isVertexArrayOES'))($array);
}

function glIsVertexAttribEnabledAPPLE(int $index, int $pname) {
  static $proc;
  return ($proc ??= GL::getProcAddress('isVertexAttribEnabledAPPLE'))($index, $pname);
}

function glLabelObjectEXT(int $type, int $object, int $length, $label) {
  static $proc;
  return ($proc ??= GL::getProcAddress('labelObjectEXT'))($type, $object, $length, $label);
}

function glLightEnviSGIX(int $pname, int $param) {
  static $proc;
  return ($proc ??= GL::getProcAddress('lightEnviSGIX'))($pname, $param);
}

function glLightModelf(int $pname, float $param) {
  static $proc;
  return ($proc ??= GL::getProcAddress('lightModelf'))($pname, $param);
}

function glLightModelfv(int $pname, $params) {
  static $proc;
  return ($proc ??= GL::getProcAddress('lightModelfv'))($pname, $params);
}

function glLightModeli(int $pname, int $param) {
  static $proc;
  return ($proc ??= GL::getProcAddress('lightModeli'))($pname, $param);
}

function glLightModeliv(int $pname, $params) {
  static $proc;
  return ($proc ??= GL::getProcAddress('lightModeliv'))($pname, $params);
}

function glLightModelx(int $pname, int $param) {
  static $proc;
  return ($proc ??= GL::getProcAddress('lightModelx'))($pname, $param);
}

function glLightModelxOES(int $pname, int $param) {
  static $proc;
  return ($proc ??= GL::getProcAddress('lightModelxOES'))($pname, $param);
}

function glLightModelxv(int $pname, $param) {
  static $proc;
  return ($proc ??= GL::getProcAddress('lightModelxv'))($pname, $param);
}

function glLightModelxvOES(int $pname, $param) {
  static $proc;
  return ($proc ??= GL::getProcAddress('lightModelxvOES'))($pname, $param);
}

function glLightf(int $light, int $pname, float $param) {
  static $proc;
  return ($proc ??= GL::getProcAddress('lightf'))($light, $pname, $param);
}

function glLightfv(int $light, int $pname, $params) {
  static $proc;
  return ($proc ??= GL::getProcAddress('lightfv'))($light, $pname, $params);
}

function glLighti(int $light, int $pname, int $param) {
  static $proc;
  return ($proc ??= GL::getProcAddress('lighti'))($light, $pname, $param);
}

function glLightiv(int $light, int $pname, $params) {
  static $proc;
  return ($proc ??= GL::getProcAddress('lightiv'))($light, $pname, $params);
}

function glLightx(int $light, int $pname, int $param) {
  static $proc;
  return ($proc ??= GL::getProcAddress('lightx'))($light, $pname, $param);
}

function glLightxOES(int $light, int $pname, int $param) {
  static $proc;
  return ($proc ??= GL::getProcAddress('lightxOES'))($light, $pname, $param);
}

function glLightxv(int $light, int $pname, $params) {
  static $proc;
  return ($proc ??= GL::getProcAddress('lightxv'))($light, $pname, $params);
}

function glLightxvOES(int $light, int $pname, $params) {
  static $proc;
  return ($proc ??= GL::getProcAddress('lightxvOES'))($light, $pname, $params);
}

function glLineStipple(int $factor, int $pattern) {
  static $proc;
  return ($proc ??= GL::getProcAddress('lineStipple'))($factor, $pattern);
}

function glLineWidth(float $width) {
  static $proc;
  return ($proc ??= GL::getProcAddress('lineWidth'))($width);
}

function glLineWidthx(int $width) {
  static $proc;
  return ($proc ??= GL::getProcAddress('lineWidthx'))($width);
}

function glLineWidthxOES(int $width) {
  static $proc;
  return ($proc ??= GL::getProcAddress('lineWidthxOES'))($width);
}

function glLinkProgram(int $program) {
  static $proc;
  return ($proc ??= GL::getProcAddress('linkProgram'))($program);
}

function glLinkProgramARB(int $programObj) {
  static $proc;
  return ($proc ??= GL::getProcAddress('linkProgramARB'))($programObj);
}

function glListBase(int $base) {
  static $proc;
  return ($proc ??= GL::getProcAddress('listBase'))($base);
}

function glListDrawCommandsStatesClientNV(int $list, int $segment, $indirects, $sizes, $states, $fbos, int $count) {
  static $proc;
  return ($proc ??= GL::getProcAddress('listDrawCommandsStatesClientNV'))($list, $segment, $indirects, $sizes, $states, $fbos, $count);
}

function glListParameterfSGIX(int $list, int $pname, float $param) {
  static $proc;
  return ($proc ??= GL::getProcAddress('listParameterfSGIX'))($list, $pname, $param);
}

function glListParameterfvSGIX(int $list, int $pname, $params) {
  static $proc;
  return ($proc ??= GL::getProcAddress('listParameterfvSGIX'))($list, $pname, $params);
}

function glListParameteriSGIX(int $list, int $pname, int $param) {
  static $proc;
  return ($proc ??= GL::getProcAddress('listParameteriSGIX'))($list, $pname, $param);
}

function glListParameterivSGIX(int $list, int $pname, $params) {
  static $proc;
  return ($proc ??= GL::getProcAddress('listParameterivSGIX'))($list, $pname, $params);
}

function glLoadIdentity() {
  static $proc;
  return ($proc ??= GL::getProcAddress('loadIdentity'))();
}

function glLoadIdentityDeformationMapSGIX(int $mask) {
  static $proc;
  return ($proc ??= GL::getProcAddress('loadIdentityDeformationMapSGIX'))($mask);
}

function glLoadMatrixd($m) {
  static $proc;
  return ($proc ??= GL::getProcAddress('loadMatrixd'))($m);
}

function glLoadMatrixf($m) {
  static $proc;
  return ($proc ??= GL::getProcAddress('loadMatrixf'))($m);
}

function glLoadMatrixx($m) {
  static $proc;
  return ($proc ??= GL::getProcAddress('loadMatrixx'))($m);
}

function glLoadMatrixxOES($m) {
  static $proc;
  return ($proc ??= GL::getProcAddress('loadMatrixxOES'))($m);
}

function glLoadName(int $name) {
  static $proc;
  return ($proc ??= GL::getProcAddress('loadName'))($name);
}

function glLoadPaletteFromModelViewMatrixOES() {
  static $proc;
  return ($proc ??= GL::getProcAddress('loadPaletteFromModelViewMatrixOES'))();
}

function glLoadProgramNV(int $target, int $id, int $len, $program) {
  static $proc;
  return ($proc ??= GL::getProcAddress('loadProgramNV'))($target, $id, $len, $program);
}

function glLoadTransposeMatrixd($m) {
  static $proc;
  return ($proc ??= GL::getProcAddress('loadTransposeMatrixd'))($m);
}

function glLoadTransposeMatrixdARB($m) {
  static $proc;
  return ($proc ??= GL::getProcAddress('loadTransposeMatrixdARB'))($m);
}

function glLoadTransposeMatrixf($m) {
  static $proc;
  return ($proc ??= GL::getProcAddress('loadTransposeMatrixf'))($m);
}

function glLoadTransposeMatrixfARB($m) {
  static $proc;
  return ($proc ??= GL::getProcAddress('loadTransposeMatrixfARB'))($m);
}

function glLoadTransposeMatrixxOES($m) {
  static $proc;
  return ($proc ??= GL::getProcAddress('loadTransposeMatrixxOES'))($m);
}

function glLockArraysEXT(int $first, int $count) {
  static $proc;
  return ($proc ??= GL::getProcAddress('lockArraysEXT'))($first, $count);
}

function glLogicOp(int $opcode) {
  static $proc;
  return ($proc ??= GL::getProcAddress('logicOp'))($opcode);
}

function glMakeBufferNonResidentNV(int $target) {
  static $proc;
  return ($proc ??= GL::getProcAddress('makeBufferNonResidentNV'))($target);
}

function glMakeBufferResidentNV(int $target, int $access) {
  static $proc;
  return ($proc ??= GL::getProcAddress('makeBufferResidentNV'))($target, $access);
}

function glMakeImageHandleNonResidentARB(int $handle) {
  static $proc;
  return ($proc ??= GL::getProcAddress('makeImageHandleNonResidentARB'))($handle);
}

function glMakeImageHandleNonResidentNV(int $handle) {
  static $proc;
  return ($proc ??= GL::getProcAddress('makeImageHandleNonResidentNV'))($handle);
}

function glMakeImageHandleResidentARB(int $handle, int $access) {
  static $proc;
  return ($proc ??= GL::getProcAddress('makeImageHandleResidentARB'))($handle, $access);
}

function glMakeImageHandleResidentNV(int $handle, int $access) {
  static $proc;
  return ($proc ??= GL::getProcAddress('makeImageHandleResidentNV'))($handle, $access);
}

function glMakeNamedBufferNonResidentNV(int $buffer) {
  static $proc;
  return ($proc ??= GL::getProcAddress('makeNamedBufferNonResidentNV'))($buffer);
}

function glMakeNamedBufferResidentNV(int $buffer, int $access) {
  static $proc;
  return ($proc ??= GL::getProcAddress('makeNamedBufferResidentNV'))($buffer, $access);
}

function glMakeTextureHandleNonResidentARB(int $handle) {
  static $proc;
  return ($proc ??= GL::getProcAddress('makeTextureHandleNonResidentARB'))($handle);
}

function glMakeTextureHandleNonResidentNV(int $handle) {
  static $proc;
  return ($proc ??= GL::getProcAddress('makeTextureHandleNonResidentNV'))($handle);
}

function glMakeTextureHandleResidentARB(int $handle) {
  static $proc;
  return ($proc ??= GL::getProcAddress('makeTextureHandleResidentARB'))($handle);
}

function glMakeTextureHandleResidentNV(int $handle) {
  static $proc;
  return ($proc ??= GL::getProcAddress('makeTextureHandleResidentNV'))($handle);
}

function glMap1d(int $target, float $u1, float $u2, int $stride, int $order, $points) {
  static $proc;
  return ($proc ??= GL::getProcAddress('map1d'))($target, $u1, $u2, $stride, $order, $points);
}

function glMap1f(int $target, float $u1, float $u2, int $stride, int $order, $points) {
  static $proc;
  return ($proc ??= GL::getProcAddress('map1f'))($target, $u1, $u2, $stride, $order, $points);
}

function glMap1xOES(int $target, int $u1, int $u2, int $stride, int $order, int $points) {
  static $proc;
  return ($proc ??= GL::getProcAddress('map1xOES'))($target, $u1, $u2, $stride, $order, $points);
}

function glMap2d(int $target, float $u1, float $u2, int $ustride, int $uorder, float $v1, float $v2, int $vstride, int $vorder, $points) {
  static $proc;
  return ($proc ??= GL::getProcAddress('map2d'))($target, $u1, $u2, $ustride, $uorder, $v1, $v2, $vstride, $vorder, $points);
}

function glMap2f(int $target, float $u1, float $u2, int $ustride, int $uorder, float $v1, float $v2, int $vstride, int $vorder, $points) {
  static $proc;
  return ($proc ??= GL::getProcAddress('map2f'))($target, $u1, $u2, $ustride, $uorder, $v1, $v2, $vstride, $vorder, $points);
}

function glMap2xOES(int $target, int $u1, int $u2, int $ustride, int $uorder, int $v1, int $v2, int $vstride, int $vorder, int $points) {
  static $proc;
  return ($proc ??= GL::getProcAddress('map2xOES'))($target, $u1, $u2, $ustride, $uorder, $v1, $v2, $vstride, $vorder, $points);
}

function glMapBuffer(int $target, int $access) {
  static $proc;
  return ($proc ??= GL::getProcAddress('mapBuffer'))($target, $access);
}

function glMapBufferARB(int $target, int $access) {
  static $proc;
  return ($proc ??= GL::getProcAddress('mapBufferARB'))($target, $access);
}

function glMapBufferOES(int $target, int $access) {
  static $proc;
  return ($proc ??= GL::getProcAddress('mapBufferOES'))($target, $access);
}

function glMapBufferRange(int $target, int $offset, int $length, int $access) {
  static $proc;
  return ($proc ??= GL::getProcAddress('mapBufferRange'))($target, $offset, $length, $access);
}

function glMapBufferRangeEXT(int $target, int $offset, int $length, int $access) {
  static $proc;
  return ($proc ??= GL::getProcAddress('mapBufferRangeEXT'))($target, $offset, $length, $access);
}

function glMapControlPointsNV(int $target, int $index, int $type, int $ustride, int $vstride, int $uorder, int $vorder, int $packed, $points) {
  static $proc;
  return ($proc ??= GL::getProcAddress('mapControlPointsNV'))($target, $index, $type, $ustride, $vstride, $uorder, $vorder, $packed, $points);
}

function glMapGrid1d(int $un, float $u1, float $u2) {
  static $proc;
  return ($proc ??= GL::getProcAddress('mapGrid1d'))($un, $u1, $u2);
}

function glMapGrid1f(int $un, float $u1, float $u2) {
  static $proc;
  return ($proc ??= GL::getProcAddress('mapGrid1f'))($un, $u1, $u2);
}

function glMapGrid1xOES(int $n, int $u1, int $u2) {
  static $proc;
  return ($proc ??= GL::getProcAddress('mapGrid1xOES'))($n, $u1, $u2);
}

function glMapGrid2d(int $un, float $u1, float $u2, int $vn, float $v1, float $v2) {
  static $proc;
  return ($proc ??= GL::getProcAddress('mapGrid2d'))($un, $u1, $u2, $vn, $v1, $v2);
}

function glMapGrid2f(int $un, float $u1, float $u2, int $vn, float $v1, float $v2) {
  static $proc;
  return ($proc ??= GL::getProcAddress('mapGrid2f'))($un, $u1, $u2, $vn, $v1, $v2);
}

function glMapGrid2xOES(int $n, int $u1, int $u2, int $v1, int $v2) {
  static $proc;
  return ($proc ??= GL::getProcAddress('mapGrid2xOES'))($n, $u1, $u2, $v1, $v2);
}

function glMapNamedBuffer(int $buffer, int $access) {
  static $proc;
  return ($proc ??= GL::getProcAddress('mapNamedBuffer'))($buffer, $access);
}

function glMapNamedBufferEXT(int $buffer, int $access) {
  static $proc;
  return ($proc ??= GL::getProcAddress('mapNamedBufferEXT'))($buffer, $access);
}

function glMapNamedBufferRange(int $buffer, int $offset, int $length, int $access) {
  static $proc;
  return ($proc ??= GL::getProcAddress('mapNamedBufferRange'))($buffer, $offset, $length, $access);
}

function glMapNamedBufferRangeEXT(int $buffer, int $offset, int $length, int $access) {
  static $proc;
  return ($proc ??= GL::getProcAddress('mapNamedBufferRangeEXT'))($buffer, $offset, $length, $access);
}

function glMapObjectBufferATI(int $buffer) {
  static $proc;
  return ($proc ??= GL::getProcAddress('mapObjectBufferATI'))($buffer);
}

function glMapParameterfvNV(int $target, int $pname, $params) {
  static $proc;
  return ($proc ??= GL::getProcAddress('mapParameterfvNV'))($target, $pname, $params);
}

function glMapParameterivNV(int $target, int $pname, $params) {
  static $proc;
  return ($proc ??= GL::getProcAddress('mapParameterivNV'))($target, $pname, $params);
}

function glMapTexture2DINTEL(int $texture, int $level, int $access, $stride, $layout) {
  static $proc;
  return ($proc ??= GL::getProcAddress('mapTexture2DINTEL'))($texture, $level, $access, $stride, $layout);
}

function glMapVertexAttrib1dAPPLE(int $index, int $size, float $u1, float $u2, int $stride, int $order, $points) {
  static $proc;
  return ($proc ??= GL::getProcAddress('mapVertexAttrib1dAPPLE'))($index, $size, $u1, $u2, $stride, $order, $points);
}

function glMapVertexAttrib1fAPPLE(int $index, int $size, float $u1, float $u2, int $stride, int $order, $points) {
  static $proc;
  return ($proc ??= GL::getProcAddress('mapVertexAttrib1fAPPLE'))($index, $size, $u1, $u2, $stride, $order, $points);
}

function glMapVertexAttrib2dAPPLE(int $index, int $size, float $u1, float $u2, int $ustride, int $uorder, float $v1, float $v2, int $vstride, int $vorder, $points) {
  static $proc;
  return ($proc ??= GL::getProcAddress('mapVertexAttrib2dAPPLE'))($index, $size, $u1, $u2, $ustride, $uorder, $v1, $v2, $vstride, $vorder, $points);
}

function glMapVertexAttrib2fAPPLE(int $index, int $size, float $u1, float $u2, int $ustride, int $uorder, float $v1, float $v2, int $vstride, int $vorder, $points) {
  static $proc;
  return ($proc ??= GL::getProcAddress('mapVertexAttrib2fAPPLE'))($index, $size, $u1, $u2, $ustride, $uorder, $v1, $v2, $vstride, $vorder, $points);
}

function glMaterialf(int $face, int $pname, float $param) {
  static $proc;
  return ($proc ??= GL::getProcAddress('materialf'))($face, $pname, $param);
}

function glMaterialfv(int $face, int $pname, $params) {
  static $proc;
  return ($proc ??= GL::getProcAddress('materialfv'))($face, $pname, $params);
}

function glMateriali(int $face, int $pname, int $param) {
  static $proc;
  return ($proc ??= GL::getProcAddress('materiali'))($face, $pname, $param);
}

function glMaterialiv(int $face, int $pname, $params) {
  static $proc;
  return ($proc ??= GL::getProcAddress('materialiv'))($face, $pname, $params);
}

function glMaterialx(int $face, int $pname, int $param) {
  static $proc;
  return ($proc ??= GL::getProcAddress('materialx'))($face, $pname, $param);
}

function glMaterialxOES(int $face, int $pname, int $param) {
  static $proc;
  return ($proc ??= GL::getProcAddress('materialxOES'))($face, $pname, $param);
}

function glMaterialxv(int $face, int $pname, $param) {
  static $proc;
  return ($proc ??= GL::getProcAddress('materialxv'))($face, $pname, $param);
}

function glMaterialxvOES(int $face, int $pname, $param) {
  static $proc;
  return ($proc ??= GL::getProcAddress('materialxvOES'))($face, $pname, $param);
}

function glMatrixFrustumEXT(int $mode, float $left, float $right, float $bottom, float $top, float $zNear, float $zFar) {
  static $proc;
  return ($proc ??= GL::getProcAddress('matrixFrustumEXT'))($mode, $left, $right, $bottom, $top, $zNear, $zFar);
}

function glMatrixIndexPointerARB(int $size, int $type, int $stride, $pointer) {
  static $proc;
  return ($proc ??= GL::getProcAddress('matrixIndexPointerARB'))($size, $type, $stride, $pointer);
}

function glMatrixIndexPointerOES(int $size, int $type, int $stride, $pointer) {
  static $proc;
  return ($proc ??= GL::getProcAddress('matrixIndexPointerOES'))($size, $type, $stride, $pointer);
}

function glMatrixIndexubvARB(int $size, $indices) {
  static $proc;
  return ($proc ??= GL::getProcAddress('matrixIndexubvARB'))($size, $indices);
}

function glMatrixIndexuivARB(int $size, $indices) {
  static $proc;
  return ($proc ??= GL::getProcAddress('matrixIndexuivARB'))($size, $indices);
}

function glMatrixIndexusvARB(int $size, $indices) {
  static $proc;
  return ($proc ??= GL::getProcAddress('matrixIndexusvARB'))($size, $indices);
}

function glMatrixLoad3x2fNV(int $matrixMode, $m) {
  static $proc;
  return ($proc ??= GL::getProcAddress('matrixLoad3x2fNV'))($matrixMode, $m);
}

function glMatrixLoad3x3fNV(int $matrixMode, $m) {
  static $proc;
  return ($proc ??= GL::getProcAddress('matrixLoad3x3fNV'))($matrixMode, $m);
}

function glMatrixLoadIdentityEXT(int $mode) {
  static $proc;
  return ($proc ??= GL::getProcAddress('matrixLoadIdentityEXT'))($mode);
}

function glMatrixLoadTranspose3x3fNV(int $matrixMode, $m) {
  static $proc;
  return ($proc ??= GL::getProcAddress('matrixLoadTranspose3x3fNV'))($matrixMode, $m);
}

function glMatrixLoadTransposedEXT(int $mode, $m) {
  static $proc;
  return ($proc ??= GL::getProcAddress('matrixLoadTransposedEXT'))($mode, $m);
}

function glMatrixLoadTransposefEXT(int $mode, $m) {
  static $proc;
  return ($proc ??= GL::getProcAddress('matrixLoadTransposefEXT'))($mode, $m);
}

function glMatrixLoaddEXT(int $mode, $m) {
  static $proc;
  return ($proc ??= GL::getProcAddress('matrixLoaddEXT'))($mode, $m);
}

function glMatrixLoadfEXT(int $mode, $m) {
  static $proc;
  return ($proc ??= GL::getProcAddress('matrixLoadfEXT'))($mode, $m);
}

function glMatrixMode(int $mode) {
  static $proc;
  return ($proc ??= GL::getProcAddress('matrixMode'))($mode);
}

function glMatrixMult3x2fNV(int $matrixMode, $m) {
  static $proc;
  return ($proc ??= GL::getProcAddress('matrixMult3x2fNV'))($matrixMode, $m);
}

function glMatrixMult3x3fNV(int $matrixMode, $m) {
  static $proc;
  return ($proc ??= GL::getProcAddress('matrixMult3x3fNV'))($matrixMode, $m);
}

function glMatrixMultTranspose3x3fNV(int $matrixMode, $m) {
  static $proc;
  return ($proc ??= GL::getProcAddress('matrixMultTranspose3x3fNV'))($matrixMode, $m);
}

function glMatrixMultTransposedEXT(int $mode, $m) {
  static $proc;
  return ($proc ??= GL::getProcAddress('matrixMultTransposedEXT'))($mode, $m);
}

function glMatrixMultTransposefEXT(int $mode, $m) {
  static $proc;
  return ($proc ??= GL::getProcAddress('matrixMultTransposefEXT'))($mode, $m);
}

function glMatrixMultdEXT(int $mode, $m) {
  static $proc;
  return ($proc ??= GL::getProcAddress('matrixMultdEXT'))($mode, $m);
}

function glMatrixMultfEXT(int $mode, $m) {
  static $proc;
  return ($proc ??= GL::getProcAddress('matrixMultfEXT'))($mode, $m);
}

function glMatrixOrthoEXT(int $mode, float $left, float $right, float $bottom, float $top, float $zNear, float $zFar) {
  static $proc;
  return ($proc ??= GL::getProcAddress('matrixOrthoEXT'))($mode, $left, $right, $bottom, $top, $zNear, $zFar);
}

function glMatrixPopEXT(int $mode) {
  static $proc;
  return ($proc ??= GL::getProcAddress('matrixPopEXT'))($mode);
}

function glMatrixPushEXT(int $mode) {
  static $proc;
  return ($proc ??= GL::getProcAddress('matrixPushEXT'))($mode);
}

function glMatrixRotatedEXT(int $mode, float $angle, float $x, float $y, float $z) {
  static $proc;
  return ($proc ??= GL::getProcAddress('matrixRotatedEXT'))($mode, $angle, $x, $y, $z);
}

function glMatrixRotatefEXT(int $mode, float $angle, float $x, float $y, float $z) {
  static $proc;
  return ($proc ??= GL::getProcAddress('matrixRotatefEXT'))($mode, $angle, $x, $y, $z);
}

function glMatrixScaledEXT(int $mode, float $x, float $y, float $z) {
  static $proc;
  return ($proc ??= GL::getProcAddress('matrixScaledEXT'))($mode, $x, $y, $z);
}

function glMatrixScalefEXT(int $mode, float $x, float $y, float $z) {
  static $proc;
  return ($proc ??= GL::getProcAddress('matrixScalefEXT'))($mode, $x, $y, $z);
}

function glMatrixTranslatedEXT(int $mode, float $x, float $y, float $z) {
  static $proc;
  return ($proc ??= GL::getProcAddress('matrixTranslatedEXT'))($mode, $x, $y, $z);
}

function glMatrixTranslatefEXT(int $mode, float $x, float $y, float $z) {
  static $proc;
  return ($proc ??= GL::getProcAddress('matrixTranslatefEXT'))($mode, $x, $y, $z);
}

function glMaxShaderCompilerThreadsARB(int $count) {
  static $proc;
  return ($proc ??= GL::getProcAddress('maxShaderCompilerThreadsARB'))($count);
}

function glMemoryBarrier(int $barriers) {
  static $proc;
  return ($proc ??= GL::getProcAddress('memoryBarrier'))($barriers);
}

function glMemoryBarrierByRegion(int $barriers) {
  static $proc;
  return ($proc ??= GL::getProcAddress('memoryBarrierByRegion'))($barriers);
}

function glMemoryBarrierEXT(int $barriers) {
  static $proc;
  return ($proc ??= GL::getProcAddress('memoryBarrierEXT'))($barriers);
}

function glMinSampleShading(float $value) {
  static $proc;
  return ($proc ??= GL::getProcAddress('minSampleShading'))($value);
}

function glMinSampleShadingARB(float $value) {
  static $proc;
  return ($proc ??= GL::getProcAddress('minSampleShadingARB'))($value);
}

function glMinSampleShadingOES(float $value) {
  static $proc;
  return ($proc ??= GL::getProcAddress('minSampleShadingOES'))($value);
}

function glMinmax(int $target, int $internalformat, int $sink) {
  static $proc;
  return ($proc ??= GL::getProcAddress('minmax'))($target, $internalformat, $sink);
}

function glMinmaxEXT(int $target, int $internalformat, int $sink) {
  static $proc;
  return ($proc ??= GL::getProcAddress('minmaxEXT'))($target, $internalformat, $sink);
}

function glMultMatrixd($m) {
  static $proc;
  return ($proc ??= GL::getProcAddress('multMatrixd'))($m);
}

function glMultMatrixf($m) {
  static $proc;
  return ($proc ??= GL::getProcAddress('multMatrixf'))($m);
}

function glMultMatrixx($m) {
  static $proc;
  return ($proc ??= GL::getProcAddress('multMatrixx'))($m);
}

function glMultMatrixxOES($m) {
  static $proc;
  return ($proc ??= GL::getProcAddress('multMatrixxOES'))($m);
}

function glMultTransposeMatrixd($m) {
  static $proc;
  return ($proc ??= GL::getProcAddress('multTransposeMatrixd'))($m);
}

function glMultTransposeMatrixdARB($m) {
  static $proc;
  return ($proc ??= GL::getProcAddress('multTransposeMatrixdARB'))($m);
}

function glMultTransposeMatrixf($m) {
  static $proc;
  return ($proc ??= GL::getProcAddress('multTransposeMatrixf'))($m);
}

function glMultTransposeMatrixfARB($m) {
  static $proc;
  return ($proc ??= GL::getProcAddress('multTransposeMatrixfARB'))($m);
}

function glMultTransposeMatrixxOES($m) {
  static $proc;
  return ($proc ??= GL::getProcAddress('multTransposeMatrixxOES'))($m);
}

function glMultiDrawArrays(int $mode, $first, $count, int $drawcount) {
  static $proc;
  return ($proc ??= GL::getProcAddress('multiDrawArrays'))($mode, $first, $count, $drawcount);
}

function glMultiDrawArraysEXT(int $mode, $first, $count, int $primcount) {
  static $proc;
  return ($proc ??= GL::getProcAddress('multiDrawArraysEXT'))($mode, $first, $count, $primcount);
}

function glMultiDrawArraysIndirect(int $mode, $indirect, int $drawcount, int $stride) {
  static $proc;
  return ($proc ??= GL::getProcAddress('multiDrawArraysIndirect'))($mode, $indirect, $drawcount, $stride);
}

function glMultiDrawArraysIndirectAMD(int $mode, $indirect, int $primcount, int $stride) {
  static $proc;
  return ($proc ??= GL::getProcAddress('multiDrawArraysIndirectAMD'))($mode, $indirect, $primcount, $stride);
}

function glMultiDrawArraysIndirectBindlessCountNV(int $mode, $indirect, int $drawCount, int $maxDrawCount, int $stride, int $vertexBufferCount) {
  static $proc;
  return ($proc ??= GL::getProcAddress('multiDrawArraysIndirectBindlessCountNV'))($mode, $indirect, $drawCount, $maxDrawCount, $stride, $vertexBufferCount);
}

function glMultiDrawArraysIndirectBindlessNV(int $mode, $indirect, int $drawCount, int $stride, int $vertexBufferCount) {
  static $proc;
  return ($proc ??= GL::getProcAddress('multiDrawArraysIndirectBindlessNV'))($mode, $indirect, $drawCount, $stride, $vertexBufferCount);
}

function glMultiDrawArraysIndirectCountARB(int $mode, int $indirect, int $drawcount, int $maxdrawcount, int $stride) {
  static $proc;
  return ($proc ??= GL::getProcAddress('multiDrawArraysIndirectCountARB'))($mode, $indirect, $drawcount, $maxdrawcount, $stride);
}

function glMultiDrawArraysIndirectEXT(int $mode, $indirect, int $drawcount, int $stride) {
  static $proc;
  return ($proc ??= GL::getProcAddress('multiDrawArraysIndirectEXT'))($mode, $indirect, $drawcount, $stride);
}

function glMultiDrawElementArrayAPPLE(int $mode, $first, $count, int $primcount) {
  static $proc;
  return ($proc ??= GL::getProcAddress('multiDrawElementArrayAPPLE'))($mode, $first, $count, $primcount);
}

function glMultiDrawElements(int $mode, $count, int $type, $indices, int $drawcount) {
  static $proc;
  return ($proc ??= GL::getProcAddress('multiDrawElements'))($mode, $count, $type, $indices, $drawcount);
}

function glMultiDrawElementsBaseVertex(int $mode, $count, int $type, $indices, int $drawcount, $basevertex) {
  static $proc;
  return ($proc ??= GL::getProcAddress('multiDrawElementsBaseVertex'))($mode, $count, $type, $indices, $drawcount, $basevertex);
}

function glMultiDrawElementsBaseVertexEXT(int $mode, $count, int $type, $indices, int $primcount, $basevertex) {
  static $proc;
  return ($proc ??= GL::getProcAddress('multiDrawElementsBaseVertexEXT'))($mode, $count, $type, $indices, $primcount, $basevertex);
}

function glMultiDrawElementsBaseVertexOES(int $mode, $count, int $type, $indices, int $primcount, $basevertex) {
  static $proc;
  return ($proc ??= GL::getProcAddress('multiDrawElementsBaseVertexOES'))($mode, $count, $type, $indices, $primcount, $basevertex);
}

function glMultiDrawElementsEXT(int $mode, $count, int $type, $indices, int $primcount) {
  static $proc;
  return ($proc ??= GL::getProcAddress('multiDrawElementsEXT'))($mode, $count, $type, $indices, $primcount);
}

function glMultiDrawElementsIndirect(int $mode, int $type, $indirect, int $drawcount, int $stride) {
  static $proc;
  return ($proc ??= GL::getProcAddress('multiDrawElementsIndirect'))($mode, $type, $indirect, $drawcount, $stride);
}

function glMultiDrawElementsIndirectAMD(int $mode, int $type, $indirect, int $primcount, int $stride) {
  static $proc;
  return ($proc ??= GL::getProcAddress('multiDrawElementsIndirectAMD'))($mode, $type, $indirect, $primcount, $stride);
}

function glMultiDrawElementsIndirectBindlessCountNV(int $mode, int $type, $indirect, int $drawCount, int $maxDrawCount, int $stride, int $vertexBufferCount) {
  static $proc;
  return ($proc ??= GL::getProcAddress('multiDrawElementsIndirectBindlessCountNV'))($mode, $type, $indirect, $drawCount, $maxDrawCount, $stride, $vertexBufferCount);
}

function glMultiDrawElementsIndirectBindlessNV(int $mode, int $type, $indirect, int $drawCount, int $stride, int $vertexBufferCount) {
  static $proc;
  return ($proc ??= GL::getProcAddress('multiDrawElementsIndirectBindlessNV'))($mode, $type, $indirect, $drawCount, $stride, $vertexBufferCount);
}

function glMultiDrawElementsIndirectCountARB(int $mode, int $type, int $indirect, int $drawcount, int $maxdrawcount, int $stride) {
  static $proc;
  return ($proc ??= GL::getProcAddress('multiDrawElementsIndirectCountARB'))($mode, $type, $indirect, $drawcount, $maxdrawcount, $stride);
}

function glMultiDrawElementsIndirectEXT(int $mode, int $type, $indirect, int $drawcount, int $stride) {
  static $proc;
  return ($proc ??= GL::getProcAddress('multiDrawElementsIndirectEXT'))($mode, $type, $indirect, $drawcount, $stride);
}

function glMultiDrawRangeElementArrayAPPLE(int $mode, int $start, int $end, $first, $count, int $primcount) {
  static $proc;
  return ($proc ??= GL::getProcAddress('multiDrawRangeElementArrayAPPLE'))($mode, $start, $end, $first, $count, $primcount);
}

function glMultiModeDrawArraysIBM($mode, $first, $count, int $primcount, int $modestride) {
  static $proc;
  return ($proc ??= GL::getProcAddress('multiModeDrawArraysIBM'))($mode, $first, $count, $primcount, $modestride);
}

function glMultiModeDrawElementsIBM($mode, $count, int $type, $indices, int $primcount, int $modestride) {
  static $proc;
  return ($proc ??= GL::getProcAddress('multiModeDrawElementsIBM'))($mode, $count, $type, $indices, $primcount, $modestride);
}

function glMultiTexBufferEXT(int $texunit, int $target, int $internalformat, int $buffer) {
  static $proc;
  return ($proc ??= GL::getProcAddress('multiTexBufferEXT'))($texunit, $target, $internalformat, $buffer);
}

function glMultiTexCoord1bOES(int $texture, int $s) {
  static $proc;
  return ($proc ??= GL::getProcAddress('multiTexCoord1bOES'))($texture, $s);
}

function glMultiTexCoord1bvOES(int $texture, $coords) {
  static $proc;
  return ($proc ??= GL::getProcAddress('multiTexCoord1bvOES'))($texture, $coords);
}

function glMultiTexCoord1d(int $target, float $s) {
  static $proc;
  return ($proc ??= GL::getProcAddress('multiTexCoord1d'))($target, $s);
}

function glMultiTexCoord1dARB(int $target, float $s) {
  static $proc;
  return ($proc ??= GL::getProcAddress('multiTexCoord1dARB'))($target, $s);
}

function glMultiTexCoord1dv(int $target, $v) {
  static $proc;
  return ($proc ??= GL::getProcAddress('multiTexCoord1dv'))($target, $v);
}

function glMultiTexCoord1dvARB(int $target, $v) {
  static $proc;
  return ($proc ??= GL::getProcAddress('multiTexCoord1dvARB'))($target, $v);
}

function glMultiTexCoord1f(int $target, float $s) {
  static $proc;
  return ($proc ??= GL::getProcAddress('multiTexCoord1f'))($target, $s);
}

function glMultiTexCoord1fARB(int $target, float $s) {
  static $proc;
  return ($proc ??= GL::getProcAddress('multiTexCoord1fARB'))($target, $s);
}

function glMultiTexCoord1fv(int $target, $v) {
  static $proc;
  return ($proc ??= GL::getProcAddress('multiTexCoord1fv'))($target, $v);
}

function glMultiTexCoord1fvARB(int $target, $v) {
  static $proc;
  return ($proc ??= GL::getProcAddress('multiTexCoord1fvARB'))($target, $v);
}

function glMultiTexCoord1hNV(int $target, int $s) {
  static $proc;
  return ($proc ??= GL::getProcAddress('multiTexCoord1hNV'))($target, $s);
}

function glMultiTexCoord1hvNV(int $target, $v) {
  static $proc;
  return ($proc ??= GL::getProcAddress('multiTexCoord1hvNV'))($target, $v);
}

function glMultiTexCoord1i(int $target, int $s) {
  static $proc;
  return ($proc ??= GL::getProcAddress('multiTexCoord1i'))($target, $s);
}

function glMultiTexCoord1iARB(int $target, int $s) {
  static $proc;
  return ($proc ??= GL::getProcAddress('multiTexCoord1iARB'))($target, $s);
}

function glMultiTexCoord1iv(int $target, $v) {
  static $proc;
  return ($proc ??= GL::getProcAddress('multiTexCoord1iv'))($target, $v);
}

function glMultiTexCoord1ivARB(int $target, $v) {
  static $proc;
  return ($proc ??= GL::getProcAddress('multiTexCoord1ivARB'))($target, $v);
}

function glMultiTexCoord1s(int $target, int $s) {
  static $proc;
  return ($proc ??= GL::getProcAddress('multiTexCoord1s'))($target, $s);
}

function glMultiTexCoord1sARB(int $target, int $s) {
  static $proc;
  return ($proc ??= GL::getProcAddress('multiTexCoord1sARB'))($target, $s);
}

function glMultiTexCoord1sv(int $target, $v) {
  static $proc;
  return ($proc ??= GL::getProcAddress('multiTexCoord1sv'))($target, $v);
}

function glMultiTexCoord1svARB(int $target, $v) {
  static $proc;
  return ($proc ??= GL::getProcAddress('multiTexCoord1svARB'))($target, $v);
}

function glMultiTexCoord1xOES(int $texture, int $s) {
  static $proc;
  return ($proc ??= GL::getProcAddress('multiTexCoord1xOES'))($texture, $s);
}

function glMultiTexCoord1xvOES(int $texture, $coords) {
  static $proc;
  return ($proc ??= GL::getProcAddress('multiTexCoord1xvOES'))($texture, $coords);
}

function glMultiTexCoord2bOES(int $texture, int $s, int $t) {
  static $proc;
  return ($proc ??= GL::getProcAddress('multiTexCoord2bOES'))($texture, $s, $t);
}

function glMultiTexCoord2bvOES(int $texture, $coords) {
  static $proc;
  return ($proc ??= GL::getProcAddress('multiTexCoord2bvOES'))($texture, $coords);
}

function glMultiTexCoord2d(int $target, float $s, float $t) {
  static $proc;
  return ($proc ??= GL::getProcAddress('multiTexCoord2d'))($target, $s, $t);
}

function glMultiTexCoord2dARB(int $target, float $s, float $t) {
  static $proc;
  return ($proc ??= GL::getProcAddress('multiTexCoord2dARB'))($target, $s, $t);
}

function glMultiTexCoord2dv(int $target, $v) {
  static $proc;
  return ($proc ??= GL::getProcAddress('multiTexCoord2dv'))($target, $v);
}

function glMultiTexCoord2dvARB(int $target, $v) {
  static $proc;
  return ($proc ??= GL::getProcAddress('multiTexCoord2dvARB'))($target, $v);
}

function glMultiTexCoord2f(int $target, float $s, float $t) {
  static $proc;
  return ($proc ??= GL::getProcAddress('multiTexCoord2f'))($target, $s, $t);
}

function glMultiTexCoord2fARB(int $target, float $s, float $t) {
  static $proc;
  return ($proc ??= GL::getProcAddress('multiTexCoord2fARB'))($target, $s, $t);
}

function glMultiTexCoord2fv(int $target, $v) {
  static $proc;
  return ($proc ??= GL::getProcAddress('multiTexCoord2fv'))($target, $v);
}

function glMultiTexCoord2fvARB(int $target, $v) {
  static $proc;
  return ($proc ??= GL::getProcAddress('multiTexCoord2fvARB'))($target, $v);
}

function glMultiTexCoord2hNV(int $target, int $s, int $t) {
  static $proc;
  return ($proc ??= GL::getProcAddress('multiTexCoord2hNV'))($target, $s, $t);
}

function glMultiTexCoord2hvNV(int $target, $v) {
  static $proc;
  return ($proc ??= GL::getProcAddress('multiTexCoord2hvNV'))($target, $v);
}

function glMultiTexCoord2i(int $target, int $s, int $t) {
  static $proc;
  return ($proc ??= GL::getProcAddress('multiTexCoord2i'))($target, $s, $t);
}

function glMultiTexCoord2iARB(int $target, int $s, int $t) {
  static $proc;
  return ($proc ??= GL::getProcAddress('multiTexCoord2iARB'))($target, $s, $t);
}

function glMultiTexCoord2iv(int $target, $v) {
  static $proc;
  return ($proc ??= GL::getProcAddress('multiTexCoord2iv'))($target, $v);
}

function glMultiTexCoord2ivARB(int $target, $v) {
  static $proc;
  return ($proc ??= GL::getProcAddress('multiTexCoord2ivARB'))($target, $v);
}

function glMultiTexCoord2s(int $target, int $s, int $t) {
  static $proc;
  return ($proc ??= GL::getProcAddress('multiTexCoord2s'))($target, $s, $t);
}

function glMultiTexCoord2sARB(int $target, int $s, int $t) {
  static $proc;
  return ($proc ??= GL::getProcAddress('multiTexCoord2sARB'))($target, $s, $t);
}

function glMultiTexCoord2sv(int $target, $v) {
  static $proc;
  return ($proc ??= GL::getProcAddress('multiTexCoord2sv'))($target, $v);
}

function glMultiTexCoord2svARB(int $target, $v) {
  static $proc;
  return ($proc ??= GL::getProcAddress('multiTexCoord2svARB'))($target, $v);
}

function glMultiTexCoord2xOES(int $texture, int $s, int $t) {
  static $proc;
  return ($proc ??= GL::getProcAddress('multiTexCoord2xOES'))($texture, $s, $t);
}

function glMultiTexCoord2xvOES(int $texture, $coords) {
  static $proc;
  return ($proc ??= GL::getProcAddress('multiTexCoord2xvOES'))($texture, $coords);
}

function glMultiTexCoord3bOES(int $texture, int $s, int $t, int $r) {
  static $proc;
  return ($proc ??= GL::getProcAddress('multiTexCoord3bOES'))($texture, $s, $t, $r);
}

function glMultiTexCoord3bvOES(int $texture, $coords) {
  static $proc;
  return ($proc ??= GL::getProcAddress('multiTexCoord3bvOES'))($texture, $coords);
}

function glMultiTexCoord3d(int $target, float $s, float $t, float $r) {
  static $proc;
  return ($proc ??= GL::getProcAddress('multiTexCoord3d'))($target, $s, $t, $r);
}

function glMultiTexCoord3dARB(int $target, float $s, float $t, float $r) {
  static $proc;
  return ($proc ??= GL::getProcAddress('multiTexCoord3dARB'))($target, $s, $t, $r);
}

function glMultiTexCoord3dv(int $target, $v) {
  static $proc;
  return ($proc ??= GL::getProcAddress('multiTexCoord3dv'))($target, $v);
}

function glMultiTexCoord3dvARB(int $target, $v) {
  static $proc;
  return ($proc ??= GL::getProcAddress('multiTexCoord3dvARB'))($target, $v);
}

function glMultiTexCoord3f(int $target, float $s, float $t, float $r) {
  static $proc;
  return ($proc ??= GL::getProcAddress('multiTexCoord3f'))($target, $s, $t, $r);
}

function glMultiTexCoord3fARB(int $target, float $s, float $t, float $r) {
  static $proc;
  return ($proc ??= GL::getProcAddress('multiTexCoord3fARB'))($target, $s, $t, $r);
}

function glMultiTexCoord3fv(int $target, $v) {
  static $proc;
  return ($proc ??= GL::getProcAddress('multiTexCoord3fv'))($target, $v);
}

function glMultiTexCoord3fvARB(int $target, $v) {
  static $proc;
  return ($proc ??= GL::getProcAddress('multiTexCoord3fvARB'))($target, $v);
}

function glMultiTexCoord3hNV(int $target, int $s, int $t, int $r) {
  static $proc;
  return ($proc ??= GL::getProcAddress('multiTexCoord3hNV'))($target, $s, $t, $r);
}

function glMultiTexCoord3hvNV(int $target, $v) {
  static $proc;
  return ($proc ??= GL::getProcAddress('multiTexCoord3hvNV'))($target, $v);
}

function glMultiTexCoord3i(int $target, int $s, int $t, int $r) {
  static $proc;
  return ($proc ??= GL::getProcAddress('multiTexCoord3i'))($target, $s, $t, $r);
}

function glMultiTexCoord3iARB(int $target, int $s, int $t, int $r) {
  static $proc;
  return ($proc ??= GL::getProcAddress('multiTexCoord3iARB'))($target, $s, $t, $r);
}

function glMultiTexCoord3iv(int $target, $v) {
  static $proc;
  return ($proc ??= GL::getProcAddress('multiTexCoord3iv'))($target, $v);
}

function glMultiTexCoord3ivARB(int $target, $v) {
  static $proc;
  return ($proc ??= GL::getProcAddress('multiTexCoord3ivARB'))($target, $v);
}

function glMultiTexCoord3s(int $target, int $s, int $t, int $r) {
  static $proc;
  return ($proc ??= GL::getProcAddress('multiTexCoord3s'))($target, $s, $t, $r);
}

function glMultiTexCoord3sARB(int $target, int $s, int $t, int $r) {
  static $proc;
  return ($proc ??= GL::getProcAddress('multiTexCoord3sARB'))($target, $s, $t, $r);
}

function glMultiTexCoord3sv(int $target, $v) {
  static $proc;
  return ($proc ??= GL::getProcAddress('multiTexCoord3sv'))($target, $v);
}

function glMultiTexCoord3svARB(int $target, $v) {
  static $proc;
  return ($proc ??= GL::getProcAddress('multiTexCoord3svARB'))($target, $v);
}

function glMultiTexCoord3xOES(int $texture, int $s, int $t, int $r) {
  static $proc;
  return ($proc ??= GL::getProcAddress('multiTexCoord3xOES'))($texture, $s, $t, $r);
}

function glMultiTexCoord3xvOES(int $texture, $coords) {
  static $proc;
  return ($proc ??= GL::getProcAddress('multiTexCoord3xvOES'))($texture, $coords);
}

function glMultiTexCoord4bOES(int $texture, int $s, int $t, int $r, int $q) {
  static $proc;
  return ($proc ??= GL::getProcAddress('multiTexCoord4bOES'))($texture, $s, $t, $r, $q);
}

function glMultiTexCoord4bvOES(int $texture, $coords) {
  static $proc;
  return ($proc ??= GL::getProcAddress('multiTexCoord4bvOES'))($texture, $coords);
}

function glMultiTexCoord4d(int $target, float $s, float $t, float $r, float $q) {
  static $proc;
  return ($proc ??= GL::getProcAddress('multiTexCoord4d'))($target, $s, $t, $r, $q);
}

function glMultiTexCoord4dARB(int $target, float $s, float $t, float $r, float $q) {
  static $proc;
  return ($proc ??= GL::getProcAddress('multiTexCoord4dARB'))($target, $s, $t, $r, $q);
}

function glMultiTexCoord4dv(int $target, $v) {
  static $proc;
  return ($proc ??= GL::getProcAddress('multiTexCoord4dv'))($target, $v);
}

function glMultiTexCoord4dvARB(int $target, $v) {
  static $proc;
  return ($proc ??= GL::getProcAddress('multiTexCoord4dvARB'))($target, $v);
}

function glMultiTexCoord4f(int $target, float $s, float $t, float $r, float $q) {
  static $proc;
  return ($proc ??= GL::getProcAddress('multiTexCoord4f'))($target, $s, $t, $r, $q);
}

function glMultiTexCoord4fARB(int $target, float $s, float $t, float $r, float $q) {
  static $proc;
  return ($proc ??= GL::getProcAddress('multiTexCoord4fARB'))($target, $s, $t, $r, $q);
}

function glMultiTexCoord4fv(int $target, $v) {
  static $proc;
  return ($proc ??= GL::getProcAddress('multiTexCoord4fv'))($target, $v);
}

function glMultiTexCoord4fvARB(int $target, $v) {
  static $proc;
  return ($proc ??= GL::getProcAddress('multiTexCoord4fvARB'))($target, $v);
}

function glMultiTexCoord4hNV(int $target, int $s, int $t, int $r, int $q) {
  static $proc;
  return ($proc ??= GL::getProcAddress('multiTexCoord4hNV'))($target, $s, $t, $r, $q);
}

function glMultiTexCoord4hvNV(int $target, $v) {
  static $proc;
  return ($proc ??= GL::getProcAddress('multiTexCoord4hvNV'))($target, $v);
}

function glMultiTexCoord4i(int $target, int $s, int $t, int $r, int $q) {
  static $proc;
  return ($proc ??= GL::getProcAddress('multiTexCoord4i'))($target, $s, $t, $r, $q);
}

function glMultiTexCoord4iARB(int $target, int $s, int $t, int $r, int $q) {
  static $proc;
  return ($proc ??= GL::getProcAddress('multiTexCoord4iARB'))($target, $s, $t, $r, $q);
}

function glMultiTexCoord4iv(int $target, $v) {
  static $proc;
  return ($proc ??= GL::getProcAddress('multiTexCoord4iv'))($target, $v);
}

function glMultiTexCoord4ivARB(int $target, $v) {
  static $proc;
  return ($proc ??= GL::getProcAddress('multiTexCoord4ivARB'))($target, $v);
}

function glMultiTexCoord4s(int $target, int $s, int $t, int $r, int $q) {
  static $proc;
  return ($proc ??= GL::getProcAddress('multiTexCoord4s'))($target, $s, $t, $r, $q);
}

function glMultiTexCoord4sARB(int $target, int $s, int $t, int $r, int $q) {
  static $proc;
  return ($proc ??= GL::getProcAddress('multiTexCoord4sARB'))($target, $s, $t, $r, $q);
}

function glMultiTexCoord4sv(int $target, $v) {
  static $proc;
  return ($proc ??= GL::getProcAddress('multiTexCoord4sv'))($target, $v);
}

function glMultiTexCoord4svARB(int $target, $v) {
  static $proc;
  return ($proc ??= GL::getProcAddress('multiTexCoord4svARB'))($target, $v);
}

function glMultiTexCoord4x(int $texture, int $s, int $t, int $r, int $q) {
  static $proc;
  return ($proc ??= GL::getProcAddress('multiTexCoord4x'))($texture, $s, $t, $r, $q);
}

function glMultiTexCoord4xOES(int $texture, int $s, int $t, int $r, int $q) {
  static $proc;
  return ($proc ??= GL::getProcAddress('multiTexCoord4xOES'))($texture, $s, $t, $r, $q);
}

function glMultiTexCoord4xvOES(int $texture, $coords) {
  static $proc;
  return ($proc ??= GL::getProcAddress('multiTexCoord4xvOES'))($texture, $coords);
}

function glMultiTexCoordP1ui(int $texture, int $type, int $coords) {
  static $proc;
  return ($proc ??= GL::getProcAddress('multiTexCoordP1ui'))($texture, $type, $coords);
}

function glMultiTexCoordP1uiv(int $texture, int $type, $coords) {
  static $proc;
  return ($proc ??= GL::getProcAddress('multiTexCoordP1uiv'))($texture, $type, $coords);
}

function glMultiTexCoordP2ui(int $texture, int $type, int $coords) {
  static $proc;
  return ($proc ??= GL::getProcAddress('multiTexCoordP2ui'))($texture, $type, $coords);
}

function glMultiTexCoordP2uiv(int $texture, int $type, $coords) {
  static $proc;
  return ($proc ??= GL::getProcAddress('multiTexCoordP2uiv'))($texture, $type, $coords);
}

function glMultiTexCoordP3ui(int $texture, int $type, int $coords) {
  static $proc;
  return ($proc ??= GL::getProcAddress('multiTexCoordP3ui'))($texture, $type, $coords);
}

function glMultiTexCoordP3uiv(int $texture, int $type, $coords) {
  static $proc;
  return ($proc ??= GL::getProcAddress('multiTexCoordP3uiv'))($texture, $type, $coords);
}

function glMultiTexCoordP4ui(int $texture, int $type, int $coords) {
  static $proc;
  return ($proc ??= GL::getProcAddress('multiTexCoordP4ui'))($texture, $type, $coords);
}

function glMultiTexCoordP4uiv(int $texture, int $type, $coords) {
  static $proc;
  return ($proc ??= GL::getProcAddress('multiTexCoordP4uiv'))($texture, $type, $coords);
}

function glMultiTexCoordPointerEXT(int $texunit, int $size, int $type, int $stride, $pointer) {
  static $proc;
  return ($proc ??= GL::getProcAddress('multiTexCoordPointerEXT'))($texunit, $size, $type, $stride, $pointer);
}

function glMultiTexEnvfEXT(int $texunit, int $target, int $pname, float $param) {
  static $proc;
  return ($proc ??= GL::getProcAddress('multiTexEnvfEXT'))($texunit, $target, $pname, $param);
}

function glMultiTexEnvfvEXT(int $texunit, int $target, int $pname, $params) {
  static $proc;
  return ($proc ??= GL::getProcAddress('multiTexEnvfvEXT'))($texunit, $target, $pname, $params);
}

function glMultiTexEnviEXT(int $texunit, int $target, int $pname, int $param) {
  static $proc;
  return ($proc ??= GL::getProcAddress('multiTexEnviEXT'))($texunit, $target, $pname, $param);
}

function glMultiTexEnvivEXT(int $texunit, int $target, int $pname, $params) {
  static $proc;
  return ($proc ??= GL::getProcAddress('multiTexEnvivEXT'))($texunit, $target, $pname, $params);
}

function glMultiTexGendEXT(int $texunit, int $coord, int $pname, float $param) {
  static $proc;
  return ($proc ??= GL::getProcAddress('multiTexGendEXT'))($texunit, $coord, $pname, $param);
}

function glMultiTexGendvEXT(int $texunit, int $coord, int $pname, $params) {
  static $proc;
  return ($proc ??= GL::getProcAddress('multiTexGendvEXT'))($texunit, $coord, $pname, $params);
}

function glMultiTexGenfEXT(int $texunit, int $coord, int $pname, float $param) {
  static $proc;
  return ($proc ??= GL::getProcAddress('multiTexGenfEXT'))($texunit, $coord, $pname, $param);
}

function glMultiTexGenfvEXT(int $texunit, int $coord, int $pname, $params) {
  static $proc;
  return ($proc ??= GL::getProcAddress('multiTexGenfvEXT'))($texunit, $coord, $pname, $params);
}

function glMultiTexGeniEXT(int $texunit, int $coord, int $pname, int $param) {
  static $proc;
  return ($proc ??= GL::getProcAddress('multiTexGeniEXT'))($texunit, $coord, $pname, $param);
}

function glMultiTexGenivEXT(int $texunit, int $coord, int $pname, $params) {
  static $proc;
  return ($proc ??= GL::getProcAddress('multiTexGenivEXT'))($texunit, $coord, $pname, $params);
}

function glMultiTexImage1DEXT(int $texunit, int $target, int $level, int $internalformat, int $width, int $border, int $format, int $type, $pixels) {
  static $proc;
  return ($proc ??= GL::getProcAddress('multiTexImage1DEXT'))($texunit, $target, $level, $internalformat, $width, $border, $format, $type, $pixels);
}

function glMultiTexImage2DEXT(int $texunit, int $target, int $level, int $internalformat, int $width, int $height, int $border, int $format, int $type, $pixels) {
  static $proc;
  return ($proc ??= GL::getProcAddress('multiTexImage2DEXT'))($texunit, $target, $level, $internalformat, $width, $height, $border, $format, $type, $pixels);
}

function glMultiTexImage3DEXT(int $texunit, int $target, int $level, int $internalformat, int $width, int $height, int $depth, int $border, int $format, int $type, $pixels) {
  static $proc;
  return ($proc ??= GL::getProcAddress('multiTexImage3DEXT'))($texunit, $target, $level, $internalformat, $width, $height, $depth, $border, $format, $type, $pixels);
}

function glMultiTexParameterIivEXT(int $texunit, int $target, int $pname, $params) {
  static $proc;
  return ($proc ??= GL::getProcAddress('multiTexParameterIivEXT'))($texunit, $target, $pname, $params);
}

function glMultiTexParameterIuivEXT(int $texunit, int $target, int $pname, $params) {
  static $proc;
  return ($proc ??= GL::getProcAddress('multiTexParameterIuivEXT'))($texunit, $target, $pname, $params);
}

function glMultiTexParameterfEXT(int $texunit, int $target, int $pname, float $param) {
  static $proc;
  return ($proc ??= GL::getProcAddress('multiTexParameterfEXT'))($texunit, $target, $pname, $param);
}

function glMultiTexParameterfvEXT(int $texunit, int $target, int $pname, $params) {
  static $proc;
  return ($proc ??= GL::getProcAddress('multiTexParameterfvEXT'))($texunit, $target, $pname, $params);
}

function glMultiTexParameteriEXT(int $texunit, int $target, int $pname, int $param) {
  static $proc;
  return ($proc ??= GL::getProcAddress('multiTexParameteriEXT'))($texunit, $target, $pname, $param);
}

function glMultiTexParameterivEXT(int $texunit, int $target, int $pname, $params) {
  static $proc;
  return ($proc ??= GL::getProcAddress('multiTexParameterivEXT'))($texunit, $target, $pname, $params);
}

function glMultiTexRenderbufferEXT(int $texunit, int $target, int $renderbuffer) {
  static $proc;
  return ($proc ??= GL::getProcAddress('multiTexRenderbufferEXT'))($texunit, $target, $renderbuffer);
}

function glMultiTexSubImage1DEXT(int $texunit, int $target, int $level, int $xoffset, int $width, int $format, int $type, $pixels) {
  static $proc;
  return ($proc ??= GL::getProcAddress('multiTexSubImage1DEXT'))($texunit, $target, $level, $xoffset, $width, $format, $type, $pixels);
}

function glMultiTexSubImage2DEXT(int $texunit, int $target, int $level, int $xoffset, int $yoffset, int $width, int $height, int $format, int $type, $pixels) {
  static $proc;
  return ($proc ??= GL::getProcAddress('multiTexSubImage2DEXT'))($texunit, $target, $level, $xoffset, $yoffset, $width, $height, $format, $type, $pixels);
}

function glMultiTexSubImage3DEXT(int $texunit, int $target, int $level, int $xoffset, int $yoffset, int $zoffset, int $width, int $height, int $depth, int $format, int $type, $pixels) {
  static $proc;
  return ($proc ??= GL::getProcAddress('multiTexSubImage3DEXT'))($texunit, $target, $level, $xoffset, $yoffset, $zoffset, $width, $height, $depth, $format, $type, $pixels);
}

function glNamedBufferData(int $buffer, int $size, $data, int $usage) {
  static $proc;
  return ($proc ??= GL::getProcAddress('namedBufferData'))($buffer, $size, $data, $usage);
}

function glNamedBufferDataEXT(int $buffer, int $size, $data, int $usage) {
  static $proc;
  return ($proc ??= GL::getProcAddress('namedBufferDataEXT'))($buffer, $size, $data, $usage);
}

function glNamedBufferPageCommitmentARB(int $buffer, int $offset, int $size, int $commit) {
  static $proc;
  return ($proc ??= GL::getProcAddress('namedBufferPageCommitmentARB'))($buffer, $offset, $size, $commit);
}

function glNamedBufferPageCommitmentEXT(int $buffer, int $offset, int $size, int $commit) {
  static $proc;
  return ($proc ??= GL::getProcAddress('namedBufferPageCommitmentEXT'))($buffer, $offset, $size, $commit);
}

function glNamedBufferStorage(int $buffer, int $size, $data, int $flags) {
  static $proc;
  return ($proc ??= GL::getProcAddress('namedBufferStorage'))($buffer, $size, $data, $flags);
}

function glNamedBufferStorageEXT(int $buffer, int $size, $data, int $flags) {
  static $proc;
  return ($proc ??= GL::getProcAddress('namedBufferStorageEXT'))($buffer, $size, $data, $flags);
}

function glNamedBufferSubData(int $buffer, int $offset, int $size, $data) {
  static $proc;
  return ($proc ??= GL::getProcAddress('namedBufferSubData'))($buffer, $offset, $size, $data);
}

function glNamedBufferSubDataEXT(int $buffer, int $offset, int $size, $data) {
  static $proc;
  return ($proc ??= GL::getProcAddress('namedBufferSubDataEXT'))($buffer, $offset, $size, $data);
}

function glNamedCopyBufferSubDataEXT(int $readBuffer, int $writeBuffer, int $readOffset, int $writeOffset, int $size) {
  static $proc;
  return ($proc ??= GL::getProcAddress('namedCopyBufferSubDataEXT'))($readBuffer, $writeBuffer, $readOffset, $writeOffset, $size);
}

function glNamedFramebufferDrawBuffer(int $framebuffer, int $buf) {
  static $proc;
  return ($proc ??= GL::getProcAddress('namedFramebufferDrawBuffer'))($framebuffer, $buf);
}

function glNamedFramebufferDrawBuffers(int $framebuffer, int $n, $bufs) {
  static $proc;
  return ($proc ??= GL::getProcAddress('namedFramebufferDrawBuffers'))($framebuffer, $n, $bufs);
}

function glNamedFramebufferParameteri(int $framebuffer, int $pname, int $param) {
  static $proc;
  return ($proc ??= GL::getProcAddress('namedFramebufferParameteri'))($framebuffer, $pname, $param);
}

function glNamedFramebufferParameteriEXT(int $framebuffer, int $pname, int $param) {
  static $proc;
  return ($proc ??= GL::getProcAddress('namedFramebufferParameteriEXT'))($framebuffer, $pname, $param);
}

function glNamedFramebufferReadBuffer(int $framebuffer, int $src) {
  static $proc;
  return ($proc ??= GL::getProcAddress('namedFramebufferReadBuffer'))($framebuffer, $src);
}

function glNamedFramebufferRenderbuffer(int $framebuffer, int $attachment, int $renderbuffertarget, int $renderbuffer) {
  static $proc;
  return ($proc ??= GL::getProcAddress('namedFramebufferRenderbuffer'))($framebuffer, $attachment, $renderbuffertarget, $renderbuffer);
}

function glNamedFramebufferRenderbufferEXT(int $framebuffer, int $attachment, int $renderbuffertarget, int $renderbuffer) {
  static $proc;
  return ($proc ??= GL::getProcAddress('namedFramebufferRenderbufferEXT'))($framebuffer, $attachment, $renderbuffertarget, $renderbuffer);
}

function glNamedFramebufferSampleLocationsfvARB(int $framebuffer, int $start, int $count, $v) {
  static $proc;
  return ($proc ??= GL::getProcAddress('namedFramebufferSampleLocationsfvARB'))($framebuffer, $start, $count, $v);
}

function glNamedFramebufferSampleLocationsfvNV(int $framebuffer, int $start, int $count, $v) {
  static $proc;
  return ($proc ??= GL::getProcAddress('namedFramebufferSampleLocationsfvNV'))($framebuffer, $start, $count, $v);
}

function glNamedFramebufferTexture(int $framebuffer, int $attachment, int $texture, int $level) {
  static $proc;
  return ($proc ??= GL::getProcAddress('namedFramebufferTexture'))($framebuffer, $attachment, $texture, $level);
}

function glNamedFramebufferSamplePositionsfvAMD(int $framebuffer, int $numsamples, int $pixelindex, $values) {
  static $proc;
  return ($proc ??= GL::getProcAddress('namedFramebufferSamplePositionsfvAMD'))($framebuffer, $numsamples, $pixelindex, $values);
}

function glNamedFramebufferTexture1DEXT(int $framebuffer, int $attachment, int $textarget, int $texture, int $level) {
  static $proc;
  return ($proc ??= GL::getProcAddress('namedFramebufferTexture1DEXT'))($framebuffer, $attachment, $textarget, $texture, $level);
}

function glNamedFramebufferTexture2DEXT(int $framebuffer, int $attachment, int $textarget, int $texture, int $level) {
  static $proc;
  return ($proc ??= GL::getProcAddress('namedFramebufferTexture2DEXT'))($framebuffer, $attachment, $textarget, $texture, $level);
}

function glNamedFramebufferTexture3DEXT(int $framebuffer, int $attachment, int $textarget, int $texture, int $level, int $zoffset) {
  static $proc;
  return ($proc ??= GL::getProcAddress('namedFramebufferTexture3DEXT'))($framebuffer, $attachment, $textarget, $texture, $level, $zoffset);
}

function glNamedFramebufferTextureEXT(int $framebuffer, int $attachment, int $texture, int $level) {
  static $proc;
  return ($proc ??= GL::getProcAddress('namedFramebufferTextureEXT'))($framebuffer, $attachment, $texture, $level);
}

function glNamedFramebufferTextureFaceEXT(int $framebuffer, int $attachment, int $texture, int $level, int $face) {
  static $proc;
  return ($proc ??= GL::getProcAddress('namedFramebufferTextureFaceEXT'))($framebuffer, $attachment, $texture, $level, $face);
}

function glNamedFramebufferTextureLayer(int $framebuffer, int $attachment, int $texture, int $level, int $layer) {
  static $proc;
  return ($proc ??= GL::getProcAddress('namedFramebufferTextureLayer'))($framebuffer, $attachment, $texture, $level, $layer);
}

function glNamedFramebufferTextureLayerEXT(int $framebuffer, int $attachment, int $texture, int $level, int $layer) {
  static $proc;
  return ($proc ??= GL::getProcAddress('namedFramebufferTextureLayerEXT'))($framebuffer, $attachment, $texture, $level, $layer);
}

function glNamedProgramLocalParameter4dEXT(int $program, int $target, int $index, float $x, float $y, float $z, float $w) {
  static $proc;
  return ($proc ??= GL::getProcAddress('namedProgramLocalParameter4dEXT'))($program, $target, $index, $x, $y, $z, $w);
}

function glNamedProgramLocalParameter4dvEXT(int $program, int $target, int $index, $params) {
  static $proc;
  return ($proc ??= GL::getProcAddress('namedProgramLocalParameter4dvEXT'))($program, $target, $index, $params);
}

function glNamedProgramLocalParameter4fEXT(int $program, int $target, int $index, float $x, float $y, float $z, float $w) {
  static $proc;
  return ($proc ??= GL::getProcAddress('namedProgramLocalParameter4fEXT'))($program, $target, $index, $x, $y, $z, $w);
}

function glNamedProgramLocalParameter4fvEXT(int $program, int $target, int $index, $params) {
  static $proc;
  return ($proc ??= GL::getProcAddress('namedProgramLocalParameter4fvEXT'))($program, $target, $index, $params);
}

function glNamedProgramLocalParameterI4iEXT(int $program, int $target, int $index, int $x, int $y, int $z, int $w) {
  static $proc;
  return ($proc ??= GL::getProcAddress('namedProgramLocalParameterI4iEXT'))($program, $target, $index, $x, $y, $z, $w);
}

function glNamedProgramLocalParameterI4ivEXT(int $program, int $target, int $index, $params) {
  static $proc;
  return ($proc ??= GL::getProcAddress('namedProgramLocalParameterI4ivEXT'))($program, $target, $index, $params);
}

function glNamedProgramLocalParameterI4uiEXT(int $program, int $target, int $index, int $x, int $y, int $z, int $w) {
  static $proc;
  return ($proc ??= GL::getProcAddress('namedProgramLocalParameterI4uiEXT'))($program, $target, $index, $x, $y, $z, $w);
}

function glNamedProgramLocalParameterI4uivEXT(int $program, int $target, int $index, $params) {
  static $proc;
  return ($proc ??= GL::getProcAddress('namedProgramLocalParameterI4uivEXT'))($program, $target, $index, $params);
}

function glNamedProgramLocalParameters4fvEXT(int $program, int $target, int $index, int $count, $params) {
  static $proc;
  return ($proc ??= GL::getProcAddress('namedProgramLocalParameters4fvEXT'))($program, $target, $index, $count, $params);
}

function glNamedProgramLocalParametersI4ivEXT(int $program, int $target, int $index, int $count, $params) {
  static $proc;
  return ($proc ??= GL::getProcAddress('namedProgramLocalParametersI4ivEXT'))($program, $target, $index, $count, $params);
}

function glNamedProgramLocalParametersI4uivEXT(int $program, int $target, int $index, int $count, $params) {
  static $proc;
  return ($proc ??= GL::getProcAddress('namedProgramLocalParametersI4uivEXT'))($program, $target, $index, $count, $params);
}

function glNamedProgramStringEXT(int $program, int $target, int $format, int $len, $string) {
  static $proc;
  return ($proc ??= GL::getProcAddress('namedProgramStringEXT'))($program, $target, $format, $len, $string);
}

function glNamedRenderbufferStorage(int $renderbuffer, int $internalformat, int $width, int $height) {
  static $proc;
  return ($proc ??= GL::getProcAddress('namedRenderbufferStorage'))($renderbuffer, $internalformat, $width, $height);
}

function glNamedRenderbufferStorageEXT(int $renderbuffer, int $internalformat, int $width, int $height) {
  static $proc;
  return ($proc ??= GL::getProcAddress('namedRenderbufferStorageEXT'))($renderbuffer, $internalformat, $width, $height);
}

function glNamedRenderbufferStorageMultisample(int $renderbuffer, int $samples, int $internalformat, int $width, int $height) {
  static $proc;
  return ($proc ??= GL::getProcAddress('namedRenderbufferStorageMultisample'))($renderbuffer, $samples, $internalformat, $width, $height);
}

function glNamedRenderbufferStorageMultisampleCoverageEXT(int $renderbuffer, int $coverageSamples, int $colorSamples, int $internalformat, int $width, int $height) {
  static $proc;
  return ($proc ??= GL::getProcAddress('namedRenderbufferStorageMultisampleCoverageEXT'))($renderbuffer, $coverageSamples, $colorSamples, $internalformat, $width, $height);
}

function glNamedRenderbufferStorageMultisampleEXT(int $renderbuffer, int $samples, int $internalformat, int $width, int $height) {
  static $proc;
  return ($proc ??= GL::getProcAddress('namedRenderbufferStorageMultisampleEXT'))($renderbuffer, $samples, $internalformat, $width, $height);
}

function glNamedStringARB(int $type, int $namelen, $name, int $stringlen, $string) {
  static $proc;
  return ($proc ??= GL::getProcAddress('namedStringARB'))($type, $namelen, $name, $stringlen, $string);
}

function glNewList(int $list, int $mode) {
  static $proc;
  return ($proc ??= GL::getProcAddress('newList'))($list, $mode);
}

function glNewObjectBufferATI(int $size, $pointer, int $usage) {
  static $proc;
  return ($proc ??= GL::getProcAddress('newObjectBufferATI'))($size, $pointer, $usage);
}

function glNormal3b(int $nx, int $ny, int $nz) {
  static $proc;
  return ($proc ??= GL::getProcAddress('normal3b'))($nx, $ny, $nz);
}

function glNormal3bv($v) {
  static $proc;
  return ($proc ??= GL::getProcAddress('normal3bv'))($v);
}

function glNormal3d(float $nx, float $ny, float $nz) {
  static $proc;
  return ($proc ??= GL::getProcAddress('normal3d'))($nx, $ny, $nz);
}

function glNormal3dv($v) {
  static $proc;
  return ($proc ??= GL::getProcAddress('normal3dv'))($v);
}

function glNormal3f(float $nx, float $ny, float $nz) {
  static $proc;
  return ($proc ??= GL::getProcAddress('normal3f'))($nx, $ny, $nz);
}

function glNormal3fVertex3fSUN(float $nx, float $ny, float $nz, float $x, float $y, float $z) {
  static $proc;
  return ($proc ??= GL::getProcAddress('normal3fVertex3fSUN'))($nx, $ny, $nz, $x, $y, $z);
}

function glNormal3fVertex3fvSUN($n, $v) {
  static $proc;
  return ($proc ??= GL::getProcAddress('normal3fVertex3fvSUN'))($n, $v);
}

function glNormal3fv($v) {
  static $proc;
  return ($proc ??= GL::getProcAddress('normal3fv'))($v);
}

function glNormal3hNV(int $nx, int $ny, int $nz) {
  static $proc;
  return ($proc ??= GL::getProcAddress('normal3hNV'))($nx, $ny, $nz);
}

function glNormal3hvNV($v) {
  static $proc;
  return ($proc ??= GL::getProcAddress('normal3hvNV'))($v);
}

function glNormal3i(int $nx, int $ny, int $nz) {
  static $proc;
  return ($proc ??= GL::getProcAddress('normal3i'))($nx, $ny, $nz);
}

function glNormal3iv($v) {
  static $proc;
  return ($proc ??= GL::getProcAddress('normal3iv'))($v);
}

function glNormal3s(int $nx, int $ny, int $nz) {
  static $proc;
  return ($proc ??= GL::getProcAddress('normal3s'))($nx, $ny, $nz);
}

function glNormal3sv($v) {
  static $proc;
  return ($proc ??= GL::getProcAddress('normal3sv'))($v);
}

function glNormal3x(int $nx, int $ny, int $nz) {
  static $proc;
  return ($proc ??= GL::getProcAddress('normal3x'))($nx, $ny, $nz);
}

function glNormal3xOES(int $nx, int $ny, int $nz) {
  static $proc;
  return ($proc ??= GL::getProcAddress('normal3xOES'))($nx, $ny, $nz);
}

function glNormal3xvOES($coords) {
  static $proc;
  return ($proc ??= GL::getProcAddress('normal3xvOES'))($coords);
}

function glNormalFormatNV(int $type, int $stride) {
  static $proc;
  return ($proc ??= GL::getProcAddress('normalFormatNV'))($type, $stride);
}

function glNormalP3ui(int $type, int $coords) {
  static $proc;
  return ($proc ??= GL::getProcAddress('normalP3ui'))($type, $coords);
}

function glNormalP3uiv(int $type, $coords) {
  static $proc;
  return ($proc ??= GL::getProcAddress('normalP3uiv'))($type, $coords);
}

function glNormalPointer(int $type, int $stride, $pointer) {
  static $proc;
  return ($proc ??= GL::getProcAddress('normalPointer'))($type, $stride, $pointer);
}

function glNormalPointerEXT(int $type, int $stride, int $count, $pointer) {
  static $proc;
  return ($proc ??= GL::getProcAddress('normalPointerEXT'))($type, $stride, $count, $pointer);
}

function glNormalPointerListIBM(int $type, int $stride, $pointer, int $ptrstride) {
  static $proc;
  return ($proc ??= GL::getProcAddress('normalPointerListIBM'))($type, $stride, $pointer, $ptrstride);
}

function glNormalPointervINTEL(int $type, $pointer) {
  static $proc;
  return ($proc ??= GL::getProcAddress('normalPointervINTEL'))($type, $pointer);
}

function glNormalStream3bATI(int $stream, int $nx, int $ny, int $nz) {
  static $proc;
  return ($proc ??= GL::getProcAddress('normalStream3bATI'))($stream, $nx, $ny, $nz);
}

function glNormalStream3bvATI(int $stream, $coords) {
  static $proc;
  return ($proc ??= GL::getProcAddress('normalStream3bvATI'))($stream, $coords);
}

function glNormalStream3dATI(int $stream, float $nx, float $ny, float $nz) {
  static $proc;
  return ($proc ??= GL::getProcAddress('normalStream3dATI'))($stream, $nx, $ny, $nz);
}

function glNormalStream3dvATI(int $stream, $coords) {
  static $proc;
  return ($proc ??= GL::getProcAddress('normalStream3dvATI'))($stream, $coords);
}

function glNormalStream3fATI(int $stream, float $nx, float $ny, float $nz) {
  static $proc;
  return ($proc ??= GL::getProcAddress('normalStream3fATI'))($stream, $nx, $ny, $nz);
}

function glNormalStream3fvATI(int $stream, $coords) {
  static $proc;
  return ($proc ??= GL::getProcAddress('normalStream3fvATI'))($stream, $coords);
}

function glNormalStream3iATI(int $stream, int $nx, int $ny, int $nz) {
  static $proc;
  return ($proc ??= GL::getProcAddress('normalStream3iATI'))($stream, $nx, $ny, $nz);
}

function glNormalStream3ivATI(int $stream, $coords) {
  static $proc;
  return ($proc ??= GL::getProcAddress('normalStream3ivATI'))($stream, $coords);
}

function glNormalStream3sATI(int $stream, int $nx, int $ny, int $nz) {
  static $proc;
  return ($proc ??= GL::getProcAddress('normalStream3sATI'))($stream, $nx, $ny, $nz);
}

function glNormalStream3svATI(int $stream, $coords) {
  static $proc;
  return ($proc ??= GL::getProcAddress('normalStream3svATI'))($stream, $coords);
}

function glObjectLabel(int $identifier, int $name, int $length, $label) {
  static $proc;
  return ($proc ??= GL::getProcAddress('objectLabel'))($identifier, $name, $length, $label);
}

function glObjectLabelKHR(int $identifier, int $name, int $length, $label) {
  static $proc;
  return ($proc ??= GL::getProcAddress('objectLabelKHR'))($identifier, $name, $length, $label);
}

function glObjectPtrLabel($ptr, int $length, $label) {
  static $proc;
  return ($proc ??= GL::getProcAddress('objectPtrLabel'))($ptr, $length, $label);
}

function glObjectPtrLabelKHR($ptr, int $length, $label) {
  static $proc;
  return ($proc ??= GL::getProcAddress('objectPtrLabelKHR'))($ptr, $length, $label);
}

function glObjectPurgeableAPPLE(int $objectType, int $name, int $option) {
  static $proc;
  return ($proc ??= GL::getProcAddress('objectPurgeableAPPLE'))($objectType, $name, $option);
}

function glObjectUnpurgeableAPPLE(int $objectType, int $name, int $option) {
  static $proc;
  return ($proc ??= GL::getProcAddress('objectUnpurgeableAPPLE'))($objectType, $name, $option);
}

function glOrtho(float $left, float $right, float $bottom, float $top, float $zNear, float $zFar) {
  static $proc;
  return ($proc ??= GL::getProcAddress('ortho'))($left, $right, $bottom, $top, $zNear, $zFar);
}

function glOrthof(float $l, float $r, float $b, float $t, float $n, float $f) {
  static $proc;
  return ($proc ??= GL::getProcAddress('orthof'))($l, $r, $b, $t, $n, $f);
}

function glOrthofOES(float $l, float $r, float $b, float $t, float $n, float $f) {
  static $proc;
  return ($proc ??= GL::getProcAddress('orthofOES'))($l, $r, $b, $t, $n, $f);
}

function glOrthox(int $l, int $r, int $b, int $t, int $n, int $f) {
  static $proc;
  return ($proc ??= GL::getProcAddress('orthox'))($l, $r, $b, $t, $n, $f);
}

function glOrthoxOES(int $l, int $r, int $b, int $t, int $n, int $f) {
  static $proc;
  return ($proc ??= GL::getProcAddress('orthoxOES'))($l, $r, $b, $t, $n, $f);
}

function glPNTrianglesfATI(int $pname, float $param) {
  static $proc;
  return ($proc ??= GL::getProcAddress('pNTrianglesfATI'))($pname, $param);
}

function glPNTrianglesiATI(int $pname, int $param) {
  static $proc;
  return ($proc ??= GL::getProcAddress('pNTrianglesiATI'))($pname, $param);
}

function glPassTexCoordATI(int $dst, int $coord, int $swizzle) {
  static $proc;
  return ($proc ??= GL::getProcAddress('passTexCoordATI'))($dst, $coord, $swizzle);
}

function glPassThrough(float $token) {
  static $proc;
  return ($proc ??= GL::getProcAddress('passThrough'))($token);
}

function glPassThroughxOES(int $token) {
  static $proc;
  return ($proc ??= GL::getProcAddress('passThroughxOES'))($token);
}

function glPatchParameterfv(int $pname, $values) {
  static $proc;
  return ($proc ??= GL::getProcAddress('patchParameterfv'))($pname, $values);
}

function glPatchParameteri(int $pname, int $value) {
  static $proc;
  return ($proc ??= GL::getProcAddress('patchParameteri'))($pname, $value);
}

function glPatchParameteriEXT(int $pname, int $value) {
  static $proc;
  return ($proc ??= GL::getProcAddress('patchParameteriEXT'))($pname, $value);
}

function glPatchParameteriOES(int $pname, int $value) {
  static $proc;
  return ($proc ??= GL::getProcAddress('patchParameteriOES'))($pname, $value);
}

function glPathColorGenNV(int $color, int $genMode, int $colorFormat, $coeffs) {
  static $proc;
  return ($proc ??= GL::getProcAddress('pathColorGenNV'))($color, $genMode, $colorFormat, $coeffs);
}

function glPathCommandsNV(int $path, int $numCommands, $commands, int $numCoords, int $coordType, $coords) {
  static $proc;
  return ($proc ??= GL::getProcAddress('pathCommandsNV'))($path, $numCommands, $commands, $numCoords, $coordType, $coords);
}

function glPathCoordsNV(int $path, int $numCoords, int $coordType, $coords) {
  static $proc;
  return ($proc ??= GL::getProcAddress('pathCoordsNV'))($path, $numCoords, $coordType, $coords);
}

function glPathCoverDepthFuncNV(int $func) {
  static $proc;
  return ($proc ??= GL::getProcAddress('pathCoverDepthFuncNV'))($func);
}

function glPathDashArrayNV(int $path, int $dashCount, $dashArray) {
  static $proc;
  return ($proc ??= GL::getProcAddress('pathDashArrayNV'))($path, $dashCount, $dashArray);
}

function glPathFogGenNV(int $genMode) {
  static $proc;
  return ($proc ??= GL::getProcAddress('pathFogGenNV'))($genMode);
}

function glPathGlyphIndexArrayNV(int $firstPathName, int $fontTarget, $fontName, int $fontStyle, int $firstGlyphIndex, int $numGlyphs, int $pathParameterTemplate, float $emScale) {
  static $proc;
  return ($proc ??= GL::getProcAddress('pathGlyphIndexArrayNV'))($firstPathName, $fontTarget, $fontName, $fontStyle, $firstGlyphIndex, $numGlyphs, $pathParameterTemplate, $emScale);
}

function glPathGlyphIndexRangeNV(int $fontTarget, $fontName, int $fontStyle, int $pathParameterTemplate, float $emScale, $baseAndCount) {
  static $proc;
  return ($proc ??= GL::getProcAddress('pathGlyphIndexRangeNV'))($fontTarget, $fontName, $fontStyle, $pathParameterTemplate, $emScale, $baseAndCount);
}

function glPathGlyphRangeNV(int $firstPathName, int $fontTarget, $fontName, int $fontStyle, int $firstGlyph, int $numGlyphs, int $handleMissingGlyphs, int $pathParameterTemplate, float $emScale) {
  static $proc;
  return ($proc ??= GL::getProcAddress('pathGlyphRangeNV'))($firstPathName, $fontTarget, $fontName, $fontStyle, $firstGlyph, $numGlyphs, $handleMissingGlyphs, $pathParameterTemplate, $emScale);
}

function glPathGlyphsNV(int $firstPathName, int $fontTarget, $fontName, int $fontStyle, int $numGlyphs, int $type, $charcodes, int $handleMissingGlyphs, int $pathParameterTemplate, float $emScale) {
  static $proc;
  return ($proc ??= GL::getProcAddress('pathGlyphsNV'))($firstPathName, $fontTarget, $fontName, $fontStyle, $numGlyphs, $type, $charcodes, $handleMissingGlyphs, $pathParameterTemplate, $emScale);
}

function glPathMemoryGlyphIndexArrayNV(int $firstPathName, int $fontTarget, int $fontSize, $fontData, int $faceIndex, int $firstGlyphIndex, int $numGlyphs, int $pathParameterTemplate, float $emScale) {
  static $proc;
  return ($proc ??= GL::getProcAddress('pathMemoryGlyphIndexArrayNV'))($firstPathName, $fontTarget, $fontSize, $fontData, $faceIndex, $firstGlyphIndex, $numGlyphs, $pathParameterTemplate, $emScale);
}

function glPathParameterfNV(int $path, int $pname, float $value) {
  static $proc;
  return ($proc ??= GL::getProcAddress('pathParameterfNV'))($path, $pname, $value);
}

function glPathParameterfvNV(int $path, int $pname, $value) {
  static $proc;
  return ($proc ??= GL::getProcAddress('pathParameterfvNV'))($path, $pname, $value);
}

function glPathParameteriNV(int $path, int $pname, int $value) {
  static $proc;
  return ($proc ??= GL::getProcAddress('pathParameteriNV'))($path, $pname, $value);
}

function glPathParameterivNV(int $path, int $pname, $value) {
  static $proc;
  return ($proc ??= GL::getProcAddress('pathParameterivNV'))($path, $pname, $value);
}

function glPathStencilDepthOffsetNV(float $factor, float $units) {
  static $proc;
  return ($proc ??= GL::getProcAddress('pathStencilDepthOffsetNV'))($factor, $units);
}

function glPathStencilFuncNV(int $func, int $ref, int $mask) {
  static $proc;
  return ($proc ??= GL::getProcAddress('pathStencilFuncNV'))($func, $ref, $mask);
}

function glPathStringNV(int $path, int $format, int $length, $pathString) {
  static $proc;
  return ($proc ??= GL::getProcAddress('pathStringNV'))($path, $format, $length, $pathString);
}

function glPathSubCommandsNV(int $path, int $commandStart, int $commandsToDelete, int $numCommands, $commands, int $numCoords, int $coordType, $coords) {
  static $proc;
  return ($proc ??= GL::getProcAddress('pathSubCommandsNV'))($path, $commandStart, $commandsToDelete, $numCommands, $commands, $numCoords, $coordType, $coords);
}

function glPathSubCoordsNV(int $path, int $coordStart, int $numCoords, int $coordType, $coords) {
  static $proc;
  return ($proc ??= GL::getProcAddress('pathSubCoordsNV'))($path, $coordStart, $numCoords, $coordType, $coords);
}

function glPathTexGenNV(int $texCoordSet, int $genMode, int $components, $coeffs) {
  static $proc;
  return ($proc ??= GL::getProcAddress('pathTexGenNV'))($texCoordSet, $genMode, $components, $coeffs);
}

function glPauseTransformFeedback() {
  static $proc;
  return ($proc ??= GL::getProcAddress('pauseTransformFeedback'))();
}

function glPauseTransformFeedbackNV() {
  static $proc;
  return ($proc ??= GL::getProcAddress('pauseTransformFeedbackNV'))();
}

function glPixelDataRangeNV(int $target, int $length, $pointer) {
  static $proc;
  return ($proc ??= GL::getProcAddress('pixelDataRangeNV'))($target, $length, $pointer);
}

function glPixelMapfv(int $map, int $mapsize, $values) {
  static $proc;
  return ($proc ??= GL::getProcAddress('pixelMapfv'))($map, $mapsize, $values);
}

function glPixelMapuiv(int $map, int $mapsize, $values) {
  static $proc;
  return ($proc ??= GL::getProcAddress('pixelMapuiv'))($map, $mapsize, $values);
}

function glPixelMapusv(int $map, int $mapsize, $values) {
  static $proc;
  return ($proc ??= GL::getProcAddress('pixelMapusv'))($map, $mapsize, $values);
}

function glPixelMapx(int $map, int $size, $values) {
  static $proc;
  return ($proc ??= GL::getProcAddress('pixelMapx'))($map, $size, $values);
}

function glPixelStoref(int $pname, float $param) {
  static $proc;
  return ($proc ??= GL::getProcAddress('pixelStoref'))($pname, $param);
}

function glPixelStorei(int $pname, int $param) {
  static $proc;
  return ($proc ??= GL::getProcAddress('pixelStorei'))($pname, $param);
}

function glPixelStorex(int $pname, int $param) {
  static $proc;
  return ($proc ??= GL::getProcAddress('pixelStorex'))($pname, $param);
}

function glPixelTexGenParameterfSGIS(int $pname, float $param) {
  static $proc;
  return ($proc ??= GL::getProcAddress('pixelTexGenParameterfSGIS'))($pname, $param);
}

function glPixelTexGenParameterfvSGIS(int $pname, $params) {
  static $proc;
  return ($proc ??= GL::getProcAddress('pixelTexGenParameterfvSGIS'))($pname, $params);
}

function glPixelTexGenParameteriSGIS(int $pname, int $param) {
  static $proc;
  return ($proc ??= GL::getProcAddress('pixelTexGenParameteriSGIS'))($pname, $param);
}

function glPixelTexGenParameterivSGIS(int $pname, $params) {
  static $proc;
  return ($proc ??= GL::getProcAddress('pixelTexGenParameterivSGIS'))($pname, $params);
}

function glPixelTexGenSGIX(int $mode) {
  static $proc;
  return ($proc ??= GL::getProcAddress('pixelTexGenSGIX'))($mode);
}

function glPixelTransferf(int $pname, float $param) {
  static $proc;
  return ($proc ??= GL::getProcAddress('pixelTransferf'))($pname, $param);
}

function glPixelTransferi(int $pname, int $param) {
  static $proc;
  return ($proc ??= GL::getProcAddress('pixelTransferi'))($pname, $param);
}

function glPixelTransferxOES(int $pname, int $param) {
  static $proc;
  return ($proc ??= GL::getProcAddress('pixelTransferxOES'))($pname, $param);
}

function glPixelTransformParameterfEXT(int $target, int $pname, float $param) {
  static $proc;
  return ($proc ??= GL::getProcAddress('pixelTransformParameterfEXT'))($target, $pname, $param);
}

function glPixelTransformParameterfvEXT(int $target, int $pname, $params) {
  static $proc;
  return ($proc ??= GL::getProcAddress('pixelTransformParameterfvEXT'))($target, $pname, $params);
}

function glPixelTransformParameteriEXT(int $target, int $pname, int $param) {
  static $proc;
  return ($proc ??= GL::getProcAddress('pixelTransformParameteriEXT'))($target, $pname, $param);
}

function glPixelTransformParameterivEXT(int $target, int $pname, $params) {
  static $proc;
  return ($proc ??= GL::getProcAddress('pixelTransformParameterivEXT'))($target, $pname, $params);
}

function glPixelZoom(float $xfactor, float $yfactor) {
  static $proc;
  return ($proc ??= GL::getProcAddress('pixelZoom'))($xfactor, $yfactor);
}

function glPixelZoomxOES(int $xfactor, int $yfactor) {
  static $proc;
  return ($proc ??= GL::getProcAddress('pixelZoomxOES'))($xfactor, $yfactor);
}

function glPointAlongPathNV(int $path, int $startSegment, int $numSegments, float $distance, $x, $y, $tangentX, $tangentY) {
  static $proc;
  return ($proc ??= GL::getProcAddress('pointAlongPathNV'))($path, $startSegment, $numSegments, $distance, $x, $y, $tangentX, $tangentY);
}

function glPointParameterf(int $pname, float $param) {
  static $proc;
  return ($proc ??= GL::getProcAddress('pointParameterf'))($pname, $param);
}

function glPointParameterfARB(int $pname, float $param) {
  static $proc;
  return ($proc ??= GL::getProcAddress('pointParameterfARB'))($pname, $param);
}

function glPointParameterfEXT(int $pname, float $param) {
  static $proc;
  return ($proc ??= GL::getProcAddress('pointParameterfEXT'))($pname, $param);
}

function glPointParameterfSGIS(int $pname, float $param) {
  static $proc;
  return ($proc ??= GL::getProcAddress('pointParameterfSGIS'))($pname, $param);
}

function glPointParameterfv(int $pname, $params) {
  static $proc;
  return ($proc ??= GL::getProcAddress('pointParameterfv'))($pname, $params);
}

function glPointParameterfvARB(int $pname, $params) {
  static $proc;
  return ($proc ??= GL::getProcAddress('pointParameterfvARB'))($pname, $params);
}

function glPointParameterfvEXT(int $pname, $params) {
  static $proc;
  return ($proc ??= GL::getProcAddress('pointParameterfvEXT'))($pname, $params);
}

function glPointParameterfvSGIS(int $pname, $params) {
  static $proc;
  return ($proc ??= GL::getProcAddress('pointParameterfvSGIS'))($pname, $params);
}

function glPointParameteri(int $pname, int $param) {
  static $proc;
  return ($proc ??= GL::getProcAddress('pointParameteri'))($pname, $param);
}

function glPointParameteriNV(int $pname, int $param) {
  static $proc;
  return ($proc ??= GL::getProcAddress('pointParameteriNV'))($pname, $param);
}

function glPointParameteriv(int $pname, $params) {
  static $proc;
  return ($proc ??= GL::getProcAddress('pointParameteriv'))($pname, $params);
}

function glPointParameterivNV(int $pname, $params) {
  static $proc;
  return ($proc ??= GL::getProcAddress('pointParameterivNV'))($pname, $params);
}

function glPointParameterx(int $pname, int $param) {
  static $proc;
  return ($proc ??= GL::getProcAddress('pointParameterx'))($pname, $param);
}

function glPointParameterxOES(int $pname, int $param) {
  static $proc;
  return ($proc ??= GL::getProcAddress('pointParameterxOES'))($pname, $param);
}

function glPointParameterxv(int $pname, $params) {
  static $proc;
  return ($proc ??= GL::getProcAddress('pointParameterxv'))($pname, $params);
}

function glPointParameterxvOES(int $pname, $params) {
  static $proc;
  return ($proc ??= GL::getProcAddress('pointParameterxvOES'))($pname, $params);
}

function glPointSize(float $size) {
  static $proc;
  return ($proc ??= GL::getProcAddress('pointSize'))($size);
}

function glPointSizePointerOES(int $type, int $stride, $pointer) {
  static $proc;
  return ($proc ??= GL::getProcAddress('pointSizePointerOES'))($type, $stride, $pointer);
}

function glPointSizex(int $size) {
  static $proc;
  return ($proc ??= GL::getProcAddress('pointSizex'))($size);
}

function glPointSizexOES(int $size) {
  static $proc;
  return ($proc ??= GL::getProcAddress('pointSizexOES'))($size);
}

function glPollAsyncSGIX($markerp) {
  static $proc;
  return ($proc ??= GL::getProcAddress('pollAsyncSGIX'))($markerp);
}

function glPollInstrumentsSGIX($marker_p) {
  static $proc;
  return ($proc ??= GL::getProcAddress('pollInstrumentsSGIX'))($marker_p);
}

function glPolygonMode(int $face, int $mode) {
  static $proc;
  return ($proc ??= GL::getProcAddress('polygonMode'))($face, $mode);
}

function glPolygonModeNV(int $face, int $mode) {
  static $proc;
  return ($proc ??= GL::getProcAddress('polygonModeNV'))($face, $mode);
}

function glPolygonOffset(float $factor, float $units) {
  static $proc;
  return ($proc ??= GL::getProcAddress('polygonOffset'))($factor, $units);
}

function glPolygonOffsetClampEXT(float $factor, float $units, float $clamp) {
  static $proc;
  return ($proc ??= GL::getProcAddress('polygonOffsetClampEXT'))($factor, $units, $clamp);
}

function glPolygonOffsetEXT(float $factor, float $bias) {
  static $proc;
  return ($proc ??= GL::getProcAddress('polygonOffsetEXT'))($factor, $bias);
}

function glPolygonOffsetx(int $factor, int $units) {
  static $proc;
  return ($proc ??= GL::getProcAddress('polygonOffsetx'))($factor, $units);
}

function glPolygonOffsetxOES(int $factor, int $units) {
  static $proc;
  return ($proc ??= GL::getProcAddress('polygonOffsetxOES'))($factor, $units);
}

function glPolygonStipple($mask) {
  static $proc;
  return ($proc ??= GL::getProcAddress('polygonStipple'))($mask);
}

function glPopAttrib() {
  static $proc;
  return ($proc ??= GL::getProcAddress('popAttrib'))();
}

function glPopClientAttrib() {
  static $proc;
  return ($proc ??= GL::getProcAddress('popClientAttrib'))();
}

function glPopDebugGroup() {
  static $proc;
  return ($proc ??= GL::getProcAddress('popDebugGroup'))();
}

function glPopDebugGroupKHR() {
  static $proc;
  return ($proc ??= GL::getProcAddress('popDebugGroupKHR'))();
}

function glPopGroupMarkerEXT() {
  static $proc;
  return ($proc ??= GL::getProcAddress('popGroupMarkerEXT'))();
}

function glPopMatrix() {
  static $proc;
  return ($proc ??= GL::getProcAddress('popMatrix'))();
}

function glPopName() {
  static $proc;
  return ($proc ??= GL::getProcAddress('popName'))();
}

function glPresentFrameDualFillNV(int $video_slot, int $minPresentTime, int $beginPresentTimeId, int $presentDurationId, int $type, int $target0, int $fill0, int $target1, int $fill1, int $target2, int $fill2, int $target3, int $fill3) {
  static $proc;
  return ($proc ??= GL::getProcAddress('presentFrameDualFillNV'))($video_slot, $minPresentTime, $beginPresentTimeId, $presentDurationId, $type, $target0, $fill0, $target1, $fill1, $target2, $fill2, $target3, $fill3);
}

function glPresentFrameKeyedNV(int $video_slot, int $minPresentTime, int $beginPresentTimeId, int $presentDurationId, int $type, int $target0, int $fill0, int $key0, int $target1, int $fill1, int $key1) {
  static $proc;
  return ($proc ??= GL::getProcAddress('presentFrameKeyedNV'))($video_slot, $minPresentTime, $beginPresentTimeId, $presentDurationId, $type, $target0, $fill0, $key0, $target1, $fill1, $key1);
}

function glPrimitiveBoundingBox(float $minX, float $minY, float $minZ, float $minW, float $maxX, float $maxY, float $maxZ, float $maxW) {
  static $proc;
  return ($proc ??= GL::getProcAddress('primitiveBoundingBox'))($minX, $minY, $minZ, $minW, $maxX, $maxY, $maxZ, $maxW);
}

function glPrimitiveBoundingBoxARB(float $minX, float $minY, float $minZ, float $minW, float $maxX, float $maxY, float $maxZ, float $maxW) {
  static $proc;
  return ($proc ??= GL::getProcAddress('primitiveBoundingBoxARB'))($minX, $minY, $minZ, $minW, $maxX, $maxY, $maxZ, $maxW);
}

function glPrimitiveBoundingBoxEXT(float $minX, float $minY, float $minZ, float $minW, float $maxX, float $maxY, float $maxZ, float $maxW) {
  static $proc;
  return ($proc ??= GL::getProcAddress('primitiveBoundingBoxEXT'))($minX, $minY, $minZ, $minW, $maxX, $maxY, $maxZ, $maxW);
}

function glPrimitiveBoundingBoxOES(float $minX, float $minY, float $minZ, float $minW, float $maxX, float $maxY, float $maxZ, float $maxW) {
  static $proc;
  return ($proc ??= GL::getProcAddress('primitiveBoundingBoxOES'))($minX, $minY, $minZ, $minW, $maxX, $maxY, $maxZ, $maxW);
}

function glPrimitiveRestartIndex(int $index) {
  static $proc;
  return ($proc ??= GL::getProcAddress('primitiveRestartIndex'))($index);
}

function glPrimitiveRestartIndexNV(int $index) {
  static $proc;
  return ($proc ??= GL::getProcAddress('primitiveRestartIndexNV'))($index);
}

function glPrimitiveRestartNV() {
  static $proc;
  return ($proc ??= GL::getProcAddress('primitiveRestartNV'))();
}

function glPrioritizeTextures(int $n, $textures, $priorities) {
  static $proc;
  return ($proc ??= GL::getProcAddress('prioritizeTextures'))($n, $textures, $priorities);
}

function glPrioritizeTexturesEXT(int $n, $textures, $priorities) {
  static $proc;
  return ($proc ??= GL::getProcAddress('prioritizeTexturesEXT'))($n, $textures, $priorities);
}

function glPrioritizeTexturesxOES(int $n, $textures, $priorities) {
  static $proc;
  return ($proc ??= GL::getProcAddress('prioritizeTexturesxOES'))($n, $textures, $priorities);
}

function glProgramBinary(int $program, int $binaryFormat, $binary, int $length) {
  static $proc;
  return ($proc ??= GL::getProcAddress('programBinary'))($program, $binaryFormat, $binary, $length);
}

function glProgramBinaryOES(int $program, int $binaryFormat, $binary, int $length) {
  static $proc;
  return ($proc ??= GL::getProcAddress('programBinaryOES'))($program, $binaryFormat, $binary, $length);
}

function glProgramBufferParametersIivNV(int $target, int $bindingIndex, int $wordIndex, int $count, $params) {
  static $proc;
  return ($proc ??= GL::getProcAddress('programBufferParametersIivNV'))($target, $bindingIndex, $wordIndex, $count, $params);
}

function glProgramBufferParametersIuivNV(int $target, int $bindingIndex, int $wordIndex, int $count, $params) {
  static $proc;
  return ($proc ??= GL::getProcAddress('programBufferParametersIuivNV'))($target, $bindingIndex, $wordIndex, $count, $params);
}

function glProgramBufferParametersfvNV(int $target, int $bindingIndex, int $wordIndex, int $count, $params) {
  static $proc;
  return ($proc ??= GL::getProcAddress('programBufferParametersfvNV'))($target, $bindingIndex, $wordIndex, $count, $params);
}

function glProgramEnvParameter4dARB(int $target, int $index, float $x, float $y, float $z, float $w) {
  static $proc;
  return ($proc ??= GL::getProcAddress('programEnvParameter4dARB'))($target, $index, $x, $y, $z, $w);
}

function glProgramEnvParameter4dvARB(int $target, int $index, $params) {
  static $proc;
  return ($proc ??= GL::getProcAddress('programEnvParameter4dvARB'))($target, $index, $params);
}

function glProgramEnvParameter4fARB(int $target, int $index, float $x, float $y, float $z, float $w) {
  static $proc;
  return ($proc ??= GL::getProcAddress('programEnvParameter4fARB'))($target, $index, $x, $y, $z, $w);
}

function glProgramEnvParameter4fvARB(int $target, int $index, $params) {
  static $proc;
  return ($proc ??= GL::getProcAddress('programEnvParameter4fvARB'))($target, $index, $params);
}

function glProgramEnvParameterI4iNV(int $target, int $index, int $x, int $y, int $z, int $w) {
  static $proc;
  return ($proc ??= GL::getProcAddress('programEnvParameterI4iNV'))($target, $index, $x, $y, $z, $w);
}

function glProgramEnvParameterI4ivNV(int $target, int $index, $params) {
  static $proc;
  return ($proc ??= GL::getProcAddress('programEnvParameterI4ivNV'))($target, $index, $params);
}

function glProgramEnvParameterI4uiNV(int $target, int $index, int $x, int $y, int $z, int $w) {
  static $proc;
  return ($proc ??= GL::getProcAddress('programEnvParameterI4uiNV'))($target, $index, $x, $y, $z, $w);
}

function glProgramEnvParameterI4uivNV(int $target, int $index, $params) {
  static $proc;
  return ($proc ??= GL::getProcAddress('programEnvParameterI4uivNV'))($target, $index, $params);
}

function glProgramEnvParameters4fvEXT(int $target, int $index, int $count, $params) {
  static $proc;
  return ($proc ??= GL::getProcAddress('programEnvParameters4fvEXT'))($target, $index, $count, $params);
}

function glProgramEnvParametersI4ivNV(int $target, int $index, int $count, $params) {
  static $proc;
  return ($proc ??= GL::getProcAddress('programEnvParametersI4ivNV'))($target, $index, $count, $params);
}

function glProgramEnvParametersI4uivNV(int $target, int $index, int $count, $params) {
  static $proc;
  return ($proc ??= GL::getProcAddress('programEnvParametersI4uivNV'))($target, $index, $count, $params);
}

function glProgramLocalParameter4dARB(int $target, int $index, float $x, float $y, float $z, float $w) {
  static $proc;
  return ($proc ??= GL::getProcAddress('programLocalParameter4dARB'))($target, $index, $x, $y, $z, $w);
}

function glProgramLocalParameter4dvARB(int $target, int $index, $params) {
  static $proc;
  return ($proc ??= GL::getProcAddress('programLocalParameter4dvARB'))($target, $index, $params);
}

function glProgramLocalParameter4fARB(int $target, int $index, float $x, float $y, float $z, float $w) {
  static $proc;
  return ($proc ??= GL::getProcAddress('programLocalParameter4fARB'))($target, $index, $x, $y, $z, $w);
}

function glProgramLocalParameter4fvARB(int $target, int $index, $params) {
  static $proc;
  return ($proc ??= GL::getProcAddress('programLocalParameter4fvARB'))($target, $index, $params);
}

function glProgramLocalParameterI4iNV(int $target, int $index, int $x, int $y, int $z, int $w) {
  static $proc;
  return ($proc ??= GL::getProcAddress('programLocalParameterI4iNV'))($target, $index, $x, $y, $z, $w);
}

function glProgramLocalParameterI4ivNV(int $target, int $index, $params) {
  static $proc;
  return ($proc ??= GL::getProcAddress('programLocalParameterI4ivNV'))($target, $index, $params);
}

function glProgramLocalParameterI4uiNV(int $target, int $index, int $x, int $y, int $z, int $w) {
  static $proc;
  return ($proc ??= GL::getProcAddress('programLocalParameterI4uiNV'))($target, $index, $x, $y, $z, $w);
}

function glProgramLocalParameterI4uivNV(int $target, int $index, $params) {
  static $proc;
  return ($proc ??= GL::getProcAddress('programLocalParameterI4uivNV'))($target, $index, $params);
}

function glProgramLocalParameters4fvEXT(int $target, int $index, int $count, $params) {
  static $proc;
  return ($proc ??= GL::getProcAddress('programLocalParameters4fvEXT'))($target, $index, $count, $params);
}

function glProgramLocalParametersI4ivNV(int $target, int $index, int $count, $params) {
  static $proc;
  return ($proc ??= GL::getProcAddress('programLocalParametersI4ivNV'))($target, $index, $count, $params);
}

function glProgramLocalParametersI4uivNV(int $target, int $index, int $count, $params) {
  static $proc;
  return ($proc ??= GL::getProcAddress('programLocalParametersI4uivNV'))($target, $index, $count, $params);
}

function glProgramNamedParameter4dNV(int $id, int $len, $name, float $x, float $y, float $z, float $w) {
  static $proc;
  return ($proc ??= GL::getProcAddress('programNamedParameter4dNV'))($id, $len, $name, $x, $y, $z, $w);
}

function glProgramNamedParameter4dvNV(int $id, int $len, $name, $v) {
  static $proc;
  return ($proc ??= GL::getProcAddress('programNamedParameter4dvNV'))($id, $len, $name, $v);
}

function glProgramNamedParameter4fNV(int $id, int $len, $name, float $x, float $y, float $z, float $w) {
  static $proc;
  return ($proc ??= GL::getProcAddress('programNamedParameter4fNV'))($id, $len, $name, $x, $y, $z, $w);
}

function glProgramNamedParameter4fvNV(int $id, int $len, $name, $v) {
  static $proc;
  return ($proc ??= GL::getProcAddress('programNamedParameter4fvNV'))($id, $len, $name, $v);
}

function glProgramParameter4dNV(int $target, int $index, float $x, float $y, float $z, float $w) {
  static $proc;
  return ($proc ??= GL::getProcAddress('programParameter4dNV'))($target, $index, $x, $y, $z, $w);
}

function glProgramParameter4dvNV(int $target, int $index, $v) {
  static $proc;
  return ($proc ??= GL::getProcAddress('programParameter4dvNV'))($target, $index, $v);
}

function glProgramParameter4fNV(int $target, int $index, float $x, float $y, float $z, float $w) {
  static $proc;
  return ($proc ??= GL::getProcAddress('programParameter4fNV'))($target, $index, $x, $y, $z, $w);
}

function glProgramParameter4fvNV(int $target, int $index, $v) {
  static $proc;
  return ($proc ??= GL::getProcAddress('programParameter4fvNV'))($target, $index, $v);
}

function glProgramParameteri(int $program, int $pname, int $value) {
  static $proc;
  return ($proc ??= GL::getProcAddress('programParameteri'))($program, $pname, $value);
}

function glProgramParameteriARB(int $program, int $pname, int $value) {
  static $proc;
  return ($proc ??= GL::getProcAddress('programParameteriARB'))($program, $pname, $value);
}

function glProgramParameteriEXT(int $program, int $pname, int $value) {
  static $proc;
  return ($proc ??= GL::getProcAddress('programParameteriEXT'))($program, $pname, $value);
}

function glProgramParameters4dvNV(int $target, int $index, int $count, $v) {
  static $proc;
  return ($proc ??= GL::getProcAddress('programParameters4dvNV'))($target, $index, $count, $v);
}

function glProgramParameters4fvNV(int $target, int $index, int $count, $v) {
  static $proc;
  return ($proc ??= GL::getProcAddress('programParameters4fvNV'))($target, $index, $count, $v);
}

function glProgramPathFragmentInputGenNV(int $program, int $location, int $genMode, int $components, $coeffs) {
  static $proc;
  return ($proc ??= GL::getProcAddress('programPathFragmentInputGenNV'))($program, $location, $genMode, $components, $coeffs);
}

function glProgramStringARB(int $target, int $format, int $len, $string) {
  static $proc;
  return ($proc ??= GL::getProcAddress('programStringARB'))($target, $format, $len, $string);
}

function glProgramSubroutineParametersuivNV(int $target, int $count, $params) {
  static $proc;
  return ($proc ??= GL::getProcAddress('programSubroutineParametersuivNV'))($target, $count, $params);
}

function glProgramUniform1d(int $program, int $location, float $v0) {
  static $proc;
  return ($proc ??= GL::getProcAddress('programUniform1d'))($program, $location, $v0);
}

function glProgramUniform1dEXT(int $program, int $location, float $x) {
  static $proc;
  return ($proc ??= GL::getProcAddress('programUniform1dEXT'))($program, $location, $x);
}

function glProgramUniform1dv(int $program, int $location, int $count, $value) {
  static $proc;
  return ($proc ??= GL::getProcAddress('programUniform1dv'))($program, $location, $count, $value);
}

function glProgramUniform1dvEXT(int $program, int $location, int $count, $value) {
  static $proc;
  return ($proc ??= GL::getProcAddress('programUniform1dvEXT'))($program, $location, $count, $value);
}

function glProgramUniform1f(int $program, int $location, float $v0) {
  static $proc;
  return ($proc ??= GL::getProcAddress('programUniform1f'))($program, $location, $v0);
}

function glProgramUniform1fEXT(int $program, int $location, float $v0) {
  static $proc;
  return ($proc ??= GL::getProcAddress('programUniform1fEXT'))($program, $location, $v0);
}

function glProgramUniform1fv(int $program, int $location, int $count, $value) {
  static $proc;
  return ($proc ??= GL::getProcAddress('programUniform1fv'))($program, $location, $count, $value);
}

function glProgramUniform1fvEXT(int $program, int $location, int $count, $value) {
  static $proc;
  return ($proc ??= GL::getProcAddress('programUniform1fvEXT'))($program, $location, $count, $value);
}

function glProgramUniform1i(int $program, int $location, int $v0) {
  static $proc;
  return ($proc ??= GL::getProcAddress('programUniform1i'))($program, $location, $v0);
}

function glProgramUniform1i64ARB(int $program, int $location, int $x) {
  static $proc;
  return ($proc ??= GL::getProcAddress('programUniform1i64ARB'))($program, $location, $x);
}

function glProgramUniform1i64NV(int $program, int $location, int $x) {
  static $proc;
  return ($proc ??= GL::getProcAddress('programUniform1i64NV'))($program, $location, $x);
}

function glProgramUniform1i64vARB(int $program, int $location, int $count, $value) {
  static $proc;
  return ($proc ??= GL::getProcAddress('programUniform1i64vARB'))($program, $location, $count, $value);
}

function glProgramUniform1i64vNV(int $program, int $location, int $count, $value) {
  static $proc;
  return ($proc ??= GL::getProcAddress('programUniform1i64vNV'))($program, $location, $count, $value);
}

function glProgramUniform1iEXT(int $program, int $location, int $v0) {
  static $proc;
  return ($proc ??= GL::getProcAddress('programUniform1iEXT'))($program, $location, $v0);
}

function glProgramUniform1iv(int $program, int $location, int $count, $value) {
  static $proc;
  return ($proc ??= GL::getProcAddress('programUniform1iv'))($program, $location, $count, $value);
}

function glProgramUniform1ivEXT(int $program, int $location, int $count, $value) {
  static $proc;
  return ($proc ??= GL::getProcAddress('programUniform1ivEXT'))($program, $location, $count, $value);
}

function glProgramUniform1ui(int $program, int $location, int $v0) {
  static $proc;
  return ($proc ??= GL::getProcAddress('programUniform1ui'))($program, $location, $v0);
}

function glProgramUniform1ui64ARB(int $program, int $location, int $x) {
  static $proc;
  return ($proc ??= GL::getProcAddress('programUniform1ui64ARB'))($program, $location, $x);
}

function glProgramUniform1ui64NV(int $program, int $location, int $x) {
  static $proc;
  return ($proc ??= GL::getProcAddress('programUniform1ui64NV'))($program, $location, $x);
}

function glProgramUniform1ui64vARB(int $program, int $location, int $count, $value) {
  static $proc;
  return ($proc ??= GL::getProcAddress('programUniform1ui64vARB'))($program, $location, $count, $value);
}

function glProgramUniform1ui64vNV(int $program, int $location, int $count, $value) {
  static $proc;
  return ($proc ??= GL::getProcAddress('programUniform1ui64vNV'))($program, $location, $count, $value);
}

function glProgramUniform1uiEXT(int $program, int $location, int $v0) {
  static $proc;
  return ($proc ??= GL::getProcAddress('programUniform1uiEXT'))($program, $location, $v0);
}

function glProgramUniform1uiv(int $program, int $location, int $count, $value) {
  static $proc;
  return ($proc ??= GL::getProcAddress('programUniform1uiv'))($program, $location, $count, $value);
}

function glProgramUniform1uivEXT(int $program, int $location, int $count, $value) {
  static $proc;
  return ($proc ??= GL::getProcAddress('programUniform1uivEXT'))($program, $location, $count, $value);
}

function glProgramUniform2d(int $program, int $location, float $v0, float $v1) {
  static $proc;
  return ($proc ??= GL::getProcAddress('programUniform2d'))($program, $location, $v0, $v1);
}

function glProgramUniform2dEXT(int $program, int $location, float $x, float $y) {
  static $proc;
  return ($proc ??= GL::getProcAddress('programUniform2dEXT'))($program, $location, $x, $y);
}

function glProgramUniform2dv(int $program, int $location, int $count, $value) {
  static $proc;
  return ($proc ??= GL::getProcAddress('programUniform2dv'))($program, $location, $count, $value);
}

function glProgramUniform2dvEXT(int $program, int $location, int $count, $value) {
  static $proc;
  return ($proc ??= GL::getProcAddress('programUniform2dvEXT'))($program, $location, $count, $value);
}

function glProgramUniform2f(int $program, int $location, float $v0, float $v1) {
  static $proc;
  return ($proc ??= GL::getProcAddress('programUniform2f'))($program, $location, $v0, $v1);
}

function glProgramUniform2fEXT(int $program, int $location, float $v0, float $v1) {
  static $proc;
  return ($proc ??= GL::getProcAddress('programUniform2fEXT'))($program, $location, $v0, $v1);
}

function glProgramUniform2fv(int $program, int $location, int $count, $value) {
  static $proc;
  return ($proc ??= GL::getProcAddress('programUniform2fv'))($program, $location, $count, $value);
}

function glProgramUniform2fvEXT(int $program, int $location, int $count, $value) {
  static $proc;
  return ($proc ??= GL::getProcAddress('programUniform2fvEXT'))($program, $location, $count, $value);
}

function glProgramUniform2i(int $program, int $location, int $v0, int $v1) {
  static $proc;
  return ($proc ??= GL::getProcAddress('programUniform2i'))($program, $location, $v0, $v1);
}

function glProgramUniform2i64ARB(int $program, int $location, int $x, int $y) {
  static $proc;
  return ($proc ??= GL::getProcAddress('programUniform2i64ARB'))($program, $location, $x, $y);
}

function glProgramUniform2i64NV(int $program, int $location, int $x, int $y) {
  static $proc;
  return ($proc ??= GL::getProcAddress('programUniform2i64NV'))($program, $location, $x, $y);
}

function glProgramUniform2i64vARB(int $program, int $location, int $count, $value) {
  static $proc;
  return ($proc ??= GL::getProcAddress('programUniform2i64vARB'))($program, $location, $count, $value);
}

function glProgramUniform2i64vNV(int $program, int $location, int $count, $value) {
  static $proc;
  return ($proc ??= GL::getProcAddress('programUniform2i64vNV'))($program, $location, $count, $value);
}

function glProgramUniform2iEXT(int $program, int $location, int $v0, int $v1) {
  static $proc;
  return ($proc ??= GL::getProcAddress('programUniform2iEXT'))($program, $location, $v0, $v1);
}

function glProgramUniform2iv(int $program, int $location, int $count, $value) {
  static $proc;
  return ($proc ??= GL::getProcAddress('programUniform2iv'))($program, $location, $count, $value);
}

function glProgramUniform2ivEXT(int $program, int $location, int $count, $value) {
  static $proc;
  return ($proc ??= GL::getProcAddress('programUniform2ivEXT'))($program, $location, $count, $value);
}

function glProgramUniform2ui(int $program, int $location, int $v0, int $v1) {
  static $proc;
  return ($proc ??= GL::getProcAddress('programUniform2ui'))($program, $location, $v0, $v1);
}

function glProgramUniform2ui64ARB(int $program, int $location, int $x, int $y) {
  static $proc;
  return ($proc ??= GL::getProcAddress('programUniform2ui64ARB'))($program, $location, $x, $y);
}

function glProgramUniform2ui64NV(int $program, int $location, int $x, int $y) {
  static $proc;
  return ($proc ??= GL::getProcAddress('programUniform2ui64NV'))($program, $location, $x, $y);
}

function glProgramUniform2ui64vARB(int $program, int $location, int $count, $value) {
  static $proc;
  return ($proc ??= GL::getProcAddress('programUniform2ui64vARB'))($program, $location, $count, $value);
}

function glProgramUniform2ui64vNV(int $program, int $location, int $count, $value) {
  static $proc;
  return ($proc ??= GL::getProcAddress('programUniform2ui64vNV'))($program, $location, $count, $value);
}

function glProgramUniform2uiEXT(int $program, int $location, int $v0, int $v1) {
  static $proc;
  return ($proc ??= GL::getProcAddress('programUniform2uiEXT'))($program, $location, $v0, $v1);
}

function glProgramUniform2uiv(int $program, int $location, int $count, $value) {
  static $proc;
  return ($proc ??= GL::getProcAddress('programUniform2uiv'))($program, $location, $count, $value);
}

function glProgramUniform2uivEXT(int $program, int $location, int $count, $value) {
  static $proc;
  return ($proc ??= GL::getProcAddress('programUniform2uivEXT'))($program, $location, $count, $value);
}

function glProgramUniform3d(int $program, int $location, float $v0, float $v1, float $v2) {
  static $proc;
  return ($proc ??= GL::getProcAddress('programUniform3d'))($program, $location, $v0, $v1, $v2);
}

function glProgramUniform3dEXT(int $program, int $location, float $x, float $y, float $z) {
  static $proc;
  return ($proc ??= GL::getProcAddress('programUniform3dEXT'))($program, $location, $x, $y, $z);
}

function glProgramUniform3dv(int $program, int $location, int $count, $value) {
  static $proc;
  return ($proc ??= GL::getProcAddress('programUniform3dv'))($program, $location, $count, $value);
}

function glProgramUniform3dvEXT(int $program, int $location, int $count, $value) {
  static $proc;
  return ($proc ??= GL::getProcAddress('programUniform3dvEXT'))($program, $location, $count, $value);
}

function glProgramUniform3f(int $program, int $location, float $v0, float $v1, float $v2) {
  static $proc;
  return ($proc ??= GL::getProcAddress('programUniform3f'))($program, $location, $v0, $v1, $v2);
}

function glProgramUniform3fEXT(int $program, int $location, float $v0, float $v1, float $v2) {
  static $proc;
  return ($proc ??= GL::getProcAddress('programUniform3fEXT'))($program, $location, $v0, $v1, $v2);
}

function glProgramUniform3fv(int $program, int $location, int $count, $value) {
  static $proc;
  return ($proc ??= GL::getProcAddress('programUniform3fv'))($program, $location, $count, $value);
}

function glProgramUniform3fvEXT(int $program, int $location, int $count, $value) {
  static $proc;
  return ($proc ??= GL::getProcAddress('programUniform3fvEXT'))($program, $location, $count, $value);
}

function glProgramUniform3i(int $program, int $location, int $v0, int $v1, int $v2) {
  static $proc;
  return ($proc ??= GL::getProcAddress('programUniform3i'))($program, $location, $v0, $v1, $v2);
}

function glProgramUniform3i64ARB(int $program, int $location, int $x, int $y, int $z) {
  static $proc;
  return ($proc ??= GL::getProcAddress('programUniform3i64ARB'))($program, $location, $x, $y, $z);
}

function glProgramUniform3i64NV(int $program, int $location, int $x, int $y, int $z) {
  static $proc;
  return ($proc ??= GL::getProcAddress('programUniform3i64NV'))($program, $location, $x, $y, $z);
}

function glProgramUniform3i64vARB(int $program, int $location, int $count, $value) {
  static $proc;
  return ($proc ??= GL::getProcAddress('programUniform3i64vARB'))($program, $location, $count, $value);
}

function glProgramUniform3i64vNV(int $program, int $location, int $count, $value) {
  static $proc;
  return ($proc ??= GL::getProcAddress('programUniform3i64vNV'))($program, $location, $count, $value);
}

function glProgramUniform3iEXT(int $program, int $location, int $v0, int $v1, int $v2) {
  static $proc;
  return ($proc ??= GL::getProcAddress('programUniform3iEXT'))($program, $location, $v0, $v1, $v2);
}

function glProgramUniform3iv(int $program, int $location, int $count, $value) {
  static $proc;
  return ($proc ??= GL::getProcAddress('programUniform3iv'))($program, $location, $count, $value);
}

function glProgramUniform3ivEXT(int $program, int $location, int $count, $value) {
  static $proc;
  return ($proc ??= GL::getProcAddress('programUniform3ivEXT'))($program, $location, $count, $value);
}

function glProgramUniform3ui(int $program, int $location, int $v0, int $v1, int $v2) {
  static $proc;
  return ($proc ??= GL::getProcAddress('programUniform3ui'))($program, $location, $v0, $v1, $v2);
}

function glProgramUniform3ui64ARB(int $program, int $location, int $x, int $y, int $z) {
  static $proc;
  return ($proc ??= GL::getProcAddress('programUniform3ui64ARB'))($program, $location, $x, $y, $z);
}

function glProgramUniform3ui64NV(int $program, int $location, int $x, int $y, int $z) {
  static $proc;
  return ($proc ??= GL::getProcAddress('programUniform3ui64NV'))($program, $location, $x, $y, $z);
}

function glProgramUniform3ui64vARB(int $program, int $location, int $count, $value) {
  static $proc;
  return ($proc ??= GL::getProcAddress('programUniform3ui64vARB'))($program, $location, $count, $value);
}

function glProgramUniform3ui64vNV(int $program, int $location, int $count, $value) {
  static $proc;
  return ($proc ??= GL::getProcAddress('programUniform3ui64vNV'))($program, $location, $count, $value);
}

function glProgramUniform3uiEXT(int $program, int $location, int $v0, int $v1, int $v2) {
  static $proc;
  return ($proc ??= GL::getProcAddress('programUniform3uiEXT'))($program, $location, $v0, $v1, $v2);
}

function glProgramUniform3uiv(int $program, int $location, int $count, $value) {
  static $proc;
  return ($proc ??= GL::getProcAddress('programUniform3uiv'))($program, $location, $count, $value);
}

function glProgramUniform3uivEXT(int $program, int $location, int $count, $value) {
  static $proc;
  return ($proc ??= GL::getProcAddress('programUniform3uivEXT'))($program, $location, $count, $value);
}

function glProgramUniform4d(int $program, int $location, float $v0, float $v1, float $v2, float $v3) {
  static $proc;
  return ($proc ??= GL::getProcAddress('programUniform4d'))($program, $location, $v0, $v1, $v2, $v3);
}

function glProgramUniform4dEXT(int $program, int $location, float $x, float $y, float $z, float $w) {
  static $proc;
  return ($proc ??= GL::getProcAddress('programUniform4dEXT'))($program, $location, $x, $y, $z, $w);
}

function glProgramUniform4dv(int $program, int $location, int $count, $value) {
  static $proc;
  return ($proc ??= GL::getProcAddress('programUniform4dv'))($program, $location, $count, $value);
}

function glProgramUniform4dvEXT(int $program, int $location, int $count, $value) {
  static $proc;
  return ($proc ??= GL::getProcAddress('programUniform4dvEXT'))($program, $location, $count, $value);
}

function glProgramUniform4f(int $program, int $location, float $v0, float $v1, float $v2, float $v3) {
  static $proc;
  return ($proc ??= GL::getProcAddress('programUniform4f'))($program, $location, $v0, $v1, $v2, $v3);
}

function glProgramUniform4fEXT(int $program, int $location, float $v0, float $v1, float $v2, float $v3) {
  static $proc;
  return ($proc ??= GL::getProcAddress('programUniform4fEXT'))($program, $location, $v0, $v1, $v2, $v3);
}

function glProgramUniform4fv(int $program, int $location, int $count, $value) {
  static $proc;
  return ($proc ??= GL::getProcAddress('programUniform4fv'))($program, $location, $count, $value);
}

function glProgramUniform4fvEXT(int $program, int $location, int $count, $value) {
  static $proc;
  return ($proc ??= GL::getProcAddress('programUniform4fvEXT'))($program, $location, $count, $value);
}

function glProgramUniform4i(int $program, int $location, int $v0, int $v1, int $v2, int $v3) {
  static $proc;
  return ($proc ??= GL::getProcAddress('programUniform4i'))($program, $location, $v0, $v1, $v2, $v3);
}

function glProgramUniform4i64ARB(int $program, int $location, int $x, int $y, int $z, int $w) {
  static $proc;
  return ($proc ??= GL::getProcAddress('programUniform4i64ARB'))($program, $location, $x, $y, $z, $w);
}

function glProgramUniform4i64NV(int $program, int $location, int $x, int $y, int $z, int $w) {
  static $proc;
  return ($proc ??= GL::getProcAddress('programUniform4i64NV'))($program, $location, $x, $y, $z, $w);
}

function glProgramUniform4i64vARB(int $program, int $location, int $count, $value) {
  static $proc;
  return ($proc ??= GL::getProcAddress('programUniform4i64vARB'))($program, $location, $count, $value);
}

function glProgramUniform4i64vNV(int $program, int $location, int $count, $value) {
  static $proc;
  return ($proc ??= GL::getProcAddress('programUniform4i64vNV'))($program, $location, $count, $value);
}

function glProgramUniform4iEXT(int $program, int $location, int $v0, int $v1, int $v2, int $v3) {
  static $proc;
  return ($proc ??= GL::getProcAddress('programUniform4iEXT'))($program, $location, $v0, $v1, $v2, $v3);
}

function glProgramUniform4iv(int $program, int $location, int $count, $value) {
  static $proc;
  return ($proc ??= GL::getProcAddress('programUniform4iv'))($program, $location, $count, $value);
}

function glProgramUniform4ivEXT(int $program, int $location, int $count, $value) {
  static $proc;
  return ($proc ??= GL::getProcAddress('programUniform4ivEXT'))($program, $location, $count, $value);
}

function glProgramUniform4ui(int $program, int $location, int $v0, int $v1, int $v2, int $v3) {
  static $proc;
  return ($proc ??= GL::getProcAddress('programUniform4ui'))($program, $location, $v0, $v1, $v2, $v3);
}

function glProgramUniform4ui64ARB(int $program, int $location, int $x, int $y, int $z, int $w) {
  static $proc;
  return ($proc ??= GL::getProcAddress('programUniform4ui64ARB'))($program, $location, $x, $y, $z, $w);
}

function glProgramUniform4ui64NV(int $program, int $location, int $x, int $y, int $z, int $w) {
  static $proc;
  return ($proc ??= GL::getProcAddress('programUniform4ui64NV'))($program, $location, $x, $y, $z, $w);
}

function glProgramUniform4ui64vARB(int $program, int $location, int $count, $value) {
  static $proc;
  return ($proc ??= GL::getProcAddress('programUniform4ui64vARB'))($program, $location, $count, $value);
}

function glProgramUniform4ui64vNV(int $program, int $location, int $count, $value) {
  static $proc;
  return ($proc ??= GL::getProcAddress('programUniform4ui64vNV'))($program, $location, $count, $value);
}

function glProgramUniform4uiEXT(int $program, int $location, int $v0, int $v1, int $v2, int $v3) {
  static $proc;
  return ($proc ??= GL::getProcAddress('programUniform4uiEXT'))($program, $location, $v0, $v1, $v2, $v3);
}

function glProgramUniform4uiv(int $program, int $location, int $count, $value) {
  static $proc;
  return ($proc ??= GL::getProcAddress('programUniform4uiv'))($program, $location, $count, $value);
}

function glProgramUniform4uivEXT(int $program, int $location, int $count, $value) {
  static $proc;
  return ($proc ??= GL::getProcAddress('programUniform4uivEXT'))($program, $location, $count, $value);
}

function glProgramUniformHandleui64ARB(int $program, int $location, int $value) {
  static $proc;
  return ($proc ??= GL::getProcAddress('programUniformHandleui64ARB'))($program, $location, $value);
}

function glProgramUniformHandleui64IMG(int $program, int $location, int $value) {
  static $proc;
  return ($proc ??= GL::getProcAddress('programUniformHandleui64IMG'))($program, $location, $value);
}

function glProgramUniformHandleui64NV(int $program, int $location, int $value) {
  static $proc;
  return ($proc ??= GL::getProcAddress('programUniformHandleui64NV'))($program, $location, $value);
}

function glProgramUniformHandleui64vARB(int $program, int $location, int $count, $values) {
  static $proc;
  return ($proc ??= GL::getProcAddress('programUniformHandleui64vARB'))($program, $location, $count, $values);
}

function glProgramUniformHandleui64vIMG(int $program, int $location, int $count, $values) {
  static $proc;
  return ($proc ??= GL::getProcAddress('programUniformHandleui64vIMG'))($program, $location, $count, $values);
}

function glProgramUniformHandleui64vNV(int $program, int $location, int $count, $values) {
  static $proc;
  return ($proc ??= GL::getProcAddress('programUniformHandleui64vNV'))($program, $location, $count, $values);
}

function glProgramUniformMatrix2dv(int $program, int $location, int $count, int $transpose, $value) {
  static $proc;
  return ($proc ??= GL::getProcAddress('programUniformMatrix2dv'))($program, $location, $count, $transpose, $value);
}

function glProgramUniformMatrix2dvEXT(int $program, int $location, int $count, int $transpose, $value) {
  static $proc;
  return ($proc ??= GL::getProcAddress('programUniformMatrix2dvEXT'))($program, $location, $count, $transpose, $value);
}

function glProgramUniformMatrix2fv(int $program, int $location, int $count, int $transpose, $value) {
  static $proc;
  return ($proc ??= GL::getProcAddress('programUniformMatrix2fv'))($program, $location, $count, $transpose, $value);
}

function glProgramUniformMatrix2fvEXT(int $program, int $location, int $count, int $transpose, $value) {
  static $proc;
  return ($proc ??= GL::getProcAddress('programUniformMatrix2fvEXT'))($program, $location, $count, $transpose, $value);
}

function glProgramUniformMatrix2x3dv(int $program, int $location, int $count, int $transpose, $value) {
  static $proc;
  return ($proc ??= GL::getProcAddress('programUniformMatrix2x3dv'))($program, $location, $count, $transpose, $value);
}

function glProgramUniformMatrix2x3dvEXT(int $program, int $location, int $count, int $transpose, $value) {
  static $proc;
  return ($proc ??= GL::getProcAddress('programUniformMatrix2x3dvEXT'))($program, $location, $count, $transpose, $value);
}

function glProgramUniformMatrix2x3fv(int $program, int $location, int $count, int $transpose, $value) {
  static $proc;
  return ($proc ??= GL::getProcAddress('programUniformMatrix2x3fv'))($program, $location, $count, $transpose, $value);
}

function glProgramUniformMatrix2x3fvEXT(int $program, int $location, int $count, int $transpose, $value) {
  static $proc;
  return ($proc ??= GL::getProcAddress('programUniformMatrix2x3fvEXT'))($program, $location, $count, $transpose, $value);
}

function glProgramUniformMatrix2x4dv(int $program, int $location, int $count, int $transpose, $value) {
  static $proc;
  return ($proc ??= GL::getProcAddress('programUniformMatrix2x4dv'))($program, $location, $count, $transpose, $value);
}

function glProgramUniformMatrix2x4dvEXT(int $program, int $location, int $count, int $transpose, $value) {
  static $proc;
  return ($proc ??= GL::getProcAddress('programUniformMatrix2x4dvEXT'))($program, $location, $count, $transpose, $value);
}

function glProgramUniformMatrix2x4fv(int $program, int $location, int $count, int $transpose, $value) {
  static $proc;
  return ($proc ??= GL::getProcAddress('programUniformMatrix2x4fv'))($program, $location, $count, $transpose, $value);
}

function glProgramUniformMatrix2x4fvEXT(int $program, int $location, int $count, int $transpose, $value) {
  static $proc;
  return ($proc ??= GL::getProcAddress('programUniformMatrix2x4fvEXT'))($program, $location, $count, $transpose, $value);
}

function glProgramUniformMatrix3dv(int $program, int $location, int $count, int $transpose, $value) {
  static $proc;
  return ($proc ??= GL::getProcAddress('programUniformMatrix3dv'))($program, $location, $count, $transpose, $value);
}

function glProgramUniformMatrix3dvEXT(int $program, int $location, int $count, int $transpose, $value) {
  static $proc;
  return ($proc ??= GL::getProcAddress('programUniformMatrix3dvEXT'))($program, $location, $count, $transpose, $value);
}

function glProgramUniformMatrix3fv(int $program, int $location, int $count, int $transpose, $value) {
  static $proc;
  return ($proc ??= GL::getProcAddress('programUniformMatrix3fv'))($program, $location, $count, $transpose, $value);
}

function glProgramUniformMatrix3fvEXT(int $program, int $location, int $count, int $transpose, $value) {
  static $proc;
  return ($proc ??= GL::getProcAddress('programUniformMatrix3fvEXT'))($program, $location, $count, $transpose, $value);
}

function glProgramUniformMatrix3x2dv(int $program, int $location, int $count, int $transpose, $value) {
  static $proc;
  return ($proc ??= GL::getProcAddress('programUniformMatrix3x2dv'))($program, $location, $count, $transpose, $value);
}

function glProgramUniformMatrix3x2dvEXT(int $program, int $location, int $count, int $transpose, $value) {
  static $proc;
  return ($proc ??= GL::getProcAddress('programUniformMatrix3x2dvEXT'))($program, $location, $count, $transpose, $value);
}

function glProgramUniformMatrix3x2fv(int $program, int $location, int $count, int $transpose, $value) {
  static $proc;
  return ($proc ??= GL::getProcAddress('programUniformMatrix3x2fv'))($program, $location, $count, $transpose, $value);
}

function glProgramUniformMatrix3x2fvEXT(int $program, int $location, int $count, int $transpose, $value) {
  static $proc;
  return ($proc ??= GL::getProcAddress('programUniformMatrix3x2fvEXT'))($program, $location, $count, $transpose, $value);
}

function glProgramUniformMatrix3x4dv(int $program, int $location, int $count, int $transpose, $value) {
  static $proc;
  return ($proc ??= GL::getProcAddress('programUniformMatrix3x4dv'))($program, $location, $count, $transpose, $value);
}

function glProgramUniformMatrix3x4dvEXT(int $program, int $location, int $count, int $transpose, $value) {
  static $proc;
  return ($proc ??= GL::getProcAddress('programUniformMatrix3x4dvEXT'))($program, $location, $count, $transpose, $value);
}

function glProgramUniformMatrix3x4fv(int $program, int $location, int $count, int $transpose, $value) {
  static $proc;
  return ($proc ??= GL::getProcAddress('programUniformMatrix3x4fv'))($program, $location, $count, $transpose, $value);
}

function glProgramUniformMatrix3x4fvEXT(int $program, int $location, int $count, int $transpose, $value) {
  static $proc;
  return ($proc ??= GL::getProcAddress('programUniformMatrix3x4fvEXT'))($program, $location, $count, $transpose, $value);
}

function glProgramUniformMatrix4dv(int $program, int $location, int $count, int $transpose, $value) {
  static $proc;
  return ($proc ??= GL::getProcAddress('programUniformMatrix4dv'))($program, $location, $count, $transpose, $value);
}

function glProgramUniformMatrix4dvEXT(int $program, int $location, int $count, int $transpose, $value) {
  static $proc;
  return ($proc ??= GL::getProcAddress('programUniformMatrix4dvEXT'))($program, $location, $count, $transpose, $value);
}

function glProgramUniformMatrix4fv(int $program, int $location, int $count, int $transpose, $value) {
  static $proc;
  return ($proc ??= GL::getProcAddress('programUniformMatrix4fv'))($program, $location, $count, $transpose, $value);
}

function glProgramUniformMatrix4fvEXT(int $program, int $location, int $count, int $transpose, $value) {
  static $proc;
  return ($proc ??= GL::getProcAddress('programUniformMatrix4fvEXT'))($program, $location, $count, $transpose, $value);
}

function glProgramUniformMatrix4x2dv(int $program, int $location, int $count, int $transpose, $value) {
  static $proc;
  return ($proc ??= GL::getProcAddress('programUniformMatrix4x2dv'))($program, $location, $count, $transpose, $value);
}

function glProgramUniformMatrix4x2dvEXT(int $program, int $location, int $count, int $transpose, $value) {
  static $proc;
  return ($proc ??= GL::getProcAddress('programUniformMatrix4x2dvEXT'))($program, $location, $count, $transpose, $value);
}

function glProgramUniformMatrix4x2fv(int $program, int $location, int $count, int $transpose, $value) {
  static $proc;
  return ($proc ??= GL::getProcAddress('programUniformMatrix4x2fv'))($program, $location, $count, $transpose, $value);
}

function glProgramUniformMatrix4x2fvEXT(int $program, int $location, int $count, int $transpose, $value) {
  static $proc;
  return ($proc ??= GL::getProcAddress('programUniformMatrix4x2fvEXT'))($program, $location, $count, $transpose, $value);
}

function glProgramUniformMatrix4x3dv(int $program, int $location, int $count, int $transpose, $value) {
  static $proc;
  return ($proc ??= GL::getProcAddress('programUniformMatrix4x3dv'))($program, $location, $count, $transpose, $value);
}

function glProgramUniformMatrix4x3dvEXT(int $program, int $location, int $count, int $transpose, $value) {
  static $proc;
  return ($proc ??= GL::getProcAddress('programUniformMatrix4x3dvEXT'))($program, $location, $count, $transpose, $value);
}

function glProgramUniformMatrix4x3fv(int $program, int $location, int $count, int $transpose, $value) {
  static $proc;
  return ($proc ??= GL::getProcAddress('programUniformMatrix4x3fv'))($program, $location, $count, $transpose, $value);
}

function glProgramUniformMatrix4x3fvEXT(int $program, int $location, int $count, int $transpose, $value) {
  static $proc;
  return ($proc ??= GL::getProcAddress('programUniformMatrix4x3fvEXT'))($program, $location, $count, $transpose, $value);
}

function glProgramUniformui64NV(int $program, int $location, int $value) {
  static $proc;
  return ($proc ??= GL::getProcAddress('programUniformui64NV'))($program, $location, $value);
}

function glProgramUniformui64vNV(int $program, int $location, int $count, $value) {
  static $proc;
  return ($proc ??= GL::getProcAddress('programUniformui64vNV'))($program, $location, $count, $value);
}

function glProgramVertexLimitNV(int $target, int $limit) {
  static $proc;
  return ($proc ??= GL::getProcAddress('programVertexLimitNV'))($target, $limit);
}

function glProvokingVertex(int $mode) {
  static $proc;
  return ($proc ??= GL::getProcAddress('provokingVertex'))($mode);
}

function glProvokingVertexEXT(int $mode) {
  static $proc;
  return ($proc ??= GL::getProcAddress('provokingVertexEXT'))($mode);
}

function glPushAttrib(int $mask) {
  static $proc;
  return ($proc ??= GL::getProcAddress('pushAttrib'))($mask);
}

function glPushClientAttrib(int $mask) {
  static $proc;
  return ($proc ??= GL::getProcAddress('pushClientAttrib'))($mask);
}

function glPushClientAttribDefaultEXT(int $mask) {
  static $proc;
  return ($proc ??= GL::getProcAddress('pushClientAttribDefaultEXT'))($mask);
}

function glPushDebugGroup(int $source, int $id, int $length, $message) {
  static $proc;
  return ($proc ??= GL::getProcAddress('pushDebugGroup'))($source, $id, $length, $message);
}

function glPushDebugGroupKHR(int $source, int $id, int $length, $message) {
  static $proc;
  return ($proc ??= GL::getProcAddress('pushDebugGroupKHR'))($source, $id, $length, $message);
}

function glPushGroupMarkerEXT(int $length, $marker) {
  static $proc;
  return ($proc ??= GL::getProcAddress('pushGroupMarkerEXT'))($length, $marker);
}

function glPushMatrix() {
  static $proc;
  return ($proc ??= GL::getProcAddress('pushMatrix'))();
}

function glPushName(int $name) {
  static $proc;
  return ($proc ??= GL::getProcAddress('pushName'))($name);
}

function glQueryCounter(int $id, int $target) {
  static $proc;
  return ($proc ??= GL::getProcAddress('queryCounter'))($id, $target);
}

function glQueryCounterEXT(int $id, int $target) {
  static $proc;
  return ($proc ??= GL::getProcAddress('queryCounterEXT'))($id, $target);
}

function glQueryMatrixxOES($mantissa, $exponent) {
  static $proc;
  return ($proc ??= GL::getProcAddress('queryMatrixxOES'))($mantissa, $exponent);
}

function glQueryObjectParameteruiAMD(int $target, int $id, int $pname, int $param) {
  static $proc;
  return ($proc ??= GL::getProcAddress('queryObjectParameteruiAMD'))($target, $id, $pname, $param);
}

function glRasterPos2d(float $x, float $y) {
  static $proc;
  return ($proc ??= GL::getProcAddress('rasterPos2d'))($x, $y);
}

function glRasterPos2dv($v) {
  static $proc;
  return ($proc ??= GL::getProcAddress('rasterPos2dv'))($v);
}

function glRasterPos2f(float $x, float $y) {
  static $proc;
  return ($proc ??= GL::getProcAddress('rasterPos2f'))($x, $y);
}

function glRasterPos2fv($v) {
  static $proc;
  return ($proc ??= GL::getProcAddress('rasterPos2fv'))($v);
}

function glRasterPos2i(int $x, int $y) {
  static $proc;
  return ($proc ??= GL::getProcAddress('rasterPos2i'))($x, $y);
}

function glRasterPos2iv($v) {
  static $proc;
  return ($proc ??= GL::getProcAddress('rasterPos2iv'))($v);
}

function glRasterPos2s(int $x, int $y) {
  static $proc;
  return ($proc ??= GL::getProcAddress('rasterPos2s'))($x, $y);
}

function glRasterPos2sv($v) {
  static $proc;
  return ($proc ??= GL::getProcAddress('rasterPos2sv'))($v);
}

function glRasterPos2xOES(int $x, int $y) {
  static $proc;
  return ($proc ??= GL::getProcAddress('rasterPos2xOES'))($x, $y);
}

function glRasterPos2xvOES($coords) {
  static $proc;
  return ($proc ??= GL::getProcAddress('rasterPos2xvOES'))($coords);
}

function glRasterPos3d(float $x, float $y, float $z) {
  static $proc;
  return ($proc ??= GL::getProcAddress('rasterPos3d'))($x, $y, $z);
}

function glRasterPos3dv($v) {
  static $proc;
  return ($proc ??= GL::getProcAddress('rasterPos3dv'))($v);
}

function glRasterPos3f(float $x, float $y, float $z) {
  static $proc;
  return ($proc ??= GL::getProcAddress('rasterPos3f'))($x, $y, $z);
}

function glRasterPos3fv($v) {
  static $proc;
  return ($proc ??= GL::getProcAddress('rasterPos3fv'))($v);
}

function glRasterPos3i(int $x, int $y, int $z) {
  static $proc;
  return ($proc ??= GL::getProcAddress('rasterPos3i'))($x, $y, $z);
}

function glRasterPos3iv($v) {
  static $proc;
  return ($proc ??= GL::getProcAddress('rasterPos3iv'))($v);
}

function glRasterPos3s(int $x, int $y, int $z) {
  static $proc;
  return ($proc ??= GL::getProcAddress('rasterPos3s'))($x, $y, $z);
}

function glRasterPos3sv($v) {
  static $proc;
  return ($proc ??= GL::getProcAddress('rasterPos3sv'))($v);
}

function glRasterPos3xOES(int $x, int $y, int $z) {
  static $proc;
  return ($proc ??= GL::getProcAddress('rasterPos3xOES'))($x, $y, $z);
}

function glRasterPos3xvOES($coords) {
  static $proc;
  return ($proc ??= GL::getProcAddress('rasterPos3xvOES'))($coords);
}

function glRasterPos4d(float $x, float $y, float $z, float $w) {
  static $proc;
  return ($proc ??= GL::getProcAddress('rasterPos4d'))($x, $y, $z, $w);
}

function glRasterPos4dv($v) {
  static $proc;
  return ($proc ??= GL::getProcAddress('rasterPos4dv'))($v);
}

function glRasterPos4f(float $x, float $y, float $z, float $w) {
  static $proc;
  return ($proc ??= GL::getProcAddress('rasterPos4f'))($x, $y, $z, $w);
}

function glRasterPos4fv($v) {
  static $proc;
  return ($proc ??= GL::getProcAddress('rasterPos4fv'))($v);
}

function glRasterPos4i(int $x, int $y, int $z, int $w) {
  static $proc;
  return ($proc ??= GL::getProcAddress('rasterPos4i'))($x, $y, $z, $w);
}

function glRasterPos4iv($v) {
  static $proc;
  return ($proc ??= GL::getProcAddress('rasterPos4iv'))($v);
}

function glRasterPos4s(int $x, int $y, int $z, int $w) {
  static $proc;
  return ($proc ??= GL::getProcAddress('rasterPos4s'))($x, $y, $z, $w);
}

function glRasterPos4sv($v) {
  static $proc;
  return ($proc ??= GL::getProcAddress('rasterPos4sv'))($v);
}

function glRasterPos4xOES(int $x, int $y, int $z, int $w) {
  static $proc;
  return ($proc ??= GL::getProcAddress('rasterPos4xOES'))($x, $y, $z, $w);
}

function glRasterPos4xvOES($coords) {
  static $proc;
  return ($proc ??= GL::getProcAddress('rasterPos4xvOES'))($coords);
}

function glRasterSamplesEXT(int $samples, int $fixedsamplelocations) {
  static $proc;
  return ($proc ??= GL::getProcAddress('rasterSamplesEXT'))($samples, $fixedsamplelocations);
}

function glReadBuffer(int $src) {
  static $proc;
  return ($proc ??= GL::getProcAddress('readBuffer'))($src);
}

function glReadBufferIndexedEXT(int $src, int $index) {
  static $proc;
  return ($proc ??= GL::getProcAddress('readBufferIndexedEXT'))($src, $index);
}

function glReadBufferNV(int $mode) {
  static $proc;
  return ($proc ??= GL::getProcAddress('readBufferNV'))($mode);
}

function glReadInstrumentsSGIX(int $marker) {
  static $proc;
  return ($proc ??= GL::getProcAddress('readInstrumentsSGIX'))($marker);
}

function glReadPixels(int $x, int $y, int $width, int $height, int $format, int $type, $pixels) {
  static $proc;
  return ($proc ??= GL::getProcAddress('readPixels'))($x, $y, $width, $height, $format, $type, $pixels);
}

function glReadnPixels(int $x, int $y, int $width, int $height, int $format, int $type, int $bufSize, $data) {
  static $proc;
  return ($proc ??= GL::getProcAddress('readnPixels'))($x, $y, $width, $height, $format, $type, $bufSize, $data);
}

function glReadnPixelsARB(int $x, int $y, int $width, int $height, int $format, int $type, int $bufSize, $data) {
  static $proc;
  return ($proc ??= GL::getProcAddress('readnPixelsARB'))($x, $y, $width, $height, $format, $type, $bufSize, $data);
}

function glReadnPixelsEXT(int $x, int $y, int $width, int $height, int $format, int $type, int $bufSize, $data) {
  static $proc;
  return ($proc ??= GL::getProcAddress('readnPixelsEXT'))($x, $y, $width, $height, $format, $type, $bufSize, $data);
}

function glReadnPixelsKHR(int $x, int $y, int $width, int $height, int $format, int $type, int $bufSize, $data) {
  static $proc;
  return ($proc ??= GL::getProcAddress('readnPixelsKHR'))($x, $y, $width, $height, $format, $type, $bufSize, $data);
}

function glRectd(float $x1, float $y1, float $x2, float $y2) {
  static $proc;
  return ($proc ??= GL::getProcAddress('rectd'))($x1, $y1, $x2, $y2);
}

function glRectdv($v1, $v2) {
  static $proc;
  return ($proc ??= GL::getProcAddress('rectdv'))($v1, $v2);
}

function glRectf(float $x1, float $y1, float $x2, float $y2) {
  static $proc;
  return ($proc ??= GL::getProcAddress('rectf'))($x1, $y1, $x2, $y2);
}

function glRectfv($v1, $v2) {
  static $proc;
  return ($proc ??= GL::getProcAddress('rectfv'))($v1, $v2);
}

function glRecti(int $x1, int $y1, int $x2, int $y2) {
  static $proc;
  return ($proc ??= GL::getProcAddress('recti'))($x1, $y1, $x2, $y2);
}

function glRectiv($v1, $v2) {
  static $proc;
  return ($proc ??= GL::getProcAddress('rectiv'))($v1, $v2);
}

function glRects(int $x1, int $y1, int $x2, int $y2) {
  static $proc;
  return ($proc ??= GL::getProcAddress('rects'))($x1, $y1, $x2, $y2);
}

function glRectsv($v1, $v2) {
  static $proc;
  return ($proc ??= GL::getProcAddress('rectsv'))($v1, $v2);
}

function glRectxOES(int $x1, int $y1, int $x2, int $y2) {
  static $proc;
  return ($proc ??= GL::getProcAddress('rectxOES'))($x1, $y1, $x2, $y2);
}

function glRectxvOES($v1, $v2) {
  static $proc;
  return ($proc ??= GL::getProcAddress('rectxvOES'))($v1, $v2);
}

function glReferencePlaneSGIX($equation) {
  static $proc;
  return ($proc ??= GL::getProcAddress('referencePlaneSGIX'))($equation);
}

function glReleaseShaderCompiler() {
  static $proc;
  return ($proc ??= GL::getProcAddress('releaseShaderCompiler'))();
}

function glRenderMode(int $mode) {
  static $proc;
  return ($proc ??= GL::getProcAddress('renderMode'))($mode);
}

function glRenderbufferStorage(int $target, int $internalformat, int $width, int $height) {
  static $proc;
  return ($proc ??= GL::getProcAddress('renderbufferStorage'))($target, $internalformat, $width, $height);
}

function glRenderbufferStorageEXT(int $target, int $internalformat, int $width, int $height) {
  static $proc;
  return ($proc ??= GL::getProcAddress('renderbufferStorageEXT'))($target, $internalformat, $width, $height);
}

function glRenderbufferStorageMultisample(int $target, int $samples, int $internalformat, int $width, int $height) {
  static $proc;
  return ($proc ??= GL::getProcAddress('renderbufferStorageMultisample'))($target, $samples, $internalformat, $width, $height);
}

function glRenderbufferStorageMultisampleANGLE(int $target, int $samples, int $internalformat, int $width, int $height) {
  static $proc;
  return ($proc ??= GL::getProcAddress('renderbufferStorageMultisampleANGLE'))($target, $samples, $internalformat, $width, $height);
}

function glRenderbufferStorageMultisampleAPPLE(int $target, int $samples, int $internalformat, int $width, int $height) {
  static $proc;
  return ($proc ??= GL::getProcAddress('renderbufferStorageMultisampleAPPLE'))($target, $samples, $internalformat, $width, $height);
}

function glRenderbufferStorageMultisampleCoverageNV(int $target, int $coverageSamples, int $colorSamples, int $internalformat, int $width, int $height) {
  static $proc;
  return ($proc ??= GL::getProcAddress('renderbufferStorageMultisampleCoverageNV'))($target, $coverageSamples, $colorSamples, $internalformat, $width, $height);
}

function glRenderbufferStorageMultisampleEXT(int $target, int $samples, int $internalformat, int $width, int $height) {
  static $proc;
  return ($proc ??= GL::getProcAddress('renderbufferStorageMultisampleEXT'))($target, $samples, $internalformat, $width, $height);
}

function glRenderbufferStorageMultisampleIMG(int $target, int $samples, int $internalformat, int $width, int $height) {
  static $proc;
  return ($proc ??= GL::getProcAddress('renderbufferStorageMultisampleIMG'))($target, $samples, $internalformat, $width, $height);
}

function glRenderbufferStorageMultisampleNV(int $target, int $samples, int $internalformat, int $width, int $height) {
  static $proc;
  return ($proc ??= GL::getProcAddress('renderbufferStorageMultisampleNV'))($target, $samples, $internalformat, $width, $height);
}

function glRenderbufferStorageOES(int $target, int $internalformat, int $width, int $height) {
  static $proc;
  return ($proc ??= GL::getProcAddress('renderbufferStorageOES'))($target, $internalformat, $width, $height);
}

function glReplacementCodePointerSUN(int $type, int $stride, $pointer) {
  static $proc;
  return ($proc ??= GL::getProcAddress('replacementCodePointerSUN'))($type, $stride, $pointer);
}

function glReplacementCodeubSUN(int $code) {
  static $proc;
  return ($proc ??= GL::getProcAddress('replacementCodeubSUN'))($code);
}

function glReplacementCodeubvSUN($code) {
  static $proc;
  return ($proc ??= GL::getProcAddress('replacementCodeubvSUN'))($code);
}

function glReplacementCodeuiColor3fVertex3fSUN(int $rc, float $r, float $g, float $b, float $x, float $y, float $z) {
  static $proc;
  return ($proc ??= GL::getProcAddress('replacementCodeuiColor3fVertex3fSUN'))($rc, $r, $g, $b, $x, $y, $z);
}

function glReplacementCodeuiColor3fVertex3fvSUN($rc, $c, $v) {
  static $proc;
  return ($proc ??= GL::getProcAddress('replacementCodeuiColor3fVertex3fvSUN'))($rc, $c, $v);
}

function glReplacementCodeuiColor4fNormal3fVertex3fSUN(int $rc, float $r, float $g, float $b, float $a, float $nx, float $ny, float $nz, float $x, float $y, float $z) {
  static $proc;
  return ($proc ??= GL::getProcAddress('replacementCodeuiColor4fNormal3fVertex3fSUN'))($rc, $r, $g, $b, $a, $nx, $ny, $nz, $x, $y, $z);
}

function glReplacementCodeuiColor4fNormal3fVertex3fvSUN($rc, $c, $n, $v) {
  static $proc;
  return ($proc ??= GL::getProcAddress('replacementCodeuiColor4fNormal3fVertex3fvSUN'))($rc, $c, $n, $v);
}

function glReplacementCodeuiColor4ubVertex3fSUN(int $rc, int $r, int $g, int $b, int $a, float $x, float $y, float $z) {
  static $proc;
  return ($proc ??= GL::getProcAddress('replacementCodeuiColor4ubVertex3fSUN'))($rc, $r, $g, $b, $a, $x, $y, $z);
}

function glReplacementCodeuiColor4ubVertex3fvSUN($rc, $c, $v) {
  static $proc;
  return ($proc ??= GL::getProcAddress('replacementCodeuiColor4ubVertex3fvSUN'))($rc, $c, $v);
}

function glReplacementCodeuiNormal3fVertex3fSUN(int $rc, float $nx, float $ny, float $nz, float $x, float $y, float $z) {
  static $proc;
  return ($proc ??= GL::getProcAddress('replacementCodeuiNormal3fVertex3fSUN'))($rc, $nx, $ny, $nz, $x, $y, $z);
}

function glReplacementCodeuiNormal3fVertex3fvSUN($rc, $n, $v) {
  static $proc;
  return ($proc ??= GL::getProcAddress('replacementCodeuiNormal3fVertex3fvSUN'))($rc, $n, $v);
}

function glReplacementCodeuiSUN(int $code) {
  static $proc;
  return ($proc ??= GL::getProcAddress('replacementCodeuiSUN'))($code);
}

function glReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fSUN(int $rc, float $s, float $t, float $r, float $g, float $b, float $a, float $nx, float $ny, float $nz, float $x, float $y, float $z) {
  static $proc;
  return ($proc ??= GL::getProcAddress('replacementCodeuiTexCoord2fColor4fNormal3fVertex3fSUN'))($rc, $s, $t, $r, $g, $b, $a, $nx, $ny, $nz, $x, $y, $z);
}

function glReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN($rc, $tc, $c, $n, $v) {
  static $proc;
  return ($proc ??= GL::getProcAddress('replacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN'))($rc, $tc, $c, $n, $v);
}

function glReplacementCodeuiTexCoord2fNormal3fVertex3fSUN(int $rc, float $s, float $t, float $nx, float $ny, float $nz, float $x, float $y, float $z) {
  static $proc;
  return ($proc ??= GL::getProcAddress('replacementCodeuiTexCoord2fNormal3fVertex3fSUN'))($rc, $s, $t, $nx, $ny, $nz, $x, $y, $z);
}

function glReplacementCodeuiTexCoord2fNormal3fVertex3fvSUN($rc, $tc, $n, $v) {
  static $proc;
  return ($proc ??= GL::getProcAddress('replacementCodeuiTexCoord2fNormal3fVertex3fvSUN'))($rc, $tc, $n, $v);
}

function glReplacementCodeuiTexCoord2fVertex3fSUN(int $rc, float $s, float $t, float $x, float $y, float $z) {
  static $proc;
  return ($proc ??= GL::getProcAddress('replacementCodeuiTexCoord2fVertex3fSUN'))($rc, $s, $t, $x, $y, $z);
}

function glReplacementCodeuiTexCoord2fVertex3fvSUN($rc, $tc, $v) {
  static $proc;
  return ($proc ??= GL::getProcAddress('replacementCodeuiTexCoord2fVertex3fvSUN'))($rc, $tc, $v);
}

function glReplacementCodeuiVertex3fSUN(int $rc, float $x, float $y, float $z) {
  static $proc;
  return ($proc ??= GL::getProcAddress('replacementCodeuiVertex3fSUN'))($rc, $x, $y, $z);
}

function glReplacementCodeuiVertex3fvSUN($rc, $v) {
  static $proc;
  return ($proc ??= GL::getProcAddress('replacementCodeuiVertex3fvSUN'))($rc, $v);
}

function glReplacementCodeuivSUN($code) {
  static $proc;
  return ($proc ??= GL::getProcAddress('replacementCodeuivSUN'))($code);
}

function glReplacementCodeusSUN(int $code) {
  static $proc;
  return ($proc ??= GL::getProcAddress('replacementCodeusSUN'))($code);
}

function glReplacementCodeusvSUN($code) {
  static $proc;
  return ($proc ??= GL::getProcAddress('replacementCodeusvSUN'))($code);
}

function glRequestResidentProgramsNV(int $n, $programs) {
  static $proc;
  return ($proc ??= GL::getProcAddress('requestResidentProgramsNV'))($n, $programs);
}

function glResetHistogram(int $target) {
  static $proc;
  return ($proc ??= GL::getProcAddress('resetHistogram'))($target);
}

function glResetHistogramEXT(int $target) {
  static $proc;
  return ($proc ??= GL::getProcAddress('resetHistogramEXT'))($target);
}

function glResetMinmax(int $target) {
  static $proc;
  return ($proc ??= GL::getProcAddress('resetMinmax'))($target);
}

function glResetMinmaxEXT(int $target) {
  static $proc;
  return ($proc ??= GL::getProcAddress('resetMinmaxEXT'))($target);
}

function glResizeBuffersMESA() {
  static $proc;
  return ($proc ??= GL::getProcAddress('resizeBuffersMESA'))();
}

function glResolveDepthValuesNV() {
  static $proc;
  return ($proc ??= GL::getProcAddress('resolveDepthValuesNV'))();
}

function glResolveMultisampleFramebufferAPPLE() {
  static $proc;
  return ($proc ??= GL::getProcAddress('resolveMultisampleFramebufferAPPLE'))();
}

function glResumeTransformFeedback() {
  static $proc;
  return ($proc ??= GL::getProcAddress('resumeTransformFeedback'))();
}

function glResumeTransformFeedbackNV() {
  static $proc;
  return ($proc ??= GL::getProcAddress('resumeTransformFeedbackNV'))();
}

function glRotated(float $angle, float $x, float $y, float $z) {
  static $proc;
  return ($proc ??= GL::getProcAddress('rotated'))($angle, $x, $y, $z);
}

function glRotatef(float $angle, float $x, float $y, float $z) {
  static $proc;
  return ($proc ??= GL::getProcAddress('rotatef'))($angle, $x, $y, $z);
}

function glRotatex(int $angle, int $x, int $y, int $z) {
  static $proc;
  return ($proc ??= GL::getProcAddress('rotatex'))($angle, $x, $y, $z);
}

function glRotatexOES(int $angle, int $x, int $y, int $z) {
  static $proc;
  return ($proc ??= GL::getProcAddress('rotatexOES'))($angle, $x, $y, $z);
}

function glSampleCoverage(float $value, int $invert) {
  static $proc;
  return ($proc ??= GL::getProcAddress('sampleCoverage'))($value, $invert);
}

function glSampleCoverageARB(float $value, int $invert) {
  static $proc;
  return ($proc ??= GL::getProcAddress('sampleCoverageARB'))($value, $invert);
}

function glSampleCoveragex(int $value, int $invert) {
  static $proc;
  return ($proc ??= GL::getProcAddress('sampleCoveragex'))($value, $invert);
}

function glSampleCoveragexOES(int $value, int $invert) {
  static $proc;
  return ($proc ??= GL::getProcAddress('sampleCoveragexOES'))($value, $invert);
}

function glSampleMapATI(int $dst, int $interp, int $swizzle) {
  static $proc;
  return ($proc ??= GL::getProcAddress('sampleMapATI'))($dst, $interp, $swizzle);
}

function glSampleMaskEXT($value, int $invert) {
  static $proc;
  return ($proc ??= GL::getProcAddress('sampleMaskEXT'))($value, $invert);
}

function glSampleMaskIndexedNV(int $index, int $mask) {
  static $proc;
  return ($proc ??= GL::getProcAddress('sampleMaskIndexedNV'))($index, $mask);
}

function glSampleMaskSGIS($value, int $invert) {
  static $proc;
  return ($proc ??= GL::getProcAddress('sampleMaskSGIS'))($value, $invert);
}

function glSampleMaski(int $maskNumber, int $mask) {
  static $proc;
  return ($proc ??= GL::getProcAddress('sampleMaski'))($maskNumber, $mask);
}

function glSamplePatternEXT(int $pattern) {
  static $proc;
  return ($proc ??= GL::getProcAddress('samplePatternEXT'))($pattern);
}

function glSamplePatternSGIS(int $pattern) {
  static $proc;
  return ($proc ??= GL::getProcAddress('samplePatternSGIS'))($pattern);
}

function glSamplerParameterIiv(int $sampler, int $pname, $param) {
  static $proc;
  return ($proc ??= GL::getProcAddress('samplerParameterIiv'))($sampler, $pname, $param);
}

function glSamplerParameterIivEXT(int $sampler, int $pname, $param) {
  static $proc;
  return ($proc ??= GL::getProcAddress('samplerParameterIivEXT'))($sampler, $pname, $param);
}

function glSamplerParameterIivOES(int $sampler, int $pname, $param) {
  static $proc;
  return ($proc ??= GL::getProcAddress('samplerParameterIivOES'))($sampler, $pname, $param);
}

function glSamplerParameterIuiv(int $sampler, int $pname, $param) {
  static $proc;
  return ($proc ??= GL::getProcAddress('samplerParameterIuiv'))($sampler, $pname, $param);
}

function glSamplerParameterIuivEXT(int $sampler, int $pname, $param) {
  static $proc;
  return ($proc ??= GL::getProcAddress('samplerParameterIuivEXT'))($sampler, $pname, $param);
}

function glSamplerParameterIuivOES(int $sampler, int $pname, $param) {
  static $proc;
  return ($proc ??= GL::getProcAddress('samplerParameterIuivOES'))($sampler, $pname, $param);
}

function glSamplerParameterf(int $sampler, int $pname, float $param) {
  static $proc;
  return ($proc ??= GL::getProcAddress('samplerParameterf'))($sampler, $pname, $param);
}

function glSamplerParameterfv(int $sampler, int $pname, $param) {
  static $proc;
  return ($proc ??= GL::getProcAddress('samplerParameterfv'))($sampler, $pname, $param);
}

function glSamplerParameteri(int $sampler, int $pname, int $param) {
  static $proc;
  return ($proc ??= GL::getProcAddress('samplerParameteri'))($sampler, $pname, $param);
}

function glSamplerParameteriv(int $sampler, int $pname, $param) {
  static $proc;
  return ($proc ??= GL::getProcAddress('samplerParameteriv'))($sampler, $pname, $param);
}

function glScaled(float $x, float $y, float $z) {
  static $proc;
  return ($proc ??= GL::getProcAddress('scaled'))($x, $y, $z);
}

function glScalef(float $x, float $y, float $z) {
  static $proc;
  return ($proc ??= GL::getProcAddress('scalef'))($x, $y, $z);
}

function glScalex(int $x, int $y, int $z) {
  static $proc;
  return ($proc ??= GL::getProcAddress('scalex'))($x, $y, $z);
}

function glScalexOES(int $x, int $y, int $z) {
  static $proc;
  return ($proc ??= GL::getProcAddress('scalexOES'))($x, $y, $z);
}

function glScissor(int $x, int $y, int $width, int $height) {
  static $proc;
  return ($proc ??= GL::getProcAddress('scissor'))($x, $y, $width, $height);
}

function glScissorArrayv(int $first, int $count, $v) {
  static $proc;
  return ($proc ??= GL::getProcAddress('scissorArrayv'))($first, $count, $v);
}

function glScissorArrayvNV(int $first, int $count, $v) {
  static $proc;
  return ($proc ??= GL::getProcAddress('scissorArrayvNV'))($first, $count, $v);
}

function glScissorArrayvOES(int $first, int $count, $v) {
  static $proc;
  return ($proc ??= GL::getProcAddress('scissorArrayvOES'))($first, $count, $v);
}

function glScissorIndexed(int $index, int $left, int $bottom, int $width, int $height) {
  static $proc;
  return ($proc ??= GL::getProcAddress('scissorIndexed'))($index, $left, $bottom, $width, $height);
}

function glScissorIndexedNV(int $index, int $left, int $bottom, int $width, int $height) {
  static $proc;
  return ($proc ??= GL::getProcAddress('scissorIndexedNV'))($index, $left, $bottom, $width, $height);
}

function glScissorIndexedOES(int $index, int $left, int $bottom, int $width, int $height) {
  static $proc;
  return ($proc ??= GL::getProcAddress('scissorIndexedOES'))($index, $left, $bottom, $width, $height);
}

function glScissorIndexedv(int $index, $v) {
  static $proc;
  return ($proc ??= GL::getProcAddress('scissorIndexedv'))($index, $v);
}

function glScissorIndexedvNV(int $index, $v) {
  static $proc;
  return ($proc ??= GL::getProcAddress('scissorIndexedvNV'))($index, $v);
}

function glScissorIndexedvOES(int $index, $v) {
  static $proc;
  return ($proc ??= GL::getProcAddress('scissorIndexedvOES'))($index, $v);
}

function glSecondaryColor3b(int $red, int $green, int $blue) {
  static $proc;
  return ($proc ??= GL::getProcAddress('secondaryColor3b'))($red, $green, $blue);
}

function glSecondaryColor3bEXT(int $red, int $green, int $blue) {
  static $proc;
  return ($proc ??= GL::getProcAddress('secondaryColor3bEXT'))($red, $green, $blue);
}

function glSecondaryColor3bv($v) {
  static $proc;
  return ($proc ??= GL::getProcAddress('secondaryColor3bv'))($v);
}

function glSecondaryColor3bvEXT($v) {
  static $proc;
  return ($proc ??= GL::getProcAddress('secondaryColor3bvEXT'))($v);
}

function glSecondaryColor3d(float $red, float $green, float $blue) {
  static $proc;
  return ($proc ??= GL::getProcAddress('secondaryColor3d'))($red, $green, $blue);
}

function glSecondaryColor3dEXT(float $red, float $green, float $blue) {
  static $proc;
  return ($proc ??= GL::getProcAddress('secondaryColor3dEXT'))($red, $green, $blue);
}

function glSecondaryColor3dv($v) {
  static $proc;
  return ($proc ??= GL::getProcAddress('secondaryColor3dv'))($v);
}

function glSecondaryColor3dvEXT($v) {
  static $proc;
  return ($proc ??= GL::getProcAddress('secondaryColor3dvEXT'))($v);
}

function glSecondaryColor3f(float $red, float $green, float $blue) {
  static $proc;
  return ($proc ??= GL::getProcAddress('secondaryColor3f'))($red, $green, $blue);
}

function glSecondaryColor3fEXT(float $red, float $green, float $blue) {
  static $proc;
  return ($proc ??= GL::getProcAddress('secondaryColor3fEXT'))($red, $green, $blue);
}

function glSecondaryColor3fv($v) {
  static $proc;
  return ($proc ??= GL::getProcAddress('secondaryColor3fv'))($v);
}

function glSecondaryColor3fvEXT($v) {
  static $proc;
  return ($proc ??= GL::getProcAddress('secondaryColor3fvEXT'))($v);
}

function glSecondaryColor3hNV(int $red, int $green, int $blue) {
  static $proc;
  return ($proc ??= GL::getProcAddress('secondaryColor3hNV'))($red, $green, $blue);
}

function glSecondaryColor3hvNV($v) {
  static $proc;
  return ($proc ??= GL::getProcAddress('secondaryColor3hvNV'))($v);
}

function glSecondaryColor3i(int $red, int $green, int $blue) {
  static $proc;
  return ($proc ??= GL::getProcAddress('secondaryColor3i'))($red, $green, $blue);
}

function glSecondaryColor3iEXT(int $red, int $green, int $blue) {
  static $proc;
  return ($proc ??= GL::getProcAddress('secondaryColor3iEXT'))($red, $green, $blue);
}

function glSecondaryColor3iv($v) {
  static $proc;
  return ($proc ??= GL::getProcAddress('secondaryColor3iv'))($v);
}

function glSecondaryColor3ivEXT($v) {
  static $proc;
  return ($proc ??= GL::getProcAddress('secondaryColor3ivEXT'))($v);
}

function glSecondaryColor3s(int $red, int $green, int $blue) {
  static $proc;
  return ($proc ??= GL::getProcAddress('secondaryColor3s'))($red, $green, $blue);
}

function glSecondaryColor3sEXT(int $red, int $green, int $blue) {
  static $proc;
  return ($proc ??= GL::getProcAddress('secondaryColor3sEXT'))($red, $green, $blue);
}

function glSecondaryColor3sv($v) {
  static $proc;
  return ($proc ??= GL::getProcAddress('secondaryColor3sv'))($v);
}

function glSecondaryColor3svEXT($v) {
  static $proc;
  return ($proc ??= GL::getProcAddress('secondaryColor3svEXT'))($v);
}

function glSecondaryColor3ub(int $red, int $green, int $blue) {
  static $proc;
  return ($proc ??= GL::getProcAddress('secondaryColor3ub'))($red, $green, $blue);
}

function glSecondaryColor3ubEXT(int $red, int $green, int $blue) {
  static $proc;
  return ($proc ??= GL::getProcAddress('secondaryColor3ubEXT'))($red, $green, $blue);
}

function glSecondaryColor3ubv($v) {
  static $proc;
  return ($proc ??= GL::getProcAddress('secondaryColor3ubv'))($v);
}

function glSecondaryColor3ubvEXT($v) {
  static $proc;
  return ($proc ??= GL::getProcAddress('secondaryColor3ubvEXT'))($v);
}

function glSecondaryColor3ui(int $red, int $green, int $blue) {
  static $proc;
  return ($proc ??= GL::getProcAddress('secondaryColor3ui'))($red, $green, $blue);
}

function glSecondaryColor3uiEXT(int $red, int $green, int $blue) {
  static $proc;
  return ($proc ??= GL::getProcAddress('secondaryColor3uiEXT'))($red, $green, $blue);
}

function glSecondaryColor3uiv($v) {
  static $proc;
  return ($proc ??= GL::getProcAddress('secondaryColor3uiv'))($v);
}

function glSecondaryColor3uivEXT($v) {
  static $proc;
  return ($proc ??= GL::getProcAddress('secondaryColor3uivEXT'))($v);
}

function glSecondaryColor3us(int $red, int $green, int $blue) {
  static $proc;
  return ($proc ??= GL::getProcAddress('secondaryColor3us'))($red, $green, $blue);
}

function glSecondaryColor3usEXT(int $red, int $green, int $blue) {
  static $proc;
  return ($proc ??= GL::getProcAddress('secondaryColor3usEXT'))($red, $green, $blue);
}

function glSecondaryColor3usv($v) {
  static $proc;
  return ($proc ??= GL::getProcAddress('secondaryColor3usv'))($v);
}

function glSecondaryColor3usvEXT($v) {
  static $proc;
  return ($proc ??= GL::getProcAddress('secondaryColor3usvEXT'))($v);
}

function glSecondaryColorFormatNV(int $size, int $type, int $stride) {
  static $proc;
  return ($proc ??= GL::getProcAddress('secondaryColorFormatNV'))($size, $type, $stride);
}

function glSecondaryColorP3ui(int $type, int $color) {
  static $proc;
  return ($proc ??= GL::getProcAddress('secondaryColorP3ui'))($type, $color);
}

function glSecondaryColorP3uiv(int $type, $color) {
  static $proc;
  return ($proc ??= GL::getProcAddress('secondaryColorP3uiv'))($type, $color);
}

function glSecondaryColorPointer(int $size, int $type, int $stride, $pointer) {
  static $proc;
  return ($proc ??= GL::getProcAddress('secondaryColorPointer'))($size, $type, $stride, $pointer);
}

function glSecondaryColorPointerEXT(int $size, int $type, int $stride, $pointer) {
  static $proc;
  return ($proc ??= GL::getProcAddress('secondaryColorPointerEXT'))($size, $type, $stride, $pointer);
}

function glSecondaryColorPointerListIBM(int $size, int $type, int $stride, $pointer, int $ptrstride) {
  static $proc;
  return ($proc ??= GL::getProcAddress('secondaryColorPointerListIBM'))($size, $type, $stride, $pointer, $ptrstride);
}

function glSelectBuffer(int $size, $buffer) {
  static $proc;
  return ($proc ??= GL::getProcAddress('selectBuffer'))($size, $buffer);
}

function glSelectPerfMonitorCountersAMD(int $monitor, int $enable, int $group, int $numCounters, $counterList) {
  static $proc;
  return ($proc ??= GL::getProcAddress('selectPerfMonitorCountersAMD'))($monitor, $enable, $group, $numCounters, $counterList);
}

function glSeparableFilter2D(int $target, int $internalformat, int $width, int $height, int $format, int $type, $row, $column) {
  static $proc;
  return ($proc ??= GL::getProcAddress('separableFilter2D'))($target, $internalformat, $width, $height, $format, $type, $row, $column);
}

function glSeparableFilter2DEXT(int $target, int $internalformat, int $width, int $height, int $format, int $type, $row, $column) {
  static $proc;
  return ($proc ??= GL::getProcAddress('separableFilter2DEXT'))($target, $internalformat, $width, $height, $format, $type, $row, $column);
}

function glSetFenceAPPLE(int $fence) {
  static $proc;
  return ($proc ??= GL::getProcAddress('setFenceAPPLE'))($fence);
}

function glSetFenceNV(int $fence, int $condition) {
  static $proc;
  return ($proc ??= GL::getProcAddress('setFenceNV'))($fence, $condition);
}

function glSetFragmentShaderConstantATI(int $dst, $value) {
  static $proc;
  return ($proc ??= GL::getProcAddress('setFragmentShaderConstantATI'))($dst, $value);
}

function glSetInvariantEXT(int $id, int $type, $addr) {
  static $proc;
  return ($proc ??= GL::getProcAddress('setInvariantEXT'))($id, $type, $addr);
}

function glSetLocalConstantEXT(int $id, int $type, $addr) {
  static $proc;
  return ($proc ??= GL::getProcAddress('setLocalConstantEXT'))($id, $type, $addr);
}

function glSetMultisamplefvAMD(int $pname, int $index, $val) {
  static $proc;
  return ($proc ??= GL::getProcAddress('setMultisamplefvAMD'))($pname, $index, $val);
}

function glShadeModel(int $mode) {
  static $proc;
  return ($proc ??= GL::getProcAddress('shadeModel'))($mode);
}

function glShaderBinary(int $count, $shaders, int $binaryformat, $binary, int $length) {
  static $proc;
  return ($proc ??= GL::getProcAddress('shaderBinary'))($count, $shaders, $binaryformat, $binary, $length);
}

function glShaderOp1EXT(int $op, int $res, int $arg1) {
  static $proc;
  return ($proc ??= GL::getProcAddress('shaderOp1EXT'))($op, $res, $arg1);
}

function glShaderOp2EXT(int $op, int $res, int $arg1, int $arg2) {
  static $proc;
  return ($proc ??= GL::getProcAddress('shaderOp2EXT'))($op, $res, $arg1, $arg2);
}

function glShaderOp3EXT(int $op, int $res, int $arg1, int $arg2, int $arg3) {
  static $proc;
  return ($proc ??= GL::getProcAddress('shaderOp3EXT'))($op, $res, $arg1, $arg2, $arg3);
}

function glShaderSource(int $shader, int $count, $string, $length) {
  static $proc;
  return ($proc ??= GL::getProcAddress('shaderSource'))($shader, $count, $string, $length);
}

function glShaderSourceARB(int $shaderObj, int $count, $string, $length) {
  static $proc;
  return ($proc ??= GL::getProcAddress('shaderSourceARB'))($shaderObj, $count, $string, $length);
}

function glShaderStorageBlockBinding(int $program, int $storageBlockIndex, int $storageBlockBinding) {
  static $proc;
  return ($proc ??= GL::getProcAddress('shaderStorageBlockBinding'))($program, $storageBlockIndex, $storageBlockBinding);
}

function glSharpenTexFuncSGIS(int $target, int $n, $points) {
  static $proc;
  return ($proc ??= GL::getProcAddress('sharpenTexFuncSGIS'))($target, $n, $points);
}

function glSpriteParameterfSGIX(int $pname, float $param) {
  static $proc;
  return ($proc ??= GL::getProcAddress('spriteParameterfSGIX'))($pname, $param);
}

function glSpriteParameterfvSGIX(int $pname, $params) {
  static $proc;
  return ($proc ??= GL::getProcAddress('spriteParameterfvSGIX'))($pname, $params);
}

function glSpriteParameteriSGIX(int $pname, int $param) {
  static $proc;
  return ($proc ??= GL::getProcAddress('spriteParameteriSGIX'))($pname, $param);
}

function glSpriteParameterivSGIX(int $pname, $params) {
  static $proc;
  return ($proc ??= GL::getProcAddress('spriteParameterivSGIX'))($pname, $params);
}

function glStartInstrumentsSGIX() {
  static $proc;
  return ($proc ??= GL::getProcAddress('startInstrumentsSGIX'))();
}

function glStartTilingQCOM(int $x, int $y, int $width, int $height, int $preserveMask) {
  static $proc;
  return ($proc ??= GL::getProcAddress('startTilingQCOM'))($x, $y, $width, $height, $preserveMask);
}

function glStateCaptureNV(int $state, int $mode) {
  static $proc;
  return ($proc ??= GL::getProcAddress('stateCaptureNV'))($state, $mode);
}

function glStencilClearTagEXT(int $stencilTagBits, int $stencilClearTag) {
  static $proc;
  return ($proc ??= GL::getProcAddress('stencilClearTagEXT'))($stencilTagBits, $stencilClearTag);
}

function glStencilFillPathInstancedNV(int $numPaths, int $pathNameType, $paths, int $pathBase, int $fillMode, int $mask, int $transformType, $transformValues) {
  static $proc;
  return ($proc ??= GL::getProcAddress('stencilFillPathInstancedNV'))($numPaths, $pathNameType, $paths, $pathBase, $fillMode, $mask, $transformType, $transformValues);
}

function glStencilFillPathNV(int $path, int $fillMode, int $mask) {
  static $proc;
  return ($proc ??= GL::getProcAddress('stencilFillPathNV'))($path, $fillMode, $mask);
}

function glStencilFunc(int $func, int $ref, int $mask) {
  static $proc;
  return ($proc ??= GL::getProcAddress('stencilFunc'))($func, $ref, $mask);
}

function glStencilFuncSeparate(int $face, int $func, int $ref, int $mask) {
  static $proc;
  return ($proc ??= GL::getProcAddress('stencilFuncSeparate'))($face, $func, $ref, $mask);
}

function glStencilFuncSeparateATI(int $frontfunc, int $backfunc, int $ref, int $mask) {
  static $proc;
  return ($proc ??= GL::getProcAddress('stencilFuncSeparateATI'))($frontfunc, $backfunc, $ref, $mask);
}

function glStencilMask(int $mask) {
  static $proc;
  return ($proc ??= GL::getProcAddress('stencilMask'))($mask);
}

function glStencilMaskSeparate(int $face, int $mask) {
  static $proc;
  return ($proc ??= GL::getProcAddress('stencilMaskSeparate'))($face, $mask);
}

function glStencilOp(int $fail, int $zfail, int $zpass) {
  static $proc;
  return ($proc ??= GL::getProcAddress('stencilOp'))($fail, $zfail, $zpass);
}

function glStencilOpSeparate(int $face, int $sfail, int $dpfail, int $dppass) {
  static $proc;
  return ($proc ??= GL::getProcAddress('stencilOpSeparate'))($face, $sfail, $dpfail, $dppass);
}

function glStencilOpSeparateATI(int $face, int $sfail, int $dpfail, int $dppass) {
  static $proc;
  return ($proc ??= GL::getProcAddress('stencilOpSeparateATI'))($face, $sfail, $dpfail, $dppass);
}

function glStencilOpValueAMD(int $face, int $value) {
  static $proc;
  return ($proc ??= GL::getProcAddress('stencilOpValueAMD'))($face, $value);
}

function glStencilStrokePathInstancedNV(int $numPaths, int $pathNameType, $paths, int $pathBase, int $reference, int $mask, int $transformType, $transformValues) {
  static $proc;
  return ($proc ??= GL::getProcAddress('stencilStrokePathInstancedNV'))($numPaths, $pathNameType, $paths, $pathBase, $reference, $mask, $transformType, $transformValues);
}

function glStencilStrokePathNV(int $path, int $reference, int $mask) {
  static $proc;
  return ($proc ??= GL::getProcAddress('stencilStrokePathNV'))($path, $reference, $mask);
}

function glStencilThenCoverFillPathInstancedNV(int $numPaths, int $pathNameType, $paths, int $pathBase, int $fillMode, int $mask, int $coverMode, int $transformType, $transformValues) {
  static $proc;
  return ($proc ??= GL::getProcAddress('stencilThenCoverFillPathInstancedNV'))($numPaths, $pathNameType, $paths, $pathBase, $fillMode, $mask, $coverMode, $transformType, $transformValues);
}

function glStencilThenCoverFillPathNV(int $path, int $fillMode, int $mask, int $coverMode) {
  static $proc;
  return ($proc ??= GL::getProcAddress('stencilThenCoverFillPathNV'))($path, $fillMode, $mask, $coverMode);
}

function glStencilThenCoverStrokePathInstancedNV(int $numPaths, int $pathNameType, $paths, int $pathBase, int $reference, int $mask, int $coverMode, int $transformType, $transformValues) {
  static $proc;
  return ($proc ??= GL::getProcAddress('stencilThenCoverStrokePathInstancedNV'))($numPaths, $pathNameType, $paths, $pathBase, $reference, $mask, $coverMode, $transformType, $transformValues);
}

function glStencilThenCoverStrokePathNV(int $path, int $reference, int $mask, int $coverMode) {
  static $proc;
  return ($proc ??= GL::getProcAddress('stencilThenCoverStrokePathNV'))($path, $reference, $mask, $coverMode);
}

function glStopInstrumentsSGIX(int $marker) {
  static $proc;
  return ($proc ??= GL::getProcAddress('stopInstrumentsSGIX'))($marker);
}

function glStringMarkerGREMEDY(int $len, $string) {
  static $proc;
  return ($proc ??= GL::getProcAddress('stringMarkerGREMEDY'))($len, $string);
}

function glSubpixelPrecisionBiasNV(int $xbits, int $ybits) {
  static $proc;
  return ($proc ??= GL::getProcAddress('subpixelPrecisionBiasNV'))($xbits, $ybits);
}

function glSwizzleEXT(int $res, int $in, int $outX, int $outY, int $outZ, int $outW) {
  static $proc;
  return ($proc ??= GL::getProcAddress('swizzleEXT'))($res, $in, $outX, $outY, $outZ, $outW);
}

function glSyncTextureINTEL(int $texture) {
  static $proc;
  return ($proc ??= GL::getProcAddress('syncTextureINTEL'))($texture);
}

function glTagSampleBufferSGIX() {
  static $proc;
  return ($proc ??= GL::getProcAddress('tagSampleBufferSGIX'))();
}

function glTangent3bEXT(int $tx, int $ty, int $tz) {
  static $proc;
  return ($proc ??= GL::getProcAddress('tangent3bEXT'))($tx, $ty, $tz);
}

function glTangent3bvEXT($v) {
  static $proc;
  return ($proc ??= GL::getProcAddress('tangent3bvEXT'))($v);
}

function glTangent3dEXT(float $tx, float $ty, float $tz) {
  static $proc;
  return ($proc ??= GL::getProcAddress('tangent3dEXT'))($tx, $ty, $tz);
}

function glTangent3dvEXT($v) {
  static $proc;
  return ($proc ??= GL::getProcAddress('tangent3dvEXT'))($v);
}

function glTangent3fEXT(float $tx, float $ty, float $tz) {
  static $proc;
  return ($proc ??= GL::getProcAddress('tangent3fEXT'))($tx, $ty, $tz);
}

function glTangent3fvEXT($v) {
  static $proc;
  return ($proc ??= GL::getProcAddress('tangent3fvEXT'))($v);
}

function glTangent3iEXT(int $tx, int $ty, int $tz) {
  static $proc;
  return ($proc ??= GL::getProcAddress('tangent3iEXT'))($tx, $ty, $tz);
}

function glTangent3ivEXT($v) {
  static $proc;
  return ($proc ??= GL::getProcAddress('tangent3ivEXT'))($v);
}

function glTangent3sEXT(int $tx, int $ty, int $tz) {
  static $proc;
  return ($proc ??= GL::getProcAddress('tangent3sEXT'))($tx, $ty, $tz);
}

function glTangent3svEXT($v) {
  static $proc;
  return ($proc ??= GL::getProcAddress('tangent3svEXT'))($v);
}

function glTangentPointerEXT(int $type, int $stride, $pointer) {
  static $proc;
  return ($proc ??= GL::getProcAddress('tangentPointerEXT'))($type, $stride, $pointer);
}

function glTbufferMask3DFX(int $mask) {
  static $proc;
  return ($proc ??= GL::getProcAddress('tbufferMask3DFX'))($mask);
}

function glTessellationFactorAMD(float $factor) {
  static $proc;
  return ($proc ??= GL::getProcAddress('tessellationFactorAMD'))($factor);
}

function glTessellationModeAMD(int $mode) {
  static $proc;
  return ($proc ??= GL::getProcAddress('tessellationModeAMD'))($mode);
}

function glTestFenceAPPLE(int $fence) {
  static $proc;
  return ($proc ??= GL::getProcAddress('testFenceAPPLE'))($fence);
}

function glTestFenceNV(int $fence) {
  static $proc;
  return ($proc ??= GL::getProcAddress('testFenceNV'))($fence);
}

function glTestObjectAPPLE(int $object, int $name) {
  static $proc;
  return ($proc ??= GL::getProcAddress('testObjectAPPLE'))($object, $name);
}

function glTexBuffer(int $target, int $internalformat, int $buffer) {
  static $proc;
  return ($proc ??= GL::getProcAddress('texBuffer'))($target, $internalformat, $buffer);
}

function glTexBufferARB(int $target, int $internalformat, int $buffer) {
  static $proc;
  return ($proc ??= GL::getProcAddress('texBufferARB'))($target, $internalformat, $buffer);
}

function glTexBufferEXT(int $target, int $internalformat, int $buffer) {
  static $proc;
  return ($proc ??= GL::getProcAddress('texBufferEXT'))($target, $internalformat, $buffer);
}

function glTexBufferOES(int $target, int $internalformat, int $buffer) {
  static $proc;
  return ($proc ??= GL::getProcAddress('texBufferOES'))($target, $internalformat, $buffer);
}

function glTexBufferRange(int $target, int $internalformat, int $buffer, int $offset, int $size) {
  static $proc;
  return ($proc ??= GL::getProcAddress('texBufferRange'))($target, $internalformat, $buffer, $offset, $size);
}

function glTexBufferRangeEXT(int $target, int $internalformat, int $buffer, int $offset, int $size) {
  static $proc;
  return ($proc ??= GL::getProcAddress('texBufferRangeEXT'))($target, $internalformat, $buffer, $offset, $size);
}

function glTexBufferRangeOES(int $target, int $internalformat, int $buffer, int $offset, int $size) {
  static $proc;
  return ($proc ??= GL::getProcAddress('texBufferRangeOES'))($target, $internalformat, $buffer, $offset, $size);
}

function glTexBumpParameterfvATI(int $pname, $param) {
  static $proc;
  return ($proc ??= GL::getProcAddress('texBumpParameterfvATI'))($pname, $param);
}

function glTexBumpParameterivATI(int $pname, $param) {
  static $proc;
  return ($proc ??= GL::getProcAddress('texBumpParameterivATI'))($pname, $param);
}

function glTexCoord1bOES(int $s) {
  static $proc;
  return ($proc ??= GL::getProcAddress('texCoord1bOES'))($s);
}

function glTexCoord1bvOES($coords) {
  static $proc;
  return ($proc ??= GL::getProcAddress('texCoord1bvOES'))($coords);
}

function glTexCoord1d(float $s) {
  static $proc;
  return ($proc ??= GL::getProcAddress('texCoord1d'))($s);
}

function glTexCoord1dv($v) {
  static $proc;
  return ($proc ??= GL::getProcAddress('texCoord1dv'))($v);
}

function glTexCoord1f(float $s) {
  static $proc;
  return ($proc ??= GL::getProcAddress('texCoord1f'))($s);
}

function glTexCoord1fv($v) {
  static $proc;
  return ($proc ??= GL::getProcAddress('texCoord1fv'))($v);
}

function glTexCoord1hNV(int $s) {
  static $proc;
  return ($proc ??= GL::getProcAddress('texCoord1hNV'))($s);
}

function glTexCoord1hvNV($v) {
  static $proc;
  return ($proc ??= GL::getProcAddress('texCoord1hvNV'))($v);
}

function glTexCoord1i(int $s) {
  static $proc;
  return ($proc ??= GL::getProcAddress('texCoord1i'))($s);
}

function glTexCoord1iv($v) {
  static $proc;
  return ($proc ??= GL::getProcAddress('texCoord1iv'))($v);
}

function glTexCoord1s(int $s) {
  static $proc;
  return ($proc ??= GL::getProcAddress('texCoord1s'))($s);
}

function glTexCoord1sv($v) {
  static $proc;
  return ($proc ??= GL::getProcAddress('texCoord1sv'))($v);
}

function glTexCoord1xOES(int $s) {
  static $proc;
  return ($proc ??= GL::getProcAddress('texCoord1xOES'))($s);
}

function glTexCoord1xvOES($coords) {
  static $proc;
  return ($proc ??= GL::getProcAddress('texCoord1xvOES'))($coords);
}

function glTexCoord2bOES(int $s, int $t) {
  static $proc;
  return ($proc ??= GL::getProcAddress('texCoord2bOES'))($s, $t);
}

function glTexCoord2bvOES($coords) {
  static $proc;
  return ($proc ??= GL::getProcAddress('texCoord2bvOES'))($coords);
}

function glTexCoord2d(float $s, float $t) {
  static $proc;
  return ($proc ??= GL::getProcAddress('texCoord2d'))($s, $t);
}

function glTexCoord2dv($v) {
  static $proc;
  return ($proc ??= GL::getProcAddress('texCoord2dv'))($v);
}

function glTexCoord2f(float $s, float $t) {
  static $proc;
  return ($proc ??= GL::getProcAddress('texCoord2f'))($s, $t);
}

function glTexCoord2fColor3fVertex3fSUN(float $s, float $t, float $r, float $g, float $b, float $x, float $y, float $z) {
  static $proc;
  return ($proc ??= GL::getProcAddress('texCoord2fColor3fVertex3fSUN'))($s, $t, $r, $g, $b, $x, $y, $z);
}

function glTexCoord2fColor3fVertex3fvSUN($tc, $c, $v) {
  static $proc;
  return ($proc ??= GL::getProcAddress('texCoord2fColor3fVertex3fvSUN'))($tc, $c, $v);
}

function glTexCoord2fColor4fNormal3fVertex3fSUN(float $s, float $t, float $r, float $g, float $b, float $a, float $nx, float $ny, float $nz, float $x, float $y, float $z) {
  static $proc;
  return ($proc ??= GL::getProcAddress('texCoord2fColor4fNormal3fVertex3fSUN'))($s, $t, $r, $g, $b, $a, $nx, $ny, $nz, $x, $y, $z);
}

function glTexCoord2fColor4fNormal3fVertex3fvSUN($tc, $c, $n, $v) {
  static $proc;
  return ($proc ??= GL::getProcAddress('texCoord2fColor4fNormal3fVertex3fvSUN'))($tc, $c, $n, $v);
}

function glTexCoord2fColor4ubVertex3fSUN(float $s, float $t, int $r, int $g, int $b, int $a, float $x, float $y, float $z) {
  static $proc;
  return ($proc ??= GL::getProcAddress('texCoord2fColor4ubVertex3fSUN'))($s, $t, $r, $g, $b, $a, $x, $y, $z);
}

function glTexCoord2fColor4ubVertex3fvSUN($tc, $c, $v) {
  static $proc;
  return ($proc ??= GL::getProcAddress('texCoord2fColor4ubVertex3fvSUN'))($tc, $c, $v);
}

function glTexCoord2fNormal3fVertex3fSUN(float $s, float $t, float $nx, float $ny, float $nz, float $x, float $y, float $z) {
  static $proc;
  return ($proc ??= GL::getProcAddress('texCoord2fNormal3fVertex3fSUN'))($s, $t, $nx, $ny, $nz, $x, $y, $z);
}

function glTexCoord2fNormal3fVertex3fvSUN($tc, $n, $v) {
  static $proc;
  return ($proc ??= GL::getProcAddress('texCoord2fNormal3fVertex3fvSUN'))($tc, $n, $v);
}

function glTexCoord2fVertex3fSUN(float $s, float $t, float $x, float $y, float $z) {
  static $proc;
  return ($proc ??= GL::getProcAddress('texCoord2fVertex3fSUN'))($s, $t, $x, $y, $z);
}

function glTexCoord2fVertex3fvSUN($tc, $v) {
  static $proc;
  return ($proc ??= GL::getProcAddress('texCoord2fVertex3fvSUN'))($tc, $v);
}

function glTexCoord2fv($v) {
  static $proc;
  return ($proc ??= GL::getProcAddress('texCoord2fv'))($v);
}

function glTexCoord2hNV(int $s, int $t) {
  static $proc;
  return ($proc ??= GL::getProcAddress('texCoord2hNV'))($s, $t);
}

function glTexCoord2hvNV($v) {
  static $proc;
  return ($proc ??= GL::getProcAddress('texCoord2hvNV'))($v);
}

function glTexCoord2i(int $s, int $t) {
  static $proc;
  return ($proc ??= GL::getProcAddress('texCoord2i'))($s, $t);
}

function glTexCoord2iv($v) {
  static $proc;
  return ($proc ??= GL::getProcAddress('texCoord2iv'))($v);
}

function glTexCoord2s(int $s, int $t) {
  static $proc;
  return ($proc ??= GL::getProcAddress('texCoord2s'))($s, $t);
}

function glTexCoord2sv($v) {
  static $proc;
  return ($proc ??= GL::getProcAddress('texCoord2sv'))($v);
}

function glTexCoord2xOES(int $s, int $t) {
  static $proc;
  return ($proc ??= GL::getProcAddress('texCoord2xOES'))($s, $t);
}

function glTexCoord2xvOES($coords) {
  static $proc;
  return ($proc ??= GL::getProcAddress('texCoord2xvOES'))($coords);
}

function glTexCoord3bOES(int $s, int $t, int $r) {
  static $proc;
  return ($proc ??= GL::getProcAddress('texCoord3bOES'))($s, $t, $r);
}

function glTexCoord3bvOES($coords) {
  static $proc;
  return ($proc ??= GL::getProcAddress('texCoord3bvOES'))($coords);
}

function glTexCoord3d(float $s, float $t, float $r) {
  static $proc;
  return ($proc ??= GL::getProcAddress('texCoord3d'))($s, $t, $r);
}

function glTexCoord3dv($v) {
  static $proc;
  return ($proc ??= GL::getProcAddress('texCoord3dv'))($v);
}

function glTexCoord3f(float $s, float $t, float $r) {
  static $proc;
  return ($proc ??= GL::getProcAddress('texCoord3f'))($s, $t, $r);
}

function glTexCoord3fv($v) {
  static $proc;
  return ($proc ??= GL::getProcAddress('texCoord3fv'))($v);
}

function glTexCoord3hNV(int $s, int $t, int $r) {
  static $proc;
  return ($proc ??= GL::getProcAddress('texCoord3hNV'))($s, $t, $r);
}

function glTexCoord3hvNV($v) {
  static $proc;
  return ($proc ??= GL::getProcAddress('texCoord3hvNV'))($v);
}

function glTexCoord3i(int $s, int $t, int $r) {
  static $proc;
  return ($proc ??= GL::getProcAddress('texCoord3i'))($s, $t, $r);
}

function glTexCoord3iv($v) {
  static $proc;
  return ($proc ??= GL::getProcAddress('texCoord3iv'))($v);
}

function glTexCoord3s(int $s, int $t, int $r) {
  static $proc;
  return ($proc ??= GL::getProcAddress('texCoord3s'))($s, $t, $r);
}

function glTexCoord3sv($v) {
  static $proc;
  return ($proc ??= GL::getProcAddress('texCoord3sv'))($v);
}

function glTexCoord3xOES(int $s, int $t, int $r) {
  static $proc;
  return ($proc ??= GL::getProcAddress('texCoord3xOES'))($s, $t, $r);
}

function glTexCoord3xvOES($coords) {
  static $proc;
  return ($proc ??= GL::getProcAddress('texCoord3xvOES'))($coords);
}

function glTexCoord4bOES(int $s, int $t, int $r, int $q) {
  static $proc;
  return ($proc ??= GL::getProcAddress('texCoord4bOES'))($s, $t, $r, $q);
}

function glTexCoord4bvOES($coords) {
  static $proc;
  return ($proc ??= GL::getProcAddress('texCoord4bvOES'))($coords);
}

function glTexCoord4d(float $s, float $t, float $r, float $q) {
  static $proc;
  return ($proc ??= GL::getProcAddress('texCoord4d'))($s, $t, $r, $q);
}

function glTexCoord4dv($v) {
  static $proc;
  return ($proc ??= GL::getProcAddress('texCoord4dv'))($v);
}

function glTexCoord4f(float $s, float $t, float $r, float $q) {
  static $proc;
  return ($proc ??= GL::getProcAddress('texCoord4f'))($s, $t, $r, $q);
}

function glTexCoord4fColor4fNormal3fVertex4fSUN(float $s, float $t, float $p, float $q, float $r, float $g, float $b, float $a, float $nx, float $ny, float $nz, float $x, float $y, float $z, float $w) {
  static $proc;
  return ($proc ??= GL::getProcAddress('texCoord4fColor4fNormal3fVertex4fSUN'))($s, $t, $p, $q, $r, $g, $b, $a, $nx, $ny, $nz, $x, $y, $z, $w);
}

function glTexCoord4fColor4fNormal3fVertex4fvSUN($tc, $c, $n, $v) {
  static $proc;
  return ($proc ??= GL::getProcAddress('texCoord4fColor4fNormal3fVertex4fvSUN'))($tc, $c, $n, $v);
}

function glTexCoord4fVertex4fSUN(float $s, float $t, float $p, float $q, float $x, float $y, float $z, float $w) {
  static $proc;
  return ($proc ??= GL::getProcAddress('texCoord4fVertex4fSUN'))($s, $t, $p, $q, $x, $y, $z, $w);
}

function glTexCoord4fVertex4fvSUN($tc, $v) {
  static $proc;
  return ($proc ??= GL::getProcAddress('texCoord4fVertex4fvSUN'))($tc, $v);
}

function glTexCoord4fv($v) {
  static $proc;
  return ($proc ??= GL::getProcAddress('texCoord4fv'))($v);
}

function glTexCoord4hNV(int $s, int $t, int $r, int $q) {
  static $proc;
  return ($proc ??= GL::getProcAddress('texCoord4hNV'))($s, $t, $r, $q);
}

function glTexCoord4hvNV($v) {
  static $proc;
  return ($proc ??= GL::getProcAddress('texCoord4hvNV'))($v);
}

function glTexCoord4i(int $s, int $t, int $r, int $q) {
  static $proc;
  return ($proc ??= GL::getProcAddress('texCoord4i'))($s, $t, $r, $q);
}

function glTexCoord4iv($v) {
  static $proc;
  return ($proc ??= GL::getProcAddress('texCoord4iv'))($v);
}

function glTexCoord4s(int $s, int $t, int $r, int $q) {
  static $proc;
  return ($proc ??= GL::getProcAddress('texCoord4s'))($s, $t, $r, $q);
}

function glTexCoord4sv($v) {
  static $proc;
  return ($proc ??= GL::getProcAddress('texCoord4sv'))($v);
}

function glTexCoord4xOES(int $s, int $t, int $r, int $q) {
  static $proc;
  return ($proc ??= GL::getProcAddress('texCoord4xOES'))($s, $t, $r, $q);
}

function glTexCoord4xvOES($coords) {
  static $proc;
  return ($proc ??= GL::getProcAddress('texCoord4xvOES'))($coords);
}

function glTexCoordFormatNV(int $size, int $type, int $stride) {
  static $proc;
  return ($proc ??= GL::getProcAddress('texCoordFormatNV'))($size, $type, $stride);
}

function glTexCoordP1ui(int $type, int $coords) {
  static $proc;
  return ($proc ??= GL::getProcAddress('texCoordP1ui'))($type, $coords);
}

function glTexCoordP1uiv(int $type, $coords) {
  static $proc;
  return ($proc ??= GL::getProcAddress('texCoordP1uiv'))($type, $coords);
}

function glTexCoordP2ui(int $type, int $coords) {
  static $proc;
  return ($proc ??= GL::getProcAddress('texCoordP2ui'))($type, $coords);
}

function glTexCoordP2uiv(int $type, $coords) {
  static $proc;
  return ($proc ??= GL::getProcAddress('texCoordP2uiv'))($type, $coords);
}

function glTexCoordP3ui(int $type, int $coords) {
  static $proc;
  return ($proc ??= GL::getProcAddress('texCoordP3ui'))($type, $coords);
}

function glTexCoordP3uiv(int $type, $coords) {
  static $proc;
  return ($proc ??= GL::getProcAddress('texCoordP3uiv'))($type, $coords);
}

function glTexCoordP4ui(int $type, int $coords) {
  static $proc;
  return ($proc ??= GL::getProcAddress('texCoordP4ui'))($type, $coords);
}

function glTexCoordP4uiv(int $type, $coords) {
  static $proc;
  return ($proc ??= GL::getProcAddress('texCoordP4uiv'))($type, $coords);
}

function glTexCoordPointer(int $size, int $type, int $stride, $pointer) {
  static $proc;
  return ($proc ??= GL::getProcAddress('texCoordPointer'))($size, $type, $stride, $pointer);
}

function glTexCoordPointerEXT(int $size, int $type, int $stride, int $count, $pointer) {
  static $proc;
  return ($proc ??= GL::getProcAddress('texCoordPointerEXT'))($size, $type, $stride, $count, $pointer);
}

function glTexCoordPointerListIBM(int $size, int $type, int $stride, $pointer, int $ptrstride) {
  static $proc;
  return ($proc ??= GL::getProcAddress('texCoordPointerListIBM'))($size, $type, $stride, $pointer, $ptrstride);
}

function glTexCoordPointervINTEL(int $size, int $type, $pointer) {
  static $proc;
  return ($proc ??= GL::getProcAddress('texCoordPointervINTEL'))($size, $type, $pointer);
}

function glTexEnvf(int $target, int $pname, float $param) {
  static $proc;
  return ($proc ??= GL::getProcAddress('texEnvf'))($target, $pname, $param);
}

function glTexEnvfv(int $target, int $pname, $params) {
  static $proc;
  return ($proc ??= GL::getProcAddress('texEnvfv'))($target, $pname, $params);
}

function glTexEnvi(int $target, int $pname, int $param) {
  static $proc;
  return ($proc ??= GL::getProcAddress('texEnvi'))($target, $pname, $param);
}

function glTexEnviv(int $target, int $pname, $params) {
  static $proc;
  return ($proc ??= GL::getProcAddress('texEnviv'))($target, $pname, $params);
}

function glTexEnvx(int $target, int $pname, int $param) {
  static $proc;
  return ($proc ??= GL::getProcAddress('texEnvx'))($target, $pname, $param);
}

function glTexEnvxOES(int $target, int $pname, int $param) {
  static $proc;
  return ($proc ??= GL::getProcAddress('texEnvxOES'))($target, $pname, $param);
}

function glTexEnvxv(int $target, int $pname, $params) {
  static $proc;
  return ($proc ??= GL::getProcAddress('texEnvxv'))($target, $pname, $params);
}

function glTexEnvxvOES(int $target, int $pname, $params) {
  static $proc;
  return ($proc ??= GL::getProcAddress('texEnvxvOES'))($target, $pname, $params);
}

function glTexFilterFuncSGIS(int $target, int $filter, int $n, $weights) {
  static $proc;
  return ($proc ??= GL::getProcAddress('texFilterFuncSGIS'))($target, $filter, $n, $weights);
}

function glTexGend(int $coord, int $pname, float $param) {
  static $proc;
  return ($proc ??= GL::getProcAddress('texGend'))($coord, $pname, $param);
}

function glTexGendv(int $coord, int $pname, $params) {
  static $proc;
  return ($proc ??= GL::getProcAddress('texGendv'))($coord, $pname, $params);
}

function glTexGenf(int $coord, int $pname, float $param) {
  static $proc;
  return ($proc ??= GL::getProcAddress('texGenf'))($coord, $pname, $param);
}

function glTexGenfOES(int $coord, int $pname, float $param) {
  static $proc;
  return ($proc ??= GL::getProcAddress('texGenfOES'))($coord, $pname, $param);
}

function glTexGenfv(int $coord, int $pname, $params) {
  static $proc;
  return ($proc ??= GL::getProcAddress('texGenfv'))($coord, $pname, $params);
}

function glTexGenfvOES(int $coord, int $pname, $params) {
  static $proc;
  return ($proc ??= GL::getProcAddress('texGenfvOES'))($coord, $pname, $params);
}

function glTexGeni(int $coord, int $pname, int $param) {
  static $proc;
  return ($proc ??= GL::getProcAddress('texGeni'))($coord, $pname, $param);
}

function glTexGeniOES(int $coord, int $pname, int $param) {
  static $proc;
  return ($proc ??= GL::getProcAddress('texGeniOES'))($coord, $pname, $param);
}

function glTexGeniv(int $coord, int $pname, $params) {
  static $proc;
  return ($proc ??= GL::getProcAddress('texGeniv'))($coord, $pname, $params);
}

function glTexGenivOES(int $coord, int $pname, $params) {
  static $proc;
  return ($proc ??= GL::getProcAddress('texGenivOES'))($coord, $pname, $params);
}

function glTexGenxOES(int $coord, int $pname, int $param) {
  static $proc;
  return ($proc ??= GL::getProcAddress('texGenxOES'))($coord, $pname, $param);
}

function glTexGenxvOES(int $coord, int $pname, $params) {
  static $proc;
  return ($proc ??= GL::getProcAddress('texGenxvOES'))($coord, $pname, $params);
}

function glTexImage1D(int $target, int $level, int $internalformat, int $width, int $border, int $format, int $type, $pixels) {
  static $proc;
  return ($proc ??= GL::getProcAddress('texImage1D'))($target, $level, $internalformat, $width, $border, $format, $type, $pixels);
}

function glTexImage2D(int $target, int $level, int $internalformat, int $width, int $height, int $border, int $format, int $type, $pixels) {
  static $proc;
  return ($proc ??= GL::getProcAddress('texImage2D'))($target, $level, $internalformat, $width, $height, $border, $format, $type, $pixels);
}

function glTexImage2DMultisample(int $target, int $samples, int $internalformat, int $width, int $height, int $fixedsamplelocations) {
  static $proc;
  return ($proc ??= GL::getProcAddress('texImage2DMultisample'))($target, $samples, $internalformat, $width, $height, $fixedsamplelocations);
}

function glTexImage2DMultisampleCoverageNV(int $target, int $coverageSamples, int $colorSamples, int $internalFormat, int $width, int $height, int $fixedSampleLocations) {
  static $proc;
  return ($proc ??= GL::getProcAddress('texImage2DMultisampleCoverageNV'))($target, $coverageSamples, $colorSamples, $internalFormat, $width, $height, $fixedSampleLocations);
}

function glTexImage3D(int $target, int $level, int $internalformat, int $width, int $height, int $depth, int $border, int $format, int $type, $pixels) {
  static $proc;
  return ($proc ??= GL::getProcAddress('texImage3D'))($target, $level, $internalformat, $width, $height, $depth, $border, $format, $type, $pixels);
}

function glTexImage3DEXT(int $target, int $level, int $internalformat, int $width, int $height, int $depth, int $border, int $format, int $type, $pixels) {
  static $proc;
  return ($proc ??= GL::getProcAddress('texImage3DEXT'))($target, $level, $internalformat, $width, $height, $depth, $border, $format, $type, $pixels);
}

function glTexImage3DMultisample(int $target, int $samples, int $internalformat, int $width, int $height, int $depth, int $fixedsamplelocations) {
  static $proc;
  return ($proc ??= GL::getProcAddress('texImage3DMultisample'))($target, $samples, $internalformat, $width, $height, $depth, $fixedsamplelocations);
}

function glTexImage3DMultisampleCoverageNV(int $target, int $coverageSamples, int $colorSamples, int $internalFormat, int $width, int $height, int $depth, int $fixedSampleLocations) {
  static $proc;
  return ($proc ??= GL::getProcAddress('texImage3DMultisampleCoverageNV'))($target, $coverageSamples, $colorSamples, $internalFormat, $width, $height, $depth, $fixedSampleLocations);
}

function glTexImage3DOES(int $target, int $level, int $internalformat, int $width, int $height, int $depth, int $border, int $format, int $type, $pixels) {
  static $proc;
  return ($proc ??= GL::getProcAddress('texImage3DOES'))($target, $level, $internalformat, $width, $height, $depth, $border, $format, $type, $pixels);
}

function glTexImage4DSGIS(int $target, int $level, int $internalformat, int $width, int $height, int $depth, int $size4d, int $border, int $format, int $type, $pixels) {
  static $proc;
  return ($proc ??= GL::getProcAddress('texImage4DSGIS'))($target, $level, $internalformat, $width, $height, $depth, $size4d, $border, $format, $type, $pixels);
}

function glTexPageCommitmentARB(int $target, int $level, int $xoffset, int $yoffset, int $zoffset, int $width, int $height, int $depth, int $commit) {
  static $proc;
  return ($proc ??= GL::getProcAddress('texPageCommitmentARB'))($target, $level, $xoffset, $yoffset, $zoffset, $width, $height, $depth, $commit);
}

function glTexPageCommitmentEXT(int $target, int $level, int $xoffset, int $yoffset, int $zoffset, int $width, int $height, int $depth, int $commit) {
  static $proc;
  return ($proc ??= GL::getProcAddress('texPageCommitmentEXT'))($target, $level, $xoffset, $yoffset, $zoffset, $width, $height, $depth, $commit);
}

function glTexParameterIiv(int $target, int $pname, $params) {
  static $proc;
  return ($proc ??= GL::getProcAddress('texParameterIiv'))($target, $pname, $params);
}

function glTexParameterIivEXT(int $target, int $pname, $params) {
  static $proc;
  return ($proc ??= GL::getProcAddress('texParameterIivEXT'))($target, $pname, $params);
}

function glTexParameterIivOES(int $target, int $pname, $params) {
  static $proc;
  return ($proc ??= GL::getProcAddress('texParameterIivOES'))($target, $pname, $params);
}

function glTexParameterIuiv(int $target, int $pname, $params) {
  static $proc;
  return ($proc ??= GL::getProcAddress('texParameterIuiv'))($target, $pname, $params);
}

function glTexParameterIuivEXT(int $target, int $pname, $params) {
  static $proc;
  return ($proc ??= GL::getProcAddress('texParameterIuivEXT'))($target, $pname, $params);
}

function glTexParameterIuivOES(int $target, int $pname, $params) {
  static $proc;
  return ($proc ??= GL::getProcAddress('texParameterIuivOES'))($target, $pname, $params);
}

function glTexParameterf(int $target, int $pname, float $param) {
  static $proc;
  return ($proc ??= GL::getProcAddress('texParameterf'))($target, $pname, $param);
}

function glTexParameterfv(int $target, int $pname, $params) {
  static $proc;
  return ($proc ??= GL::getProcAddress('texParameterfv'))($target, $pname, $params);
}

function glTexParameteri(int $target, int $pname, int $param) {
  static $proc;
  return ($proc ??= GL::getProcAddress('texParameteri'))($target, $pname, $param);
}

function glTexParameteriv(int $target, int $pname, $params) {
  static $proc;
  return ($proc ??= GL::getProcAddress('texParameteriv'))($target, $pname, $params);
}

function glTexParameterx(int $target, int $pname, int $param) {
  static $proc;
  return ($proc ??= GL::getProcAddress('texParameterx'))($target, $pname, $param);
}

function glTexParameterxOES(int $target, int $pname, int $param) {
  static $proc;
  return ($proc ??= GL::getProcAddress('texParameterxOES'))($target, $pname, $param);
}

function glTexParameterxv(int $target, int $pname, $params) {
  static $proc;
  return ($proc ??= GL::getProcAddress('texParameterxv'))($target, $pname, $params);
}

function glTexParameterxvOES(int $target, int $pname, $params) {
  static $proc;
  return ($proc ??= GL::getProcAddress('texParameterxvOES'))($target, $pname, $params);
}

function glTexRenderbufferNV(int $target, int $renderbuffer) {
  static $proc;
  return ($proc ??= GL::getProcAddress('texRenderbufferNV'))($target, $renderbuffer);
}

function glTexStorage1D(int $target, int $levels, int $internalformat, int $width) {
  static $proc;
  return ($proc ??= GL::getProcAddress('texStorage1D'))($target, $levels, $internalformat, $width);
}

function glTexStorage1DEXT(int $target, int $levels, int $internalformat, int $width) {
  static $proc;
  return ($proc ??= GL::getProcAddress('texStorage1DEXT'))($target, $levels, $internalformat, $width);
}

function glTexStorage2D(int $target, int $levels, int $internalformat, int $width, int $height) {
  static $proc;
  return ($proc ??= GL::getProcAddress('texStorage2D'))($target, $levels, $internalformat, $width, $height);
}

function glTexStorage2DEXT(int $target, int $levels, int $internalformat, int $width, int $height) {
  static $proc;
  return ($proc ??= GL::getProcAddress('texStorage2DEXT'))($target, $levels, $internalformat, $width, $height);
}

function glTexStorage2DMultisample(int $target, int $samples, int $internalformat, int $width, int $height, int $fixedsamplelocations) {
  static $proc;
  return ($proc ??= GL::getProcAddress('texStorage2DMultisample'))($target, $samples, $internalformat, $width, $height, $fixedsamplelocations);
}

function glTexStorage3D(int $target, int $levels, int $internalformat, int $width, int $height, int $depth) {
  static $proc;
  return ($proc ??= GL::getProcAddress('texStorage3D'))($target, $levels, $internalformat, $width, $height, $depth);
}

function glTexStorage3DEXT(int $target, int $levels, int $internalformat, int $width, int $height, int $depth) {
  static $proc;
  return ($proc ??= GL::getProcAddress('texStorage3DEXT'))($target, $levels, $internalformat, $width, $height, $depth);
}

function glTexStorage3DMultisample(int $target, int $samples, int $internalformat, int $width, int $height, int $depth, int $fixedsamplelocations) {
  static $proc;
  return ($proc ??= GL::getProcAddress('texStorage3DMultisample'))($target, $samples, $internalformat, $width, $height, $depth, $fixedsamplelocations);
}

function glTexStorage3DMultisampleOES(int $target, int $samples, int $internalformat, int $width, int $height, int $depth, int $fixedsamplelocations) {
  static $proc;
  return ($proc ??= GL::getProcAddress('texStorage3DMultisampleOES'))($target, $samples, $internalformat, $width, $height, $depth, $fixedsamplelocations);
}

function glTexStorageSparseAMD(int $target, int $internalFormat, int $width, int $height, int $depth, int $layers, int $flags) {
  static $proc;
  return ($proc ??= GL::getProcAddress('texStorageSparseAMD'))($target, $internalFormat, $width, $height, $depth, $layers, $flags);
}

function glTexSubImage1D(int $target, int $level, int $xoffset, int $width, int $format, int $type, $pixels) {
  static $proc;
  return ($proc ??= GL::getProcAddress('texSubImage1D'))($target, $level, $xoffset, $width, $format, $type, $pixels);
}

function glTexSubImage1DEXT(int $target, int $level, int $xoffset, int $width, int $format, int $type, $pixels) {
  static $proc;
  return ($proc ??= GL::getProcAddress('texSubImage1DEXT'))($target, $level, $xoffset, $width, $format, $type, $pixels);
}

function glTexSubImage2D(int $target, int $level, int $xoffset, int $yoffset, int $width, int $height, int $format, int $type, $pixels) {
  static $proc;
  return ($proc ??= GL::getProcAddress('texSubImage2D'))($target, $level, $xoffset, $yoffset, $width, $height, $format, $type, $pixels);
}

function glTexSubImage2DEXT(int $target, int $level, int $xoffset, int $yoffset, int $width, int $height, int $format, int $type, $pixels) {
  static $proc;
  return ($proc ??= GL::getProcAddress('texSubImage2DEXT'))($target, $level, $xoffset, $yoffset, $width, $height, $format, $type, $pixels);
}

function glTexSubImage3D(int $target, int $level, int $xoffset, int $yoffset, int $zoffset, int $width, int $height, int $depth, int $format, int $type, $pixels) {
  static $proc;
  return ($proc ??= GL::getProcAddress('texSubImage3D'))($target, $level, $xoffset, $yoffset, $zoffset, $width, $height, $depth, $format, $type, $pixels);
}

function glTexSubImage3DEXT(int $target, int $level, int $xoffset, int $yoffset, int $zoffset, int $width, int $height, int $depth, int $format, int $type, $pixels) {
  static $proc;
  return ($proc ??= GL::getProcAddress('texSubImage3DEXT'))($target, $level, $xoffset, $yoffset, $zoffset, $width, $height, $depth, $format, $type, $pixels);
}

function glTexSubImage3DOES(int $target, int $level, int $xoffset, int $yoffset, int $zoffset, int $width, int $height, int $depth, int $format, int $type, $pixels) {
  static $proc;
  return ($proc ??= GL::getProcAddress('texSubImage3DOES'))($target, $level, $xoffset, $yoffset, $zoffset, $width, $height, $depth, $format, $type, $pixels);
}

function glTexSubImage4DSGIS(int $target, int $level, int $xoffset, int $yoffset, int $zoffset, int $woffset, int $width, int $height, int $depth, int $size4d, int $format, int $type, $pixels) {
  static $proc;
  return ($proc ??= GL::getProcAddress('texSubImage4DSGIS'))($target, $level, $xoffset, $yoffset, $zoffset, $woffset, $width, $height, $depth, $size4d, $format, $type, $pixels);
}

function glTextureBarrier() {
  static $proc;
  return ($proc ??= GL::getProcAddress('textureBarrier'))();
}

function glTextureBarrierNV() {
  static $proc;
  return ($proc ??= GL::getProcAddress('textureBarrierNV'))();
}

function glTextureBuffer(int $texture, int $internalformat, int $buffer) {
  static $proc;
  return ($proc ??= GL::getProcAddress('textureBuffer'))($texture, $internalformat, $buffer);
}

function glTextureBufferEXT(int $texture, int $target, int $internalformat, int $buffer) {
  static $proc;
  return ($proc ??= GL::getProcAddress('textureBufferEXT'))($texture, $target, $internalformat, $buffer);
}

function glTextureBufferRange(int $texture, int $internalformat, int $buffer, int $offset, int $size) {
  static $proc;
  return ($proc ??= GL::getProcAddress('textureBufferRange'))($texture, $internalformat, $buffer, $offset, $size);
}

function glTextureBufferRangeEXT(int $texture, int $target, int $internalformat, int $buffer, int $offset, int $size) {
  static $proc;
  return ($proc ??= GL::getProcAddress('textureBufferRangeEXT'))($texture, $target, $internalformat, $buffer, $offset, $size);
}

function glTextureColorMaskSGIS(int $red, int $green, int $blue, int $alpha) {
  static $proc;
  return ($proc ??= GL::getProcAddress('textureColorMaskSGIS'))($red, $green, $blue, $alpha);
}

function glTextureImage1DEXT(int $texture, int $target, int $level, int $internalformat, int $width, int $border, int $format, int $type, $pixels) {
  static $proc;
  return ($proc ??= GL::getProcAddress('textureImage1DEXT'))($texture, $target, $level, $internalformat, $width, $border, $format, $type, $pixels);
}

function glTextureImage2DEXT(int $texture, int $target, int $level, int $internalformat, int $width, int $height, int $border, int $format, int $type, $pixels) {
  static $proc;
  return ($proc ??= GL::getProcAddress('textureImage2DEXT'))($texture, $target, $level, $internalformat, $width, $height, $border, $format, $type, $pixels);
}

function glTextureImage2DMultisampleCoverageNV(int $texture, int $target, int $coverageSamples, int $colorSamples, int $internalFormat, int $width, int $height, int $fixedSampleLocations) {
  static $proc;
  return ($proc ??= GL::getProcAddress('textureImage2DMultisampleCoverageNV'))($texture, $target, $coverageSamples, $colorSamples, $internalFormat, $width, $height, $fixedSampleLocations);
}

function glTextureImage2DMultisampleNV(int $texture, int $target, int $samples, int $internalFormat, int $width, int $height, int $fixedSampleLocations) {
  static $proc;
  return ($proc ??= GL::getProcAddress('textureImage2DMultisampleNV'))($texture, $target, $samples, $internalFormat, $width, $height, $fixedSampleLocations);
}

function glTextureImage3DEXT(int $texture, int $target, int $level, int $internalformat, int $width, int $height, int $depth, int $border, int $format, int $type, $pixels) {
  static $proc;
  return ($proc ??= GL::getProcAddress('textureImage3DEXT'))($texture, $target, $level, $internalformat, $width, $height, $depth, $border, $format, $type, $pixels);
}

function glTextureImage3DMultisampleCoverageNV(int $texture, int $target, int $coverageSamples, int $colorSamples, int $internalFormat, int $width, int $height, int $depth, int $fixedSampleLocations) {
  static $proc;
  return ($proc ??= GL::getProcAddress('textureImage3DMultisampleCoverageNV'))($texture, $target, $coverageSamples, $colorSamples, $internalFormat, $width, $height, $depth, $fixedSampleLocations);
}

function glTextureImage3DMultisampleNV(int $texture, int $target, int $samples, int $internalFormat, int $width, int $height, int $depth, int $fixedSampleLocations) {
  static $proc;
  return ($proc ??= GL::getProcAddress('textureImage3DMultisampleNV'))($texture, $target, $samples, $internalFormat, $width, $height, $depth, $fixedSampleLocations);
}

function glTextureLightEXT(int $pname) {
  static $proc;
  return ($proc ??= GL::getProcAddress('textureLightEXT'))($pname);
}

function glTextureMaterialEXT(int $face, int $mode) {
  static $proc;
  return ($proc ??= GL::getProcAddress('textureMaterialEXT'))($face, $mode);
}

function glTextureNormalEXT(int $mode) {
  static $proc;
  return ($proc ??= GL::getProcAddress('textureNormalEXT'))($mode);
}

function glTexturePageCommitmentEXT(int $texture, int $level, int $xoffset, int $yoffset, int $zoffset, int $width, int $height, int $depth, int $commit) {
  static $proc;
  return ($proc ??= GL::getProcAddress('texturePageCommitmentEXT'))($texture, $level, $xoffset, $yoffset, $zoffset, $width, $height, $depth, $commit);
}

function glTextureParameterIiv(int $texture, int $pname, $params) {
  static $proc;
  return ($proc ??= GL::getProcAddress('textureParameterIiv'))($texture, $pname, $params);
}

function glTextureParameterIivEXT(int $texture, int $target, int $pname, $params) {
  static $proc;
  return ($proc ??= GL::getProcAddress('textureParameterIivEXT'))($texture, $target, $pname, $params);
}

function glTextureParameterIuiv(int $texture, int $pname, $params) {
  static $proc;
  return ($proc ??= GL::getProcAddress('textureParameterIuiv'))($texture, $pname, $params);
}

function glTextureParameterIuivEXT(int $texture, int $target, int $pname, $params) {
  static $proc;
  return ($proc ??= GL::getProcAddress('textureParameterIuivEXT'))($texture, $target, $pname, $params);
}

function glTextureParameterf(int $texture, int $pname, float $param) {
  static $proc;
  return ($proc ??= GL::getProcAddress('textureParameterf'))($texture, $pname, $param);
}

function glTextureParameterfEXT(int $texture, int $target, int $pname, float $param) {
  static $proc;
  return ($proc ??= GL::getProcAddress('textureParameterfEXT'))($texture, $target, $pname, $param);
}

function glTextureParameterfv(int $texture, int $pname, $param) {
  static $proc;
  return ($proc ??= GL::getProcAddress('textureParameterfv'))($texture, $pname, $param);
}

function glTextureParameterfvEXT(int $texture, int $target, int $pname, $params) {
  static $proc;
  return ($proc ??= GL::getProcAddress('textureParameterfvEXT'))($texture, $target, $pname, $params);
}

function glTextureParameteri(int $texture, int $pname, int $param) {
  static $proc;
  return ($proc ??= GL::getProcAddress('textureParameteri'))($texture, $pname, $param);
}

function glTextureParameteriEXT(int $texture, int $target, int $pname, int $param) {
  static $proc;
  return ($proc ??= GL::getProcAddress('textureParameteriEXT'))($texture, $target, $pname, $param);
}

function glTextureParameteriv(int $texture, int $pname, $param) {
  static $proc;
  return ($proc ??= GL::getProcAddress('textureParameteriv'))($texture, $pname, $param);
}

function glTextureParameterivEXT(int $texture, int $target, int $pname, $params) {
  static $proc;
  return ($proc ??= GL::getProcAddress('textureParameterivEXT'))($texture, $target, $pname, $params);
}

function glTextureRangeAPPLE(int $target, int $length, $pointer) {
  static $proc;
  return ($proc ??= GL::getProcAddress('textureRangeAPPLE'))($target, $length, $pointer);
}

function glTextureRenderbufferEXT(int $texture, int $target, int $renderbuffer) {
  static $proc;
  return ($proc ??= GL::getProcAddress('textureRenderbufferEXT'))($texture, $target, $renderbuffer);
}

function glTextureStorage1D(int $texture, int $levels, int $internalformat, int $width) {
  static $proc;
  return ($proc ??= GL::getProcAddress('textureStorage1D'))($texture, $levels, $internalformat, $width);
}

function glTextureStorage1DEXT(int $texture, int $target, int $levels, int $internalformat, int $width) {
  static $proc;
  return ($proc ??= GL::getProcAddress('textureStorage1DEXT'))($texture, $target, $levels, $internalformat, $width);
}

function glTextureStorage2D(int $texture, int $levels, int $internalformat, int $width, int $height) {
  static $proc;
  return ($proc ??= GL::getProcAddress('textureStorage2D'))($texture, $levels, $internalformat, $width, $height);
}

function glTextureStorage2DEXT(int $texture, int $target, int $levels, int $internalformat, int $width, int $height) {
  static $proc;
  return ($proc ??= GL::getProcAddress('textureStorage2DEXT'))($texture, $target, $levels, $internalformat, $width, $height);
}

function glTextureStorage2DMultisample(int $texture, int $samples, int $internalformat, int $width, int $height, int $fixedsamplelocations) {
  static $proc;
  return ($proc ??= GL::getProcAddress('textureStorage2DMultisample'))($texture, $samples, $internalformat, $width, $height, $fixedsamplelocations);
}

function glTextureStorage2DMultisampleEXT(int $texture, int $target, int $samples, int $internalformat, int $width, int $height, int $fixedsamplelocations) {
  static $proc;
  return ($proc ??= GL::getProcAddress('textureStorage2DMultisampleEXT'))($texture, $target, $samples, $internalformat, $width, $height, $fixedsamplelocations);
}

function glTextureStorage3D(int $texture, int $levels, int $internalformat, int $width, int $height, int $depth) {
  static $proc;
  return ($proc ??= GL::getProcAddress('textureStorage3D'))($texture, $levels, $internalformat, $width, $height, $depth);
}

function glTextureStorage3DEXT(int $texture, int $target, int $levels, int $internalformat, int $width, int $height, int $depth) {
  static $proc;
  return ($proc ??= GL::getProcAddress('textureStorage3DEXT'))($texture, $target, $levels, $internalformat, $width, $height, $depth);
}

function glTextureStorage3DMultisample(int $texture, int $samples, int $internalformat, int $width, int $height, int $depth, int $fixedsamplelocations) {
  static $proc;
  return ($proc ??= GL::getProcAddress('textureStorage3DMultisample'))($texture, $samples, $internalformat, $width, $height, $depth, $fixedsamplelocations);
}

function glTextureStorage3DMultisampleEXT(int $texture, int $target, int $samples, int $internalformat, int $width, int $height, int $depth, int $fixedsamplelocations) {
  static $proc;
  return ($proc ??= GL::getProcAddress('textureStorage3DMultisampleEXT'))($texture, $target, $samples, $internalformat, $width, $height, $depth, $fixedsamplelocations);
}

function glTextureStorageSparseAMD(int $texture, int $target, int $internalFormat, int $width, int $height, int $depth, int $layers, int $flags) {
  static $proc;
  return ($proc ??= GL::getProcAddress('textureStorageSparseAMD'))($texture, $target, $internalFormat, $width, $height, $depth, $layers, $flags);
}

function glTextureSubImage1D(int $texture, int $level, int $xoffset, int $width, int $format, int $type, $pixels) {
  static $proc;
  return ($proc ??= GL::getProcAddress('textureSubImage1D'))($texture, $level, $xoffset, $width, $format, $type, $pixels);
}

function glTextureSubImage1DEXT(int $texture, int $target, int $level, int $xoffset, int $width, int $format, int $type, $pixels) {
  static $proc;
  return ($proc ??= GL::getProcAddress('textureSubImage1DEXT'))($texture, $target, $level, $xoffset, $width, $format, $type, $pixels);
}

function glTextureSubImage2D(int $texture, int $level, int $xoffset, int $yoffset, int $width, int $height, int $format, int $type, $pixels) {
  static $proc;
  return ($proc ??= GL::getProcAddress('textureSubImage2D'))($texture, $level, $xoffset, $yoffset, $width, $height, $format, $type, $pixels);
}

function glTextureSubImage2DEXT(int $texture, int $target, int $level, int $xoffset, int $yoffset, int $width, int $height, int $format, int $type, $pixels) {
  static $proc;
  return ($proc ??= GL::getProcAddress('textureSubImage2DEXT'))($texture, $target, $level, $xoffset, $yoffset, $width, $height, $format, $type, $pixels);
}

function glTextureSubImage3D(int $texture, int $level, int $xoffset, int $yoffset, int $zoffset, int $width, int $height, int $depth, int $format, int $type, $pixels) {
  static $proc;
  return ($proc ??= GL::getProcAddress('textureSubImage3D'))($texture, $level, $xoffset, $yoffset, $zoffset, $width, $height, $depth, $format, $type, $pixels);
}

function glTextureSubImage3DEXT(int $texture, int $target, int $level, int $xoffset, int $yoffset, int $zoffset, int $width, int $height, int $depth, int $format, int $type, $pixels) {
  static $proc;
  return ($proc ??= GL::getProcAddress('textureSubImage3DEXT'))($texture, $target, $level, $xoffset, $yoffset, $zoffset, $width, $height, $depth, $format, $type, $pixels);
}

function glTextureView(int $texture, int $target, int $origtexture, int $internalformat, int $minlevel, int $numlevels, int $minlayer, int $numlayers) {
  static $proc;
  return ($proc ??= GL::getProcAddress('textureView'))($texture, $target, $origtexture, $internalformat, $minlevel, $numlevels, $minlayer, $numlayers);
}

function glTextureViewEXT(int $texture, int $target, int $origtexture, int $internalformat, int $minlevel, int $numlevels, int $minlayer, int $numlayers) {
  static $proc;
  return ($proc ??= GL::getProcAddress('textureViewEXT'))($texture, $target, $origtexture, $internalformat, $minlevel, $numlevels, $minlayer, $numlayers);
}

function glTextureViewOES(int $texture, int $target, int $origtexture, int $internalformat, int $minlevel, int $numlevels, int $minlayer, int $numlayers) {
  static $proc;
  return ($proc ??= GL::getProcAddress('textureViewOES'))($texture, $target, $origtexture, $internalformat, $minlevel, $numlevels, $minlayer, $numlayers);
}

function glTrackMatrixNV(int $target, int $address, int $matrix, int $transform) {
  static $proc;
  return ($proc ??= GL::getProcAddress('trackMatrixNV'))($target, $address, $matrix, $transform);
}

function glTransformFeedbackAttribsNV(int $count, $attribs, int $bufferMode) {
  static $proc;
  return ($proc ??= GL::getProcAddress('transformFeedbackAttribsNV'))($count, $attribs, $bufferMode);
}

function glTransformFeedbackBufferBase(int $xfb, int $index, int $buffer) {
  static $proc;
  return ($proc ??= GL::getProcAddress('transformFeedbackBufferBase'))($xfb, $index, $buffer);
}

function glTransformFeedbackBufferRange(int $xfb, int $index, int $buffer, int $offset, int $size) {
  static $proc;
  return ($proc ??= GL::getProcAddress('transformFeedbackBufferRange'))($xfb, $index, $buffer, $offset, $size);
}

function glTransformFeedbackStreamAttribsNV(int $count, $attribs, int $nbuffers, $bufstreams, int $bufferMode) {
  static $proc;
  return ($proc ??= GL::getProcAddress('transformFeedbackStreamAttribsNV'))($count, $attribs, $nbuffers, $bufstreams, $bufferMode);
}

function glTransformFeedbackVaryings(int $program, int $count, $varyings, int $bufferMode) {
  static $proc;
  return ($proc ??= GL::getProcAddress('transformFeedbackVaryings'))($program, $count, $varyings, $bufferMode);
}

function glTransformFeedbackVaryingsEXT(int $program, int $count, $varyings, int $bufferMode) {
  static $proc;
  return ($proc ??= GL::getProcAddress('transformFeedbackVaryingsEXT'))($program, $count, $varyings, $bufferMode);
}

function glTransformFeedbackVaryingsNV(int $program, int $count, $locations, int $bufferMode) {
  static $proc;
  return ($proc ??= GL::getProcAddress('transformFeedbackVaryingsNV'))($program, $count, $locations, $bufferMode);
}

function glTransformPathNV(int $resultPath, int $srcPath, int $transformType, $transformValues) {
  static $proc;
  return ($proc ??= GL::getProcAddress('transformPathNV'))($resultPath, $srcPath, $transformType, $transformValues);
}

function glTranslated(float $x, float $y, float $z) {
  static $proc;
  return ($proc ??= GL::getProcAddress('translated'))($x, $y, $z);
}

function glTranslatef(float $x, float $y, float $z) {
  static $proc;
  return ($proc ??= GL::getProcAddress('translatef'))($x, $y, $z);
}

function glTranslatex(int $x, int $y, int $z) {
  static $proc;
  return ($proc ??= GL::getProcAddress('translatex'))($x, $y, $z);
}

function glTranslatexOES(int $x, int $y, int $z) {
  static $proc;
  return ($proc ??= GL::getProcAddress('translatexOES'))($x, $y, $z);
}

function glUniform1d(int $location, float $x) {
  static $proc;
  return ($proc ??= GL::getProcAddress('uniform1d'))($location, $x);
}

function glUniform1dv(int $location, int $count, $value) {
  static $proc;
  return ($proc ??= GL::getProcAddress('uniform1dv'))($location, $count, $value);
}

function glUniform1f(int $location, float $v0) {
  static $proc;
  return ($proc ??= GL::getProcAddress('uniform1f'))($location, $v0);
}

function glUniform1fARB(int $location, float $v0) {
  static $proc;
  return ($proc ??= GL::getProcAddress('uniform1fARB'))($location, $v0);
}

function glUniform1fv(int $location, int $count, $value) {
  static $proc;
  return ($proc ??= GL::getProcAddress('uniform1fv'))($location, $count, $value);
}

function glUniform1fvARB(int $location, int $count, $value) {
  static $proc;
  return ($proc ??= GL::getProcAddress('uniform1fvARB'))($location, $count, $value);
}

function glUniform1i(int $location, int $v0) {
  static $proc;
  return ($proc ??= GL::getProcAddress('uniform1i'))($location, $v0);
}

function glUniform1i64ARB(int $location, int $x) {
  static $proc;
  return ($proc ??= GL::getProcAddress('uniform1i64ARB'))($location, $x);
}

function glUniform1i64NV(int $location, int $x) {
  static $proc;
  return ($proc ??= GL::getProcAddress('uniform1i64NV'))($location, $x);
}

function glUniform1i64vARB(int $location, int $count, $value) {
  static $proc;
  return ($proc ??= GL::getProcAddress('uniform1i64vARB'))($location, $count, $value);
}

function glUniform1i64vNV(int $location, int $count, $value) {
  static $proc;
  return ($proc ??= GL::getProcAddress('uniform1i64vNV'))($location, $count, $value);
}

function glUniform1iARB(int $location, int $v0) {
  static $proc;
  return ($proc ??= GL::getProcAddress('uniform1iARB'))($location, $v0);
}

function glUniform1iv(int $location, int $count, $value) {
  static $proc;
  return ($proc ??= GL::getProcAddress('uniform1iv'))($location, $count, $value);
}

function glUniform1ivARB(int $location, int $count, $value) {
  static $proc;
  return ($proc ??= GL::getProcAddress('uniform1ivARB'))($location, $count, $value);
}

function glUniform1ui(int $location, int $v0) {
  static $proc;
  return ($proc ??= GL::getProcAddress('uniform1ui'))($location, $v0);
}

function glUniform1ui64ARB(int $location, int $x) {
  static $proc;
  return ($proc ??= GL::getProcAddress('uniform1ui64ARB'))($location, $x);
}

function glUniform1ui64NV(int $location, int $x) {
  static $proc;
  return ($proc ??= GL::getProcAddress('uniform1ui64NV'))($location, $x);
}

function glUniform1ui64vARB(int $location, int $count, $value) {
  static $proc;
  return ($proc ??= GL::getProcAddress('uniform1ui64vARB'))($location, $count, $value);
}

function glUniform1ui64vNV(int $location, int $count, $value) {
  static $proc;
  return ($proc ??= GL::getProcAddress('uniform1ui64vNV'))($location, $count, $value);
}

function glUniform1uiEXT(int $location, int $v0) {
  static $proc;
  return ($proc ??= GL::getProcAddress('uniform1uiEXT'))($location, $v0);
}

function glUniform1uiv(int $location, int $count, $value) {
  static $proc;
  return ($proc ??= GL::getProcAddress('uniform1uiv'))($location, $count, $value);
}

function glUniform1uivEXT(int $location, int $count, $value) {
  static $proc;
  return ($proc ??= GL::getProcAddress('uniform1uivEXT'))($location, $count, $value);
}

function glUniform2d(int $location, float $x, float $y) {
  static $proc;
  return ($proc ??= GL::getProcAddress('uniform2d'))($location, $x, $y);
}

function glUniform2dv(int $location, int $count, $value) {
  static $proc;
  return ($proc ??= GL::getProcAddress('uniform2dv'))($location, $count, $value);
}

function glUniform2f(int $location, float $v0, float $v1) {
  static $proc;
  return ($proc ??= GL::getProcAddress('uniform2f'))($location, $v0, $v1);
}

function glUniform2fARB(int $location, float $v0, float $v1) {
  static $proc;
  return ($proc ??= GL::getProcAddress('uniform2fARB'))($location, $v0, $v1);
}

function glUniform2fv(int $location, int $count, $value) {
  static $proc;
  return ($proc ??= GL::getProcAddress('uniform2fv'))($location, $count, $value);
}

function glUniform2fvARB(int $location, int $count, $value) {
  static $proc;
  return ($proc ??= GL::getProcAddress('uniform2fvARB'))($location, $count, $value);
}

function glUniform2i(int $location, int $v0, int $v1) {
  static $proc;
  return ($proc ??= GL::getProcAddress('uniform2i'))($location, $v0, $v1);
}

function glUniform2i64ARB(int $location, int $x, int $y) {
  static $proc;
  return ($proc ??= GL::getProcAddress('uniform2i64ARB'))($location, $x, $y);
}

function glUniform2i64NV(int $location, int $x, int $y) {
  static $proc;
  return ($proc ??= GL::getProcAddress('uniform2i64NV'))($location, $x, $y);
}

function glUniform2i64vARB(int $location, int $count, $value) {
  static $proc;
  return ($proc ??= GL::getProcAddress('uniform2i64vARB'))($location, $count, $value);
}

function glUniform2i64vNV(int $location, int $count, $value) {
  static $proc;
  return ($proc ??= GL::getProcAddress('uniform2i64vNV'))($location, $count, $value);
}

function glUniform2iARB(int $location, int $v0, int $v1) {
  static $proc;
  return ($proc ??= GL::getProcAddress('uniform2iARB'))($location, $v0, $v1);
}

function glUniform2iv(int $location, int $count, $value) {
  static $proc;
  return ($proc ??= GL::getProcAddress('uniform2iv'))($location, $count, $value);
}

function glUniform2ivARB(int $location, int $count, $value) {
  static $proc;
  return ($proc ??= GL::getProcAddress('uniform2ivARB'))($location, $count, $value);
}

function glUniform2ui(int $location, int $v0, int $v1) {
  static $proc;
  return ($proc ??= GL::getProcAddress('uniform2ui'))($location, $v0, $v1);
}

function glUniform2ui64ARB(int $location, int $x, int $y) {
  static $proc;
  return ($proc ??= GL::getProcAddress('uniform2ui64ARB'))($location, $x, $y);
}

function glUniform2ui64NV(int $location, int $x, int $y) {
  static $proc;
  return ($proc ??= GL::getProcAddress('uniform2ui64NV'))($location, $x, $y);
}

function glUniform2ui64vARB(int $location, int $count, $value) {
  static $proc;
  return ($proc ??= GL::getProcAddress('uniform2ui64vARB'))($location, $count, $value);
}

function glUniform2ui64vNV(int $location, int $count, $value) {
  static $proc;
  return ($proc ??= GL::getProcAddress('uniform2ui64vNV'))($location, $count, $value);
}

function glUniform2uiEXT(int $location, int $v0, int $v1) {
  static $proc;
  return ($proc ??= GL::getProcAddress('uniform2uiEXT'))($location, $v0, $v1);
}

function glUniform2uiv(int $location, int $count, $value) {
  static $proc;
  return ($proc ??= GL::getProcAddress('uniform2uiv'))($location, $count, $value);
}

function glUniform2uivEXT(int $location, int $count, $value) {
  static $proc;
  return ($proc ??= GL::getProcAddress('uniform2uivEXT'))($location, $count, $value);
}

function glUniform3d(int $location, float $x, float $y, float $z) {
  static $proc;
  return ($proc ??= GL::getProcAddress('uniform3d'))($location, $x, $y, $z);
}

function glUniform3dv(int $location, int $count, $value) {
  static $proc;
  return ($proc ??= GL::getProcAddress('uniform3dv'))($location, $count, $value);
}

function glUniform3f(int $location, float $v0, float $v1, float $v2) {
  static $proc;
  return ($proc ??= GL::getProcAddress('uniform3f'))($location, $v0, $v1, $v2);
}

function glUniform3fARB(int $location, float $v0, float $v1, float $v2) {
  static $proc;
  return ($proc ??= GL::getProcAddress('uniform3fARB'))($location, $v0, $v1, $v2);
}

function glUniform3fv(int $location, int $count, $value) {
  static $proc;
  return ($proc ??= GL::getProcAddress('uniform3fv'))($location, $count, $value);
}

function glUniform3fvARB(int $location, int $count, $value) {
  static $proc;
  return ($proc ??= GL::getProcAddress('uniform3fvARB'))($location, $count, $value);
}

function glUniform3i(int $location, int $v0, int $v1, int $v2) {
  static $proc;
  return ($proc ??= GL::getProcAddress('uniform3i'))($location, $v0, $v1, $v2);
}

function glUniform3i64ARB(int $location, int $x, int $y, int $z) {
  static $proc;
  return ($proc ??= GL::getProcAddress('uniform3i64ARB'))($location, $x, $y, $z);
}

function glUniform3i64NV(int $location, int $x, int $y, int $z) {
  static $proc;
  return ($proc ??= GL::getProcAddress('uniform3i64NV'))($location, $x, $y, $z);
}

function glUniform3i64vARB(int $location, int $count, $value) {
  static $proc;
  return ($proc ??= GL::getProcAddress('uniform3i64vARB'))($location, $count, $value);
}

function glUniform3i64vNV(int $location, int $count, $value) {
  static $proc;
  return ($proc ??= GL::getProcAddress('uniform3i64vNV'))($location, $count, $value);
}

function glUniform3iARB(int $location, int $v0, int $v1, int $v2) {
  static $proc;
  return ($proc ??= GL::getProcAddress('uniform3iARB'))($location, $v0, $v1, $v2);
}

function glUniform3iv(int $location, int $count, $value) {
  static $proc;
  return ($proc ??= GL::getProcAddress('uniform3iv'))($location, $count, $value);
}

function glUniform3ivARB(int $location, int $count, $value) {
  static $proc;
  return ($proc ??= GL::getProcAddress('uniform3ivARB'))($location, $count, $value);
}

function glUniform3ui(int $location, int $v0, int $v1, int $v2) {
  static $proc;
  return ($proc ??= GL::getProcAddress('uniform3ui'))($location, $v0, $v1, $v2);
}

function glUniform3ui64ARB(int $location, int $x, int $y, int $z) {
  static $proc;
  return ($proc ??= GL::getProcAddress('uniform3ui64ARB'))($location, $x, $y, $z);
}

function glUniform3ui64NV(int $location, int $x, int $y, int $z) {
  static $proc;
  return ($proc ??= GL::getProcAddress('uniform3ui64NV'))($location, $x, $y, $z);
}

function glUniform3ui64vARB(int $location, int $count, $value) {
  static $proc;
  return ($proc ??= GL::getProcAddress('uniform3ui64vARB'))($location, $count, $value);
}

function glUniform3ui64vNV(int $location, int $count, $value) {
  static $proc;
  return ($proc ??= GL::getProcAddress('uniform3ui64vNV'))($location, $count, $value);
}

function glUniform3uiEXT(int $location, int $v0, int $v1, int $v2) {
  static $proc;
  return ($proc ??= GL::getProcAddress('uniform3uiEXT'))($location, $v0, $v1, $v2);
}

function glUniform3uiv(int $location, int $count, $value) {
  static $proc;
  return ($proc ??= GL::getProcAddress('uniform3uiv'))($location, $count, $value);
}

function glUniform3uivEXT(int $location, int $count, $value) {
  static $proc;
  return ($proc ??= GL::getProcAddress('uniform3uivEXT'))($location, $count, $value);
}

function glUniform4d(int $location, float $x, float $y, float $z, float $w) {
  static $proc;
  return ($proc ??= GL::getProcAddress('uniform4d'))($location, $x, $y, $z, $w);
}

function glUniform4dv(int $location, int $count, $value) {
  static $proc;
  return ($proc ??= GL::getProcAddress('uniform4dv'))($location, $count, $value);
}

function glUniform4f(int $location, float $v0, float $v1, float $v2, float $v3) {
  static $proc;
  return ($proc ??= GL::getProcAddress('uniform4f'))($location, $v0, $v1, $v2, $v3);
}

function glUniform4fARB(int $location, float $v0, float $v1, float $v2, float $v3) {
  static $proc;
  return ($proc ??= GL::getProcAddress('uniform4fARB'))($location, $v0, $v1, $v2, $v3);
}

function glUniform4fv(int $location, int $count, $value) {
  static $proc;
  return ($proc ??= GL::getProcAddress('uniform4fv'))($location, $count, $value);
}

function glUniform4fvARB(int $location, int $count, $value) {
  static $proc;
  return ($proc ??= GL::getProcAddress('uniform4fvARB'))($location, $count, $value);
}

function glUniform4i(int $location, int $v0, int $v1, int $v2, int $v3) {
  static $proc;
  return ($proc ??= GL::getProcAddress('uniform4i'))($location, $v0, $v1, $v2, $v3);
}

function glUniform4i64ARB(int $location, int $x, int $y, int $z, int $w) {
  static $proc;
  return ($proc ??= GL::getProcAddress('uniform4i64ARB'))($location, $x, $y, $z, $w);
}

function glUniform4i64NV(int $location, int $x, int $y, int $z, int $w) {
  static $proc;
  return ($proc ??= GL::getProcAddress('uniform4i64NV'))($location, $x, $y, $z, $w);
}

function glUniform4i64vARB(int $location, int $count, $value) {
  static $proc;
  return ($proc ??= GL::getProcAddress('uniform4i64vARB'))($location, $count, $value);
}

function glUniform4i64vNV(int $location, int $count, $value) {
  static $proc;
  return ($proc ??= GL::getProcAddress('uniform4i64vNV'))($location, $count, $value);
}

function glUniform4iARB(int $location, int $v0, int $v1, int $v2, int $v3) {
  static $proc;
  return ($proc ??= GL::getProcAddress('uniform4iARB'))($location, $v0, $v1, $v2, $v3);
}

function glUniform4iv(int $location, int $count, $value) {
  static $proc;
  return ($proc ??= GL::getProcAddress('uniform4iv'))($location, $count, $value);
}

function glUniform4ivARB(int $location, int $count, $value) {
  static $proc;
  return ($proc ??= GL::getProcAddress('uniform4ivARB'))($location, $count, $value);
}

function glUniform4ui(int $location, int $v0, int $v1, int $v2, int $v3) {
  static $proc;
  return ($proc ??= GL::getProcAddress('uniform4ui'))($location, $v0, $v1, $v2, $v3);
}

function glUniform4ui64ARB(int $location, int $x, int $y, int $z, int $w) {
  static $proc;
  return ($proc ??= GL::getProcAddress('uniform4ui64ARB'))($location, $x, $y, $z, $w);
}

function glUniform4ui64NV(int $location, int $x, int $y, int $z, int $w) {
  static $proc;
  return ($proc ??= GL::getProcAddress('uniform4ui64NV'))($location, $x, $y, $z, $w);
}

function glUniform4ui64vARB(int $location, int $count, $value) {
  static $proc;
  return ($proc ??= GL::getProcAddress('uniform4ui64vARB'))($location, $count, $value);
}

function glUniform4ui64vNV(int $location, int $count, $value) {
  static $proc;
  return ($proc ??= GL::getProcAddress('uniform4ui64vNV'))($location, $count, $value);
}

function glUniform4uiEXT(int $location, int $v0, int $v1, int $v2, int $v3) {
  static $proc;
  return ($proc ??= GL::getProcAddress('uniform4uiEXT'))($location, $v0, $v1, $v2, $v3);
}

function glUniform4uiv(int $location, int $count, $value) {
  static $proc;
  return ($proc ??= GL::getProcAddress('uniform4uiv'))($location, $count, $value);
}

function glUniform4uivEXT(int $location, int $count, $value) {
  static $proc;
  return ($proc ??= GL::getProcAddress('uniform4uivEXT'))($location, $count, $value);
}

function glUniformBlockBinding(int $program, int $uniformBlockIndex, int $uniformBlockBinding) {
  static $proc;
  return ($proc ??= GL::getProcAddress('uniformBlockBinding'))($program, $uniformBlockIndex, $uniformBlockBinding);
}

function glUniformBufferEXT(int $program, int $location, int $buffer) {
  static $proc;
  return ($proc ??= GL::getProcAddress('uniformBufferEXT'))($program, $location, $buffer);
}

function glUniformHandleui64ARB(int $location, int $value) {
  static $proc;
  return ($proc ??= GL::getProcAddress('uniformHandleui64ARB'))($location, $value);
}

function glUniformHandleui64IMG(int $location, int $value) {
  static $proc;
  return ($proc ??= GL::getProcAddress('uniformHandleui64IMG'))($location, $value);
}

function glUniformHandleui64NV(int $location, int $value) {
  static $proc;
  return ($proc ??= GL::getProcAddress('uniformHandleui64NV'))($location, $value);
}

function glUniformHandleui64vARB(int $location, int $count, $value) {
  static $proc;
  return ($proc ??= GL::getProcAddress('uniformHandleui64vARB'))($location, $count, $value);
}

function glUniformHandleui64vIMG(int $location, int $count, $value) {
  static $proc;
  return ($proc ??= GL::getProcAddress('uniformHandleui64vIMG'))($location, $count, $value);
}

function glUniformHandleui64vNV(int $location, int $count, $value) {
  static $proc;
  return ($proc ??= GL::getProcAddress('uniformHandleui64vNV'))($location, $count, $value);
}

function glUniformMatrix2dv(int $location, int $count, int $transpose, $value) {
  static $proc;
  return ($proc ??= GL::getProcAddress('uniformMatrix2dv'))($location, $count, $transpose, $value);
}

function glUniformMatrix2fv(int $location, int $count, int $transpose, $value) {
  static $proc;
  return ($proc ??= GL::getProcAddress('uniformMatrix2fv'))($location, $count, $transpose, $value);
}

function glUniformMatrix2fvARB(int $location, int $count, int $transpose, $value) {
  static $proc;
  return ($proc ??= GL::getProcAddress('uniformMatrix2fvARB'))($location, $count, $transpose, $value);
}

function glUniformMatrix2x3dv(int $location, int $count, int $transpose, $value) {
  static $proc;
  return ($proc ??= GL::getProcAddress('uniformMatrix2x3dv'))($location, $count, $transpose, $value);
}

function glUniformMatrix2x3fv(int $location, int $count, int $transpose, $value) {
  static $proc;
  return ($proc ??= GL::getProcAddress('uniformMatrix2x3fv'))($location, $count, $transpose, $value);
}

function glUniformMatrix2x3fvNV(int $location, int $count, int $transpose, $value) {
  static $proc;
  return ($proc ??= GL::getProcAddress('uniformMatrix2x3fvNV'))($location, $count, $transpose, $value);
}

function glUniformMatrix2x4dv(int $location, int $count, int $transpose, $value) {
  static $proc;
  return ($proc ??= GL::getProcAddress('uniformMatrix2x4dv'))($location, $count, $transpose, $value);
}

function glUniformMatrix2x4fv(int $location, int $count, int $transpose, $value) {
  static $proc;
  return ($proc ??= GL::getProcAddress('uniformMatrix2x4fv'))($location, $count, $transpose, $value);
}

function glUniformMatrix2x4fvNV(int $location, int $count, int $transpose, $value) {
  static $proc;
  return ($proc ??= GL::getProcAddress('uniformMatrix2x4fvNV'))($location, $count, $transpose, $value);
}

function glUniformMatrix3dv(int $location, int $count, int $transpose, $value) {
  static $proc;
  return ($proc ??= GL::getProcAddress('uniformMatrix3dv'))($location, $count, $transpose, $value);
}

function glUniformMatrix3fv(int $location, int $count, int $transpose, $value) {
  static $proc;
  return ($proc ??= GL::getProcAddress('uniformMatrix3fv'))($location, $count, $transpose, $value);
}

function glUniformMatrix3fvARB(int $location, int $count, int $transpose, $value) {
  static $proc;
  return ($proc ??= GL::getProcAddress('uniformMatrix3fvARB'))($location, $count, $transpose, $value);
}

function glUniformMatrix3x2dv(int $location, int $count, int $transpose, $value) {
  static $proc;
  return ($proc ??= GL::getProcAddress('uniformMatrix3x2dv'))($location, $count, $transpose, $value);
}

function glUniformMatrix3x2fv(int $location, int $count, int $transpose, $value) {
  static $proc;
  return ($proc ??= GL::getProcAddress('uniformMatrix3x2fv'))($location, $count, $transpose, $value);
}

function glUniformMatrix3x2fvNV(int $location, int $count, int $transpose, $value) {
  static $proc;
  return ($proc ??= GL::getProcAddress('uniformMatrix3x2fvNV'))($location, $count, $transpose, $value);
}

function glUniformMatrix3x4dv(int $location, int $count, int $transpose, $value) {
  static $proc;
  return ($proc ??= GL::getProcAddress('uniformMatrix3x4dv'))($location, $count, $transpose, $value);
}

function glUniformMatrix3x4fv(int $location, int $count, int $transpose, $value) {
  static $proc;
  return ($proc ??= GL::getProcAddress('uniformMatrix3x4fv'))($location, $count, $transpose, $value);
}

function glUniformMatrix3x4fvNV(int $location, int $count, int $transpose, $value) {
  static $proc;
  return ($proc ??= GL::getProcAddress('uniformMatrix3x4fvNV'))($location, $count, $transpose, $value);
}

function glUniformMatrix4dv(int $location, int $count, int $transpose, $value) {
  static $proc;
  return ($proc ??= GL::getProcAddress('uniformMatrix4dv'))($location, $count, $transpose, $value);
}

function glUniformMatrix4fv(int $location, int $count, int $transpose, $value) {
  static $proc;
  return ($proc ??= GL::getProcAddress('uniformMatrix4fv'))($location, $count, $transpose, $value);
}

function glUniformMatrix4fvARB(int $location, int $count, int $transpose, $value) {
  static $proc;
  return ($proc ??= GL::getProcAddress('uniformMatrix4fvARB'))($location, $count, $transpose, $value);
}

function glUniformMatrix4x2dv(int $location, int $count, int $transpose, $value) {
  static $proc;
  return ($proc ??= GL::getProcAddress('uniformMatrix4x2dv'))($location, $count, $transpose, $value);
}

function glUniformMatrix4x2fv(int $location, int $count, int $transpose, $value) {
  static $proc;
  return ($proc ??= GL::getProcAddress('uniformMatrix4x2fv'))($location, $count, $transpose, $value);
}

function glUniformMatrix4x2fvNV(int $location, int $count, int $transpose, $value) {
  static $proc;
  return ($proc ??= GL::getProcAddress('uniformMatrix4x2fvNV'))($location, $count, $transpose, $value);
}

function glUniformMatrix4x3dv(int $location, int $count, int $transpose, $value) {
  static $proc;
  return ($proc ??= GL::getProcAddress('uniformMatrix4x3dv'))($location, $count, $transpose, $value);
}

function glUniformMatrix4x3fv(int $location, int $count, int $transpose, $value) {
  static $proc;
  return ($proc ??= GL::getProcAddress('uniformMatrix4x3fv'))($location, $count, $transpose, $value);
}

function glUniformMatrix4x3fvNV(int $location, int $count, int $transpose, $value) {
  static $proc;
  return ($proc ??= GL::getProcAddress('uniformMatrix4x3fvNV'))($location, $count, $transpose, $value);
}

function glUniformSubroutinesuiv(int $shadertype, int $count, $indices) {
  static $proc;
  return ($proc ??= GL::getProcAddress('uniformSubroutinesuiv'))($shadertype, $count, $indices);
}

function glUniformui64NV(int $location, int $value) {
  static $proc;
  return ($proc ??= GL::getProcAddress('uniformui64NV'))($location, $value);
}

function glUniformui64vNV(int $location, int $count, $value) {
  static $proc;
  return ($proc ??= GL::getProcAddress('uniformui64vNV'))($location, $count, $value);
}

function glUnlockArraysEXT() {
  static $proc;
  return ($proc ??= GL::getProcAddress('unlockArraysEXT'))();
}

function glUnmapBuffer(int $target) {
  static $proc;
  return ($proc ??= GL::getProcAddress('unmapBuffer'))($target);
}

function glUnmapBufferARB(int $target) {
  static $proc;
  return ($proc ??= GL::getProcAddress('unmapBufferARB'))($target);
}

function glUnmapBufferOES(int $target) {
  static $proc;
  return ($proc ??= GL::getProcAddress('unmapBufferOES'))($target);
}

function glUnmapNamedBuffer(int $buffer) {
  static $proc;
  return ($proc ??= GL::getProcAddress('unmapNamedBuffer'))($buffer);
}

function glUnmapNamedBufferEXT(int $buffer) {
  static $proc;
  return ($proc ??= GL::getProcAddress('unmapNamedBufferEXT'))($buffer);
}

function glUnmapObjectBufferATI(int $buffer) {
  static $proc;
  return ($proc ??= GL::getProcAddress('unmapObjectBufferATI'))($buffer);
}

function glUnmapTexture2DINTEL(int $texture, int $level) {
  static $proc;
  return ($proc ??= GL::getProcAddress('unmapTexture2DINTEL'))($texture, $level);
}

function glUpdateObjectBufferATI(int $buffer, int $offset, int $size, $pointer, int $preserve) {
  static $proc;
  return ($proc ??= GL::getProcAddress('updateObjectBufferATI'))($buffer, $offset, $size, $pointer, $preserve);
}

function glUseProgram(int $program) {
  static $proc;
  return ($proc ??= GL::getProcAddress('useProgram'))($program);
}

function glUseProgramObjectARB(int $programObj) {
  static $proc;
  return ($proc ??= GL::getProcAddress('useProgramObjectARB'))($programObj);
}

function glUseProgramStages(int $pipeline, int $stages, int $program) {
  static $proc;
  return ($proc ??= GL::getProcAddress('useProgramStages'))($pipeline, $stages, $program);
}

function glUseProgramStagesEXT(int $pipeline, int $stages, int $program) {
  static $proc;
  return ($proc ??= GL::getProcAddress('useProgramStagesEXT'))($pipeline, $stages, $program);
}

function glUseShaderProgramEXT(int $type, int $program) {
  static $proc;
  return ($proc ??= GL::getProcAddress('useShaderProgramEXT'))($type, $program);
}

function glVDPAUFiniNV() {
  static $proc;
  return ($proc ??= GL::getProcAddress('vDPAUFiniNV'))();
}

function glVDPAUGetSurfaceivNV($surface, int $pname, int $bufSize, $length, $values) {
  static $proc;
  return ($proc ??= GL::getProcAddress('vDPAUGetSurfaceivNV'))($surface, $pname, $bufSize, $length, $values);
}

function glVDPAUInitNV($vdpDevice, $getProcAddress) {
  static $proc;
  return ($proc ??= GL::getProcAddress('vDPAUInitNV'))($vdpDevice, $getProcAddress);
}

function glVDPAUIsSurfaceNV($surface) {
  static $proc;
  return ($proc ??= GL::getProcAddress('vDPAUIsSurfaceNV'))($surface);
}

function glVDPAUMapSurfacesNV(int $numSurfaces, $surfaces) {
  static $proc;
  return ($proc ??= GL::getProcAddress('vDPAUMapSurfacesNV'))($numSurfaces, $surfaces);
}

function glVDPAURegisterOutputSurfaceNV($vdpSurface, int $target, int $numTextureNames, $textureNames) {
  static $proc;
  return ($proc ??= GL::getProcAddress('vDPAURegisterOutputSurfaceNV'))($vdpSurface, $target, $numTextureNames, $textureNames);
}

function glVDPAURegisterVideoSurfaceNV($vdpSurface, int $target, int $numTextureNames, $textureNames) {
  static $proc;
  return ($proc ??= GL::getProcAddress('vDPAURegisterVideoSurfaceNV'))($vdpSurface, $target, $numTextureNames, $textureNames);
}

function glVDPAUSurfaceAccessNV($surface, int $access) {
  static $proc;
  return ($proc ??= GL::getProcAddress('vDPAUSurfaceAccessNV'))($surface, $access);
}

function glVDPAUUnmapSurfacesNV(int $numSurface, $surfaces) {
  static $proc;
  return ($proc ??= GL::getProcAddress('vDPAUUnmapSurfacesNV'))($numSurface, $surfaces);
}

function glVDPAUUnregisterSurfaceNV($surface) {
  static $proc;
  return ($proc ??= GL::getProcAddress('vDPAUUnregisterSurfaceNV'))($surface);
}

function glValidateProgram(int $program) {
  static $proc;
  return ($proc ??= GL::getProcAddress('validateProgram'))($program);
}

function glValidateProgramARB(int $programObj) {
  static $proc;
  return ($proc ??= GL::getProcAddress('validateProgramARB'))($programObj);
}

function glValidateProgramPipeline(int $pipeline) {
  static $proc;
  return ($proc ??= GL::getProcAddress('validateProgramPipeline'))($pipeline);
}

function glValidateProgramPipelineEXT(int $pipeline) {
  static $proc;
  return ($proc ??= GL::getProcAddress('validateProgramPipelineEXT'))($pipeline);
}

function glVariantArrayObjectATI(int $id, int $type, int $stride, int $buffer, int $offset) {
  static $proc;
  return ($proc ??= GL::getProcAddress('variantArrayObjectATI'))($id, $type, $stride, $buffer, $offset);
}

function glVariantPointerEXT(int $id, int $type, int $stride, $addr) {
  static $proc;
  return ($proc ??= GL::getProcAddress('variantPointerEXT'))($id, $type, $stride, $addr);
}

function glVariantbvEXT(int $id, $addr) {
  static $proc;
  return ($proc ??= GL::getProcAddress('variantbvEXT'))($id, $addr);
}

function glVariantdvEXT(int $id, $addr) {
  static $proc;
  return ($proc ??= GL::getProcAddress('variantdvEXT'))($id, $addr);
}

function glVariantfvEXT(int $id, $addr) {
  static $proc;
  return ($proc ??= GL::getProcAddress('variantfvEXT'))($id, $addr);
}

function glVariantivEXT(int $id, $addr) {
  static $proc;
  return ($proc ??= GL::getProcAddress('variantivEXT'))($id, $addr);
}

function glVariantsvEXT(int $id, $addr) {
  static $proc;
  return ($proc ??= GL::getProcAddress('variantsvEXT'))($id, $addr);
}

function glVariantubvEXT(int $id, $addr) {
  static $proc;
  return ($proc ??= GL::getProcAddress('variantubvEXT'))($id, $addr);
}

function glVariantuivEXT(int $id, $addr) {
  static $proc;
  return ($proc ??= GL::getProcAddress('variantuivEXT'))($id, $addr);
}

function glVariantusvEXT(int $id, $addr) {
  static $proc;
  return ($proc ??= GL::getProcAddress('variantusvEXT'))($id, $addr);
}

function glVertex2bOES(int $x, int $y) {
  static $proc;
  return ($proc ??= GL::getProcAddress('vertex2bOES'))($x, $y);
}

function glVertex2bvOES($coords) {
  static $proc;
  return ($proc ??= GL::getProcAddress('vertex2bvOES'))($coords);
}

function glVertex2d(float $x, float $y) {
  static $proc;
  return ($proc ??= GL::getProcAddress('vertex2d'))($x, $y);
}

function glVertex2dv($v) {
  static $proc;
  return ($proc ??= GL::getProcAddress('vertex2dv'))($v);
}

function glVertex2f(float $x, float $y) {
  static $proc;
  return ($proc ??= GL::getProcAddress('vertex2f'))($x, $y);
}

function glVertex2fv($v) {
  static $proc;
  return ($proc ??= GL::getProcAddress('vertex2fv'))($v);
}

function glVertex2hNV(int $x, int $y) {
  static $proc;
  return ($proc ??= GL::getProcAddress('vertex2hNV'))($x, $y);
}

function glVertex2hvNV($v) {
  static $proc;
  return ($proc ??= GL::getProcAddress('vertex2hvNV'))($v);
}

function glVertex2i(int $x, int $y) {
  static $proc;
  return ($proc ??= GL::getProcAddress('vertex2i'))($x, $y);
}

function glVertex2iv($v) {
  static $proc;
  return ($proc ??= GL::getProcAddress('vertex2iv'))($v);
}

function glVertex2s(int $x, int $y) {
  static $proc;
  return ($proc ??= GL::getProcAddress('vertex2s'))($x, $y);
}

function glVertex2sv($v) {
  static $proc;
  return ($proc ??= GL::getProcAddress('vertex2sv'))($v);
}

function glVertex2xOES(int $x) {
  static $proc;
  return ($proc ??= GL::getProcAddress('vertex2xOES'))($x);
}

function glVertex2xvOES($coords) {
  static $proc;
  return ($proc ??= GL::getProcAddress('vertex2xvOES'))($coords);
}

function glVertex3bOES(int $x, int $y, int $z) {
  static $proc;
  return ($proc ??= GL::getProcAddress('vertex3bOES'))($x, $y, $z);
}

function glVertex3bvOES($coords) {
  static $proc;
  return ($proc ??= GL::getProcAddress('vertex3bvOES'))($coords);
}

function glVertex3d(float $x, float $y, float $z) {
  static $proc;
  return ($proc ??= GL::getProcAddress('vertex3d'))($x, $y, $z);
}

function glVertex3dv($v) {
  static $proc;
  return ($proc ??= GL::getProcAddress('vertex3dv'))($v);
}

function glVertex3f(float $x, float $y, float $z) {
  static $proc;
  return ($proc ??= GL::getProcAddress('vertex3f'))($x, $y, $z);
}

function glVertex3fv($v) {
  static $proc;
  return ($proc ??= GL::getProcAddress('vertex3fv'))($v);
}

function glVertex3hNV(int $x, int $y, int $z) {
  static $proc;
  return ($proc ??= GL::getProcAddress('vertex3hNV'))($x, $y, $z);
}

function glVertex3hvNV($v) {
  static $proc;
  return ($proc ??= GL::getProcAddress('vertex3hvNV'))($v);
}

function glVertex3i(int $x, int $y, int $z) {
  static $proc;
  return ($proc ??= GL::getProcAddress('vertex3i'))($x, $y, $z);
}

function glVertex3iv($v) {
  static $proc;
  return ($proc ??= GL::getProcAddress('vertex3iv'))($v);
}

function glVertex3s(int $x, int $y, int $z) {
  static $proc;
  return ($proc ??= GL::getProcAddress('vertex3s'))($x, $y, $z);
}

function glVertex3sv($v) {
  static $proc;
  return ($proc ??= GL::getProcAddress('vertex3sv'))($v);
}

function glVertex3xOES(int $x, int $y) {
  static $proc;
  return ($proc ??= GL::getProcAddress('vertex3xOES'))($x, $y);
}

function glVertex3xvOES($coords) {
  static $proc;
  return ($proc ??= GL::getProcAddress('vertex3xvOES'))($coords);
}

function glVertex4bOES(int $x, int $y, int $z, int $w) {
  static $proc;
  return ($proc ??= GL::getProcAddress('vertex4bOES'))($x, $y, $z, $w);
}

function glVertex4bvOES($coords) {
  static $proc;
  return ($proc ??= GL::getProcAddress('vertex4bvOES'))($coords);
}

function glVertex4d(float $x, float $y, float $z, float $w) {
  static $proc;
  return ($proc ??= GL::getProcAddress('vertex4d'))($x, $y, $z, $w);
}

function glVertex4dv($v) {
  static $proc;
  return ($proc ??= GL::getProcAddress('vertex4dv'))($v);
}

function glVertex4f(float $x, float $y, float $z, float $w) {
  static $proc;
  return ($proc ??= GL::getProcAddress('vertex4f'))($x, $y, $z, $w);
}

function glVertex4fv($v) {
  static $proc;
  return ($proc ??= GL::getProcAddress('vertex4fv'))($v);
}

function glVertex4hNV(int $x, int $y, int $z, int $w) {
  static $proc;
  return ($proc ??= GL::getProcAddress('vertex4hNV'))($x, $y, $z, $w);
}

function glVertex4hvNV($v) {
  static $proc;
  return ($proc ??= GL::getProcAddress('vertex4hvNV'))($v);
}

function glVertex4i(int $x, int $y, int $z, int $w) {
  static $proc;
  return ($proc ??= GL::getProcAddress('vertex4i'))($x, $y, $z, $w);
}

function glVertex4iv($v) {
  static $proc;
  return ($proc ??= GL::getProcAddress('vertex4iv'))($v);
}

function glVertex4s(int $x, int $y, int $z, int $w) {
  static $proc;
  return ($proc ??= GL::getProcAddress('vertex4s'))($x, $y, $z, $w);
}

function glVertex4sv($v) {
  static $proc;
  return ($proc ??= GL::getProcAddress('vertex4sv'))($v);
}

function glVertex4xOES(int $x, int $y, int $z) {
  static $proc;
  return ($proc ??= GL::getProcAddress('vertex4xOES'))($x, $y, $z);
}

function glVertex4xvOES($coords) {
  static $proc;
  return ($proc ??= GL::getProcAddress('vertex4xvOES'))($coords);
}

function glVertexArrayAttribBinding(int $vaobj, int $attribindex, int $bindingindex) {
  static $proc;
  return ($proc ??= GL::getProcAddress('vertexArrayAttribBinding'))($vaobj, $attribindex, $bindingindex);
}

function glVertexArrayAttribFormat(int $vaobj, int $attribindex, int $size, int $type, int $normalized, int $relativeoffset) {
  static $proc;
  return ($proc ??= GL::getProcAddress('vertexArrayAttribFormat'))($vaobj, $attribindex, $size, $type, $normalized, $relativeoffset);
}

function glVertexArrayAttribIFormat(int $vaobj, int $attribindex, int $size, int $type, int $relativeoffset) {
  static $proc;
  return ($proc ??= GL::getProcAddress('vertexArrayAttribIFormat'))($vaobj, $attribindex, $size, $type, $relativeoffset);
}

function glVertexArrayAttribLFormat(int $vaobj, int $attribindex, int $size, int $type, int $relativeoffset) {
  static $proc;
  return ($proc ??= GL::getProcAddress('vertexArrayAttribLFormat'))($vaobj, $attribindex, $size, $type, $relativeoffset);
}

function glVertexArrayBindVertexBufferEXT(int $vaobj, int $bindingindex, int $buffer, int $offset, int $stride) {
  static $proc;
  return ($proc ??= GL::getProcAddress('vertexArrayBindVertexBufferEXT'))($vaobj, $bindingindex, $buffer, $offset, $stride);
}

function glVertexArrayBindingDivisor(int $vaobj, int $bindingindex, int $divisor) {
  static $proc;
  return ($proc ??= GL::getProcAddress('vertexArrayBindingDivisor'))($vaobj, $bindingindex, $divisor);
}

function glVertexArrayColorOffsetEXT(int $vaobj, int $buffer, int $size, int $type, int $stride, int $offset) {
  static $proc;
  return ($proc ??= GL::getProcAddress('vertexArrayColorOffsetEXT'))($vaobj, $buffer, $size, $type, $stride, $offset);
}

function glVertexArrayEdgeFlagOffsetEXT(int $vaobj, int $buffer, int $stride, int $offset) {
  static $proc;
  return ($proc ??= GL::getProcAddress('vertexArrayEdgeFlagOffsetEXT'))($vaobj, $buffer, $stride, $offset);
}

function glVertexArrayElementBuffer(int $vaobj, int $buffer) {
  static $proc;
  return ($proc ??= GL::getProcAddress('vertexArrayElementBuffer'))($vaobj, $buffer);
}

function glVertexArrayFogCoordOffsetEXT(int $vaobj, int $buffer, int $type, int $stride, int $offset) {
  static $proc;
  return ($proc ??= GL::getProcAddress('vertexArrayFogCoordOffsetEXT'))($vaobj, $buffer, $type, $stride, $offset);
}

function glVertexArrayIndexOffsetEXT(int $vaobj, int $buffer, int $type, int $stride, int $offset) {
  static $proc;
  return ($proc ??= GL::getProcAddress('vertexArrayIndexOffsetEXT'))($vaobj, $buffer, $type, $stride, $offset);
}

function glVertexArrayMultiTexCoordOffsetEXT(int $vaobj, int $buffer, int $texunit, int $size, int $type, int $stride, int $offset) {
  static $proc;
  return ($proc ??= GL::getProcAddress('vertexArrayMultiTexCoordOffsetEXT'))($vaobj, $buffer, $texunit, $size, $type, $stride, $offset);
}

function glVertexArrayNormalOffsetEXT(int $vaobj, int $buffer, int $type, int $stride, int $offset) {
  static $proc;
  return ($proc ??= GL::getProcAddress('vertexArrayNormalOffsetEXT'))($vaobj, $buffer, $type, $stride, $offset);
}

function glVertexArrayParameteriAPPLE(int $pname, int $param) {
  static $proc;
  return ($proc ??= GL::getProcAddress('vertexArrayParameteriAPPLE'))($pname, $param);
}

function glVertexArrayRangeAPPLE(int $length, $pointer) {
  static $proc;
  return ($proc ??= GL::getProcAddress('vertexArrayRangeAPPLE'))($length, $pointer);
}

function glVertexArrayRangeNV(int $length, $pointer) {
  static $proc;
  return ($proc ??= GL::getProcAddress('vertexArrayRangeNV'))($length, $pointer);
}

function glVertexArraySecondaryColorOffsetEXT(int $vaobj, int $buffer, int $size, int $type, int $stride, int $offset) {
  static $proc;
  return ($proc ??= GL::getProcAddress('vertexArraySecondaryColorOffsetEXT'))($vaobj, $buffer, $size, $type, $stride, $offset);
}

function glVertexArrayTexCoordOffsetEXT(int $vaobj, int $buffer, int $size, int $type, int $stride, int $offset) {
  static $proc;
  return ($proc ??= GL::getProcAddress('vertexArrayTexCoordOffsetEXT'))($vaobj, $buffer, $size, $type, $stride, $offset);
}

function glVertexArrayVertexAttribBindingEXT(int $vaobj, int $attribindex, int $bindingindex) {
  static $proc;
  return ($proc ??= GL::getProcAddress('vertexArrayVertexAttribBindingEXT'))($vaobj, $attribindex, $bindingindex);
}

function glVertexArrayVertexAttribDivisorEXT(int $vaobj, int $index, int $divisor) {
  static $proc;
  return ($proc ??= GL::getProcAddress('vertexArrayVertexAttribDivisorEXT'))($vaobj, $index, $divisor);
}

function glVertexArrayVertexAttribFormatEXT(int $vaobj, int $attribindex, int $size, int $type, int $normalized, int $relativeoffset) {
  static $proc;
  return ($proc ??= GL::getProcAddress('vertexArrayVertexAttribFormatEXT'))($vaobj, $attribindex, $size, $type, $normalized, $relativeoffset);
}

function glVertexArrayVertexAttribIFormatEXT(int $vaobj, int $attribindex, int $size, int $type, int $relativeoffset) {
  static $proc;
  return ($proc ??= GL::getProcAddress('vertexArrayVertexAttribIFormatEXT'))($vaobj, $attribindex, $size, $type, $relativeoffset);
}

function glVertexArrayVertexAttribIOffsetEXT(int $vaobj, int $buffer, int $index, int $size, int $type, int $stride, int $offset) {
  static $proc;
  return ($proc ??= GL::getProcAddress('vertexArrayVertexAttribIOffsetEXT'))($vaobj, $buffer, $index, $size, $type, $stride, $offset);
}

function glVertexArrayVertexAttribLFormatEXT(int $vaobj, int $attribindex, int $size, int $type, int $relativeoffset) {
  static $proc;
  return ($proc ??= GL::getProcAddress('vertexArrayVertexAttribLFormatEXT'))($vaobj, $attribindex, $size, $type, $relativeoffset);
}

function glVertexArrayVertexAttribLOffsetEXT(int $vaobj, int $buffer, int $index, int $size, int $type, int $stride, int $offset) {
  static $proc;
  return ($proc ??= GL::getProcAddress('vertexArrayVertexAttribLOffsetEXT'))($vaobj, $buffer, $index, $size, $type, $stride, $offset);
}

function glVertexArrayVertexAttribOffsetEXT(int $vaobj, int $buffer, int $index, int $size, int $type, int $normalized, int $stride, int $offset) {
  static $proc;
  return ($proc ??= GL::getProcAddress('vertexArrayVertexAttribOffsetEXT'))($vaobj, $buffer, $index, $size, $type, $normalized, $stride, $offset);
}

function glVertexArrayVertexBindingDivisorEXT(int $vaobj, int $bindingindex, int $divisor) {
  static $proc;
  return ($proc ??= GL::getProcAddress('vertexArrayVertexBindingDivisorEXT'))($vaobj, $bindingindex, $divisor);
}

function glVertexArrayVertexBuffer(int $vaobj, int $bindingindex, int $buffer, int $offset, int $stride) {
  static $proc;
  return ($proc ??= GL::getProcAddress('vertexArrayVertexBuffer'))($vaobj, $bindingindex, $buffer, $offset, $stride);
}

function glVertexArrayVertexBuffers(int $vaobj, int $first, int $count, $buffers, $offsets, $strides) {
  static $proc;
  return ($proc ??= GL::getProcAddress('vertexArrayVertexBuffers'))($vaobj, $first, $count, $buffers, $offsets, $strides);
}

function glVertexArrayVertexOffsetEXT(int $vaobj, int $buffer, int $size, int $type, int $stride, int $offset) {
  static $proc;
  return ($proc ??= GL::getProcAddress('vertexArrayVertexOffsetEXT'))($vaobj, $buffer, $size, $type, $stride, $offset);
}

function glVertexAttrib1d(int $index, float $x) {
  static $proc;
  return ($proc ??= GL::getProcAddress('vertexAttrib1d'))($index, $x);
}

function glVertexAttrib1dARB(int $index, float $x) {
  static $proc;
  return ($proc ??= GL::getProcAddress('vertexAttrib1dARB'))($index, $x);
}

function glVertexAttrib1dNV(int $index, float $x) {
  static $proc;
  return ($proc ??= GL::getProcAddress('vertexAttrib1dNV'))($index, $x);
}

function glVertexAttrib1dv(int $index, $v) {
  static $proc;
  return ($proc ??= GL::getProcAddress('vertexAttrib1dv'))($index, $v);
}

function glVertexAttrib1dvARB(int $index, $v) {
  static $proc;
  return ($proc ??= GL::getProcAddress('vertexAttrib1dvARB'))($index, $v);
}

function glVertexAttrib1dvNV(int $index, $v) {
  static $proc;
  return ($proc ??= GL::getProcAddress('vertexAttrib1dvNV'))($index, $v);
}

function glVertexAttrib1f(int $index, float $x) {
  static $proc;
  return ($proc ??= GL::getProcAddress('vertexAttrib1f'))($index, $x);
}

function glVertexAttrib1fARB(int $index, float $x) {
  static $proc;
  return ($proc ??= GL::getProcAddress('vertexAttrib1fARB'))($index, $x);
}

function glVertexAttrib1fNV(int $index, float $x) {
  static $proc;
  return ($proc ??= GL::getProcAddress('vertexAttrib1fNV'))($index, $x);
}

function glVertexAttrib1fv(int $index, $v) {
  static $proc;
  return ($proc ??= GL::getProcAddress('vertexAttrib1fv'))($index, $v);
}

function glVertexAttrib1fvARB(int $index, $v) {
  static $proc;
  return ($proc ??= GL::getProcAddress('vertexAttrib1fvARB'))($index, $v);
}

function glVertexAttrib1fvNV(int $index, $v) {
  static $proc;
  return ($proc ??= GL::getProcAddress('vertexAttrib1fvNV'))($index, $v);
}

function glVertexAttrib1hNV(int $index, int $x) {
  static $proc;
  return ($proc ??= GL::getProcAddress('vertexAttrib1hNV'))($index, $x);
}

function glVertexAttrib1hvNV(int $index, $v) {
  static $proc;
  return ($proc ??= GL::getProcAddress('vertexAttrib1hvNV'))($index, $v);
}

function glVertexAttrib1s(int $index, int $x) {
  static $proc;
  return ($proc ??= GL::getProcAddress('vertexAttrib1s'))($index, $x);
}

function glVertexAttrib1sARB(int $index, int $x) {
  static $proc;
  return ($proc ??= GL::getProcAddress('vertexAttrib1sARB'))($index, $x);
}

function glVertexAttrib1sNV(int $index, int $x) {
  static $proc;
  return ($proc ??= GL::getProcAddress('vertexAttrib1sNV'))($index, $x);
}

function glVertexAttrib1sv(int $index, $v) {
  static $proc;
  return ($proc ??= GL::getProcAddress('vertexAttrib1sv'))($index, $v);
}

function glVertexAttrib1svARB(int $index, $v) {
  static $proc;
  return ($proc ??= GL::getProcAddress('vertexAttrib1svARB'))($index, $v);
}

function glVertexAttrib1svNV(int $index, $v) {
  static $proc;
  return ($proc ??= GL::getProcAddress('vertexAttrib1svNV'))($index, $v);
}

function glVertexAttrib2d(int $index, float $x, float $y) {
  static $proc;
  return ($proc ??= GL::getProcAddress('vertexAttrib2d'))($index, $x, $y);
}

function glVertexAttrib2dARB(int $index, float $x, float $y) {
  static $proc;
  return ($proc ??= GL::getProcAddress('vertexAttrib2dARB'))($index, $x, $y);
}

function glVertexAttrib2dNV(int $index, float $x, float $y) {
  static $proc;
  return ($proc ??= GL::getProcAddress('vertexAttrib2dNV'))($index, $x, $y);
}

function glVertexAttrib2dv(int $index, $v) {
  static $proc;
  return ($proc ??= GL::getProcAddress('vertexAttrib2dv'))($index, $v);
}

function glVertexAttrib2dvARB(int $index, $v) {
  static $proc;
  return ($proc ??= GL::getProcAddress('vertexAttrib2dvARB'))($index, $v);
}

function glVertexAttrib2dvNV(int $index, $v) {
  static $proc;
  return ($proc ??= GL::getProcAddress('vertexAttrib2dvNV'))($index, $v);
}

function glVertexAttrib2f(int $index, float $x, float $y) {
  static $proc;
  return ($proc ??= GL::getProcAddress('vertexAttrib2f'))($index, $x, $y);
}

function glVertexAttrib2fARB(int $index, float $x, float $y) {
  static $proc;
  return ($proc ??= GL::getProcAddress('vertexAttrib2fARB'))($index, $x, $y);
}

function glVertexAttrib2fNV(int $index, float $x, float $y) {
  static $proc;
  return ($proc ??= GL::getProcAddress('vertexAttrib2fNV'))($index, $x, $y);
}

function glVertexAttrib2fv(int $index, $v) {
  static $proc;
  return ($proc ??= GL::getProcAddress('vertexAttrib2fv'))($index, $v);
}

function glVertexAttrib2fvARB(int $index, $v) {
  static $proc;
  return ($proc ??= GL::getProcAddress('vertexAttrib2fvARB'))($index, $v);
}

function glVertexAttrib2fvNV(int $index, $v) {
  static $proc;
  return ($proc ??= GL::getProcAddress('vertexAttrib2fvNV'))($index, $v);
}

function glVertexAttrib2hNV(int $index, int $x, int $y) {
  static $proc;
  return ($proc ??= GL::getProcAddress('vertexAttrib2hNV'))($index, $x, $y);
}

function glVertexAttrib2hvNV(int $index, $v) {
  static $proc;
  return ($proc ??= GL::getProcAddress('vertexAttrib2hvNV'))($index, $v);
}

function glVertexAttrib2s(int $index, int $x, int $y) {
  static $proc;
  return ($proc ??= GL::getProcAddress('vertexAttrib2s'))($index, $x, $y);
}

function glVertexAttrib2sARB(int $index, int $x, int $y) {
  static $proc;
  return ($proc ??= GL::getProcAddress('vertexAttrib2sARB'))($index, $x, $y);
}

function glVertexAttrib2sNV(int $index, int $x, int $y) {
  static $proc;
  return ($proc ??= GL::getProcAddress('vertexAttrib2sNV'))($index, $x, $y);
}

function glVertexAttrib2sv(int $index, $v) {
  static $proc;
  return ($proc ??= GL::getProcAddress('vertexAttrib2sv'))($index, $v);
}

function glVertexAttrib2svARB(int $index, $v) {
  static $proc;
  return ($proc ??= GL::getProcAddress('vertexAttrib2svARB'))($index, $v);
}

function glVertexAttrib2svNV(int $index, $v) {
  static $proc;
  return ($proc ??= GL::getProcAddress('vertexAttrib2svNV'))($index, $v);
}

function glVertexAttrib3d(int $index, float $x, float $y, float $z) {
  static $proc;
  return ($proc ??= GL::getProcAddress('vertexAttrib3d'))($index, $x, $y, $z);
}

function glVertexAttrib3dARB(int $index, float $x, float $y, float $z) {
  static $proc;
  return ($proc ??= GL::getProcAddress('vertexAttrib3dARB'))($index, $x, $y, $z);
}

function glVertexAttrib3dNV(int $index, float $x, float $y, float $z) {
  static $proc;
  return ($proc ??= GL::getProcAddress('vertexAttrib3dNV'))($index, $x, $y, $z);
}

function glVertexAttrib3dv(int $index, $v) {
  static $proc;
  return ($proc ??= GL::getProcAddress('vertexAttrib3dv'))($index, $v);
}

function glVertexAttrib3dvARB(int $index, $v) {
  static $proc;
  return ($proc ??= GL::getProcAddress('vertexAttrib3dvARB'))($index, $v);
}

function glVertexAttrib3dvNV(int $index, $v) {
  static $proc;
  return ($proc ??= GL::getProcAddress('vertexAttrib3dvNV'))($index, $v);
}

function glVertexAttrib3f(int $index, float $x, float $y, float $z) {
  static $proc;
  return ($proc ??= GL::getProcAddress('vertexAttrib3f'))($index, $x, $y, $z);
}

function glVertexAttrib3fARB(int $index, float $x, float $y, float $z) {
  static $proc;
  return ($proc ??= GL::getProcAddress('vertexAttrib3fARB'))($index, $x, $y, $z);
}

function glVertexAttrib3fNV(int $index, float $x, float $y, float $z) {
  static $proc;
  return ($proc ??= GL::getProcAddress('vertexAttrib3fNV'))($index, $x, $y, $z);
}

function glVertexAttrib3fv(int $index, $v) {
  static $proc;
  return ($proc ??= GL::getProcAddress('vertexAttrib3fv'))($index, $v);
}

function glVertexAttrib3fvARB(int $index, $v) {
  static $proc;
  return ($proc ??= GL::getProcAddress('vertexAttrib3fvARB'))($index, $v);
}

function glVertexAttrib3fvNV(int $index, $v) {
  static $proc;
  return ($proc ??= GL::getProcAddress('vertexAttrib3fvNV'))($index, $v);
}

function glVertexAttrib3hNV(int $index, int $x, int $y, int $z) {
  static $proc;
  return ($proc ??= GL::getProcAddress('vertexAttrib3hNV'))($index, $x, $y, $z);
}

function glVertexAttrib3hvNV(int $index, $v) {
  static $proc;
  return ($proc ??= GL::getProcAddress('vertexAttrib3hvNV'))($index, $v);
}

function glVertexAttrib3s(int $index, int $x, int $y, int $z) {
  static $proc;
  return ($proc ??= GL::getProcAddress('vertexAttrib3s'))($index, $x, $y, $z);
}

function glVertexAttrib3sARB(int $index, int $x, int $y, int $z) {
  static $proc;
  return ($proc ??= GL::getProcAddress('vertexAttrib3sARB'))($index, $x, $y, $z);
}

function glVertexAttrib3sNV(int $index, int $x, int $y, int $z) {
  static $proc;
  return ($proc ??= GL::getProcAddress('vertexAttrib3sNV'))($index, $x, $y, $z);
}

function glVertexAttrib3sv(int $index, $v) {
  static $proc;
  return ($proc ??= GL::getProcAddress('vertexAttrib3sv'))($index, $v);
}

function glVertexAttrib3svARB(int $index, $v) {
  static $proc;
  return ($proc ??= GL::getProcAddress('vertexAttrib3svARB'))($index, $v);
}

function glVertexAttrib3svNV(int $index, $v) {
  static $proc;
  return ($proc ??= GL::getProcAddress('vertexAttrib3svNV'))($index, $v);
}

function glVertexAttrib4Nbv(int $index, $v) {
  static $proc;
  return ($proc ??= GL::getProcAddress('vertexAttrib4Nbv'))($index, $v);
}

function glVertexAttrib4NbvARB(int $index, $v) {
  static $proc;
  return ($proc ??= GL::getProcAddress('vertexAttrib4NbvARB'))($index, $v);
}

function glVertexAttrib4Niv(int $index, $v) {
  static $proc;
  return ($proc ??= GL::getProcAddress('vertexAttrib4Niv'))($index, $v);
}

function glVertexAttrib4NivARB(int $index, $v) {
  static $proc;
  return ($proc ??= GL::getProcAddress('vertexAttrib4NivARB'))($index, $v);
}

function glVertexAttrib4Nsv(int $index, $v) {
  static $proc;
  return ($proc ??= GL::getProcAddress('vertexAttrib4Nsv'))($index, $v);
}

function glVertexAttrib4NsvARB(int $index, $v) {
  static $proc;
  return ($proc ??= GL::getProcAddress('vertexAttrib4NsvARB'))($index, $v);
}

function glVertexAttrib4Nub(int $index, int $x, int $y, int $z, int $w) {
  static $proc;
  return ($proc ??= GL::getProcAddress('vertexAttrib4Nub'))($index, $x, $y, $z, $w);
}

function glVertexAttrib4NubARB(int $index, int $x, int $y, int $z, int $w) {
  static $proc;
  return ($proc ??= GL::getProcAddress('vertexAttrib4NubARB'))($index, $x, $y, $z, $w);
}

function glVertexAttrib4Nubv(int $index, $v) {
  static $proc;
  return ($proc ??= GL::getProcAddress('vertexAttrib4Nubv'))($index, $v);
}

function glVertexAttrib4NubvARB(int $index, $v) {
  static $proc;
  return ($proc ??= GL::getProcAddress('vertexAttrib4NubvARB'))($index, $v);
}

function glVertexAttrib4Nuiv(int $index, $v) {
  static $proc;
  return ($proc ??= GL::getProcAddress('vertexAttrib4Nuiv'))($index, $v);
}

function glVertexAttrib4NuivARB(int $index, $v) {
  static $proc;
  return ($proc ??= GL::getProcAddress('vertexAttrib4NuivARB'))($index, $v);
}

function glVertexAttrib4Nusv(int $index, $v) {
  static $proc;
  return ($proc ??= GL::getProcAddress('vertexAttrib4Nusv'))($index, $v);
}

function glVertexAttrib4NusvARB(int $index, $v) {
  static $proc;
  return ($proc ??= GL::getProcAddress('vertexAttrib4NusvARB'))($index, $v);
}

function glVertexAttrib4bv(int $index, $v) {
  static $proc;
  return ($proc ??= GL::getProcAddress('vertexAttrib4bv'))($index, $v);
}

function glVertexAttrib4bvARB(int $index, $v) {
  static $proc;
  return ($proc ??= GL::getProcAddress('vertexAttrib4bvARB'))($index, $v);
}

function glVertexAttrib4d(int $index, float $x, float $y, float $z, float $w) {
  static $proc;
  return ($proc ??= GL::getProcAddress('vertexAttrib4d'))($index, $x, $y, $z, $w);
}

function glVertexAttrib4dARB(int $index, float $x, float $y, float $z, float $w) {
  static $proc;
  return ($proc ??= GL::getProcAddress('vertexAttrib4dARB'))($index, $x, $y, $z, $w);
}

function glVertexAttrib4dNV(int $index, float $x, float $y, float $z, float $w) {
  static $proc;
  return ($proc ??= GL::getProcAddress('vertexAttrib4dNV'))($index, $x, $y, $z, $w);
}

function glVertexAttrib4dv(int $index, $v) {
  static $proc;
  return ($proc ??= GL::getProcAddress('vertexAttrib4dv'))($index, $v);
}

function glVertexAttrib4dvARB(int $index, $v) {
  static $proc;
  return ($proc ??= GL::getProcAddress('vertexAttrib4dvARB'))($index, $v);
}

function glVertexAttrib4dvNV(int $index, $v) {
  static $proc;
  return ($proc ??= GL::getProcAddress('vertexAttrib4dvNV'))($index, $v);
}

function glVertexAttrib4f(int $index, float $x, float $y, float $z, float $w) {
  static $proc;
  return ($proc ??= GL::getProcAddress('vertexAttrib4f'))($index, $x, $y, $z, $w);
}

function glVertexAttrib4fARB(int $index, float $x, float $y, float $z, float $w) {
  static $proc;
  return ($proc ??= GL::getProcAddress('vertexAttrib4fARB'))($index, $x, $y, $z, $w);
}

function glVertexAttrib4fNV(int $index, float $x, float $y, float $z, float $w) {
  static $proc;
  return ($proc ??= GL::getProcAddress('vertexAttrib4fNV'))($index, $x, $y, $z, $w);
}

function glVertexAttrib4fv(int $index, $v) {
  static $proc;
  return ($proc ??= GL::getProcAddress('vertexAttrib4fv'))($index, $v);
}

function glVertexAttrib4fvARB(int $index, $v) {
  static $proc;
  return ($proc ??= GL::getProcAddress('vertexAttrib4fvARB'))($index, $v);
}

function glVertexAttrib4fvNV(int $index, $v) {
  static $proc;
  return ($proc ??= GL::getProcAddress('vertexAttrib4fvNV'))($index, $v);
}

function glVertexAttrib4hNV(int $index, int $x, int $y, int $z, int $w) {
  static $proc;
  return ($proc ??= GL::getProcAddress('vertexAttrib4hNV'))($index, $x, $y, $z, $w);
}

function glVertexAttrib4hvNV(int $index, $v) {
  static $proc;
  return ($proc ??= GL::getProcAddress('vertexAttrib4hvNV'))($index, $v);
}

function glVertexAttrib4iv(int $index, $v) {
  static $proc;
  return ($proc ??= GL::getProcAddress('vertexAttrib4iv'))($index, $v);
}

function glVertexAttrib4ivARB(int $index, $v) {
  static $proc;
  return ($proc ??= GL::getProcAddress('vertexAttrib4ivARB'))($index, $v);
}

function glVertexAttrib4s(int $index, int $x, int $y, int $z, int $w) {
  static $proc;
  return ($proc ??= GL::getProcAddress('vertexAttrib4s'))($index, $x, $y, $z, $w);
}

function glVertexAttrib4sARB(int $index, int $x, int $y, int $z, int $w) {
  static $proc;
  return ($proc ??= GL::getProcAddress('vertexAttrib4sARB'))($index, $x, $y, $z, $w);
}

function glVertexAttrib4sNV(int $index, int $x, int $y, int $z, int $w) {
  static $proc;
  return ($proc ??= GL::getProcAddress('vertexAttrib4sNV'))($index, $x, $y, $z, $w);
}

function glVertexAttrib4sv(int $index, $v) {
  static $proc;
  return ($proc ??= GL::getProcAddress('vertexAttrib4sv'))($index, $v);
}

function glVertexAttrib4svARB(int $index, $v) {
  static $proc;
  return ($proc ??= GL::getProcAddress('vertexAttrib4svARB'))($index, $v);
}

function glVertexAttrib4svNV(int $index, $v) {
  static $proc;
  return ($proc ??= GL::getProcAddress('vertexAttrib4svNV'))($index, $v);
}

function glVertexAttrib4ubNV(int $index, int $x, int $y, int $z, int $w) {
  static $proc;
  return ($proc ??= GL::getProcAddress('vertexAttrib4ubNV'))($index, $x, $y, $z, $w);
}

function glVertexAttrib4ubv(int $index, $v) {
  static $proc;
  return ($proc ??= GL::getProcAddress('vertexAttrib4ubv'))($index, $v);
}

function glVertexAttrib4ubvARB(int $index, $v) {
  static $proc;
  return ($proc ??= GL::getProcAddress('vertexAttrib4ubvARB'))($index, $v);
}

function glVertexAttrib4ubvNV(int $index, $v) {
  static $proc;
  return ($proc ??= GL::getProcAddress('vertexAttrib4ubvNV'))($index, $v);
}

function glVertexAttrib4uiv(int $index, $v) {
  static $proc;
  return ($proc ??= GL::getProcAddress('vertexAttrib4uiv'))($index, $v);
}

function glVertexAttrib4uivARB(int $index, $v) {
  static $proc;
  return ($proc ??= GL::getProcAddress('vertexAttrib4uivARB'))($index, $v);
}

function glVertexAttrib4usv(int $index, $v) {
  static $proc;
  return ($proc ??= GL::getProcAddress('vertexAttrib4usv'))($index, $v);
}

function glVertexAttrib4usvARB(int $index, $v) {
  static $proc;
  return ($proc ??= GL::getProcAddress('vertexAttrib4usvARB'))($index, $v);
}

function glVertexAttribArrayObjectATI(int $index, int $size, int $type, int $normalized, int $stride, int $buffer, int $offset) {
  static $proc;
  return ($proc ??= GL::getProcAddress('vertexAttribArrayObjectATI'))($index, $size, $type, $normalized, $stride, $buffer, $offset);
}

function glVertexAttribBinding(int $attribindex, int $bindingindex) {
  static $proc;
  return ($proc ??= GL::getProcAddress('vertexAttribBinding'))($attribindex, $bindingindex);
}

function glVertexAttribDivisor(int $index, int $divisor) {
  static $proc;
  return ($proc ??= GL::getProcAddress('vertexAttribDivisor'))($index, $divisor);
}

function glVertexAttribDivisorANGLE(int $index, int $divisor) {
  static $proc;
  return ($proc ??= GL::getProcAddress('vertexAttribDivisorANGLE'))($index, $divisor);
}

function glVertexAttribDivisorARB(int $index, int $divisor) {
  static $proc;
  return ($proc ??= GL::getProcAddress('vertexAttribDivisorARB'))($index, $divisor);
}

function glVertexAttribDivisorEXT(int $index, int $divisor) {
  static $proc;
  return ($proc ??= GL::getProcAddress('vertexAttribDivisorEXT'))($index, $divisor);
}

function glVertexAttribDivisorNV(int $index, int $divisor) {
  static $proc;
  return ($proc ??= GL::getProcAddress('vertexAttribDivisorNV'))($index, $divisor);
}

function glVertexAttribFormat(int $attribindex, int $size, int $type, int $normalized, int $relativeoffset) {
  static $proc;
  return ($proc ??= GL::getProcAddress('vertexAttribFormat'))($attribindex, $size, $type, $normalized, $relativeoffset);
}

function glVertexAttribFormatNV(int $index, int $size, int $type, int $normalized, int $stride) {
  static $proc;
  return ($proc ??= GL::getProcAddress('vertexAttribFormatNV'))($index, $size, $type, $normalized, $stride);
}

function glVertexAttribI1i(int $index, int $x) {
  static $proc;
  return ($proc ??= GL::getProcAddress('vertexAttribI1i'))($index, $x);
}

function glVertexAttribI1iEXT(int $index, int $x) {
  static $proc;
  return ($proc ??= GL::getProcAddress('vertexAttribI1iEXT'))($index, $x);
}

function glVertexAttribI1iv(int $index, $v) {
  static $proc;
  return ($proc ??= GL::getProcAddress('vertexAttribI1iv'))($index, $v);
}

function glVertexAttribI1ivEXT(int $index, $v) {
  static $proc;
  return ($proc ??= GL::getProcAddress('vertexAttribI1ivEXT'))($index, $v);
}

function glVertexAttribI1ui(int $index, int $x) {
  static $proc;
  return ($proc ??= GL::getProcAddress('vertexAttribI1ui'))($index, $x);
}

function glVertexAttribI1uiEXT(int $index, int $x) {
  static $proc;
  return ($proc ??= GL::getProcAddress('vertexAttribI1uiEXT'))($index, $x);
}

function glVertexAttribI1uiv(int $index, $v) {
  static $proc;
  return ($proc ??= GL::getProcAddress('vertexAttribI1uiv'))($index, $v);
}

function glVertexAttribI1uivEXT(int $index, $v) {
  static $proc;
  return ($proc ??= GL::getProcAddress('vertexAttribI1uivEXT'))($index, $v);
}

function glVertexAttribI2i(int $index, int $x, int $y) {
  static $proc;
  return ($proc ??= GL::getProcAddress('vertexAttribI2i'))($index, $x, $y);
}

function glVertexAttribI2iEXT(int $index, int $x, int $y) {
  static $proc;
  return ($proc ??= GL::getProcAddress('vertexAttribI2iEXT'))($index, $x, $y);
}

function glVertexAttribI2iv(int $index, $v) {
  static $proc;
  return ($proc ??= GL::getProcAddress('vertexAttribI2iv'))($index, $v);
}

function glVertexAttribI2ivEXT(int $index, $v) {
  static $proc;
  return ($proc ??= GL::getProcAddress('vertexAttribI2ivEXT'))($index, $v);
}

function glVertexAttribI2ui(int $index, int $x, int $y) {
  static $proc;
  return ($proc ??= GL::getProcAddress('vertexAttribI2ui'))($index, $x, $y);
}

function glVertexAttribI2uiEXT(int $index, int $x, int $y) {
  static $proc;
  return ($proc ??= GL::getProcAddress('vertexAttribI2uiEXT'))($index, $x, $y);
}

function glVertexAttribI2uiv(int $index, $v) {
  static $proc;
  return ($proc ??= GL::getProcAddress('vertexAttribI2uiv'))($index, $v);
}

function glVertexAttribI2uivEXT(int $index, $v) {
  static $proc;
  return ($proc ??= GL::getProcAddress('vertexAttribI2uivEXT'))($index, $v);
}

function glVertexAttribI3i(int $index, int $x, int $y, int $z) {
  static $proc;
  return ($proc ??= GL::getProcAddress('vertexAttribI3i'))($index, $x, $y, $z);
}

function glVertexAttribI3iEXT(int $index, int $x, int $y, int $z) {
  static $proc;
  return ($proc ??= GL::getProcAddress('vertexAttribI3iEXT'))($index, $x, $y, $z);
}

function glVertexAttribI3iv(int $index, $v) {
  static $proc;
  return ($proc ??= GL::getProcAddress('vertexAttribI3iv'))($index, $v);
}

function glVertexAttribI3ivEXT(int $index, $v) {
  static $proc;
  return ($proc ??= GL::getProcAddress('vertexAttribI3ivEXT'))($index, $v);
}

function glVertexAttribI3ui(int $index, int $x, int $y, int $z) {
  static $proc;
  return ($proc ??= GL::getProcAddress('vertexAttribI3ui'))($index, $x, $y, $z);
}

function glVertexAttribI3uiEXT(int $index, int $x, int $y, int $z) {
  static $proc;
  return ($proc ??= GL::getProcAddress('vertexAttribI3uiEXT'))($index, $x, $y, $z);
}

function glVertexAttribI3uiv(int $index, $v) {
  static $proc;
  return ($proc ??= GL::getProcAddress('vertexAttribI3uiv'))($index, $v);
}

function glVertexAttribI3uivEXT(int $index, $v) {
  static $proc;
  return ($proc ??= GL::getProcAddress('vertexAttribI3uivEXT'))($index, $v);
}

function glVertexAttribI4bv(int $index, $v) {
  static $proc;
  return ($proc ??= GL::getProcAddress('vertexAttribI4bv'))($index, $v);
}

function glVertexAttribI4bvEXT(int $index, $v) {
  static $proc;
  return ($proc ??= GL::getProcAddress('vertexAttribI4bvEXT'))($index, $v);
}

function glVertexAttribI4i(int $index, int $x, int $y, int $z, int $w) {
  static $proc;
  return ($proc ??= GL::getProcAddress('vertexAttribI4i'))($index, $x, $y, $z, $w);
}

function glVertexAttribI4iEXT(int $index, int $x, int $y, int $z, int $w) {
  static $proc;
  return ($proc ??= GL::getProcAddress('vertexAttribI4iEXT'))($index, $x, $y, $z, $w);
}

function glVertexAttribI4iv(int $index, $v) {
  static $proc;
  return ($proc ??= GL::getProcAddress('vertexAttribI4iv'))($index, $v);
}

function glVertexAttribI4ivEXT(int $index, $v) {
  static $proc;
  return ($proc ??= GL::getProcAddress('vertexAttribI4ivEXT'))($index, $v);
}

function glVertexAttribI4sv(int $index, $v) {
  static $proc;
  return ($proc ??= GL::getProcAddress('vertexAttribI4sv'))($index, $v);
}

function glVertexAttribI4svEXT(int $index, $v) {
  static $proc;
  return ($proc ??= GL::getProcAddress('vertexAttribI4svEXT'))($index, $v);
}

function glVertexAttribI4ubv(int $index, $v) {
  static $proc;
  return ($proc ??= GL::getProcAddress('vertexAttribI4ubv'))($index, $v);
}

function glVertexAttribI4ubvEXT(int $index, $v) {
  static $proc;
  return ($proc ??= GL::getProcAddress('vertexAttribI4ubvEXT'))($index, $v);
}

function glVertexAttribI4ui(int $index, int $x, int $y, int $z, int $w) {
  static $proc;
  return ($proc ??= GL::getProcAddress('vertexAttribI4ui'))($index, $x, $y, $z, $w);
}

function glVertexAttribI4uiEXT(int $index, int $x, int $y, int $z, int $w) {
  static $proc;
  return ($proc ??= GL::getProcAddress('vertexAttribI4uiEXT'))($index, $x, $y, $z, $w);
}

function glVertexAttribI4uiv(int $index, $v) {
  static $proc;
  return ($proc ??= GL::getProcAddress('vertexAttribI4uiv'))($index, $v);
}

function glVertexAttribI4uivEXT(int $index, $v) {
  static $proc;
  return ($proc ??= GL::getProcAddress('vertexAttribI4uivEXT'))($index, $v);
}

function glVertexAttribI4usv(int $index, $v) {
  static $proc;
  return ($proc ??= GL::getProcAddress('vertexAttribI4usv'))($index, $v);
}

function glVertexAttribI4usvEXT(int $index, $v) {
  static $proc;
  return ($proc ??= GL::getProcAddress('vertexAttribI4usvEXT'))($index, $v);
}

function glVertexAttribIFormat(int $attribindex, int $size, int $type, int $relativeoffset) {
  static $proc;
  return ($proc ??= GL::getProcAddress('vertexAttribIFormat'))($attribindex, $size, $type, $relativeoffset);
}

function glVertexAttribIFormatNV(int $index, int $size, int $type, int $stride) {
  static $proc;
  return ($proc ??= GL::getProcAddress('vertexAttribIFormatNV'))($index, $size, $type, $stride);
}

function glVertexAttribIPointer(int $index, int $size, int $type, int $stride, $pointer) {
  static $proc;
  return ($proc ??= GL::getProcAddress('vertexAttribIPointer'))($index, $size, $type, $stride, $pointer);
}

function glVertexAttribIPointerEXT(int $index, int $size, int $type, int $stride, $pointer) {
  static $proc;
  return ($proc ??= GL::getProcAddress('vertexAttribIPointerEXT'))($index, $size, $type, $stride, $pointer);
}

function glVertexAttribL1d(int $index, float $x) {
  static $proc;
  return ($proc ??= GL::getProcAddress('vertexAttribL1d'))($index, $x);
}

function glVertexAttribL1dEXT(int $index, float $x) {
  static $proc;
  return ($proc ??= GL::getProcAddress('vertexAttribL1dEXT'))($index, $x);
}

function glVertexAttribL1dv(int $index, $v) {
  static $proc;
  return ($proc ??= GL::getProcAddress('vertexAttribL1dv'))($index, $v);
}

function glVertexAttribL1dvEXT(int $index, $v) {
  static $proc;
  return ($proc ??= GL::getProcAddress('vertexAttribL1dvEXT'))($index, $v);
}

function glVertexAttribL1i64NV(int $index, int $x) {
  static $proc;
  return ($proc ??= GL::getProcAddress('vertexAttribL1i64NV'))($index, $x);
}

function glVertexAttribL1i64vNV(int $index, $v) {
  static $proc;
  return ($proc ??= GL::getProcAddress('vertexAttribL1i64vNV'))($index, $v);
}

function glVertexAttribL1ui64ARB(int $index, int $x) {
  static $proc;
  return ($proc ??= GL::getProcAddress('vertexAttribL1ui64ARB'))($index, $x);
}

function glVertexAttribL1ui64NV(int $index, int $x) {
  static $proc;
  return ($proc ??= GL::getProcAddress('vertexAttribL1ui64NV'))($index, $x);
}

function glVertexAttribL1ui64vARB(int $index, $v) {
  static $proc;
  return ($proc ??= GL::getProcAddress('vertexAttribL1ui64vARB'))($index, $v);
}

function glVertexAttribL1ui64vNV(int $index, $v) {
  static $proc;
  return ($proc ??= GL::getProcAddress('vertexAttribL1ui64vNV'))($index, $v);
}

function glVertexAttribL2d(int $index, float $x, float $y) {
  static $proc;
  return ($proc ??= GL::getProcAddress('vertexAttribL2d'))($index, $x, $y);
}

function glVertexAttribL2dEXT(int $index, float $x, float $y) {
  static $proc;
  return ($proc ??= GL::getProcAddress('vertexAttribL2dEXT'))($index, $x, $y);
}

function glVertexAttribL2dv(int $index, $v) {
  static $proc;
  return ($proc ??= GL::getProcAddress('vertexAttribL2dv'))($index, $v);
}

function glVertexAttribL2dvEXT(int $index, $v) {
  static $proc;
  return ($proc ??= GL::getProcAddress('vertexAttribL2dvEXT'))($index, $v);
}

function glVertexAttribL2i64NV(int $index, int $x, int $y) {
  static $proc;
  return ($proc ??= GL::getProcAddress('vertexAttribL2i64NV'))($index, $x, $y);
}

function glVertexAttribL2i64vNV(int $index, $v) {
  static $proc;
  return ($proc ??= GL::getProcAddress('vertexAttribL2i64vNV'))($index, $v);
}

function glVertexAttribL2ui64NV(int $index, int $x, int $y) {
  static $proc;
  return ($proc ??= GL::getProcAddress('vertexAttribL2ui64NV'))($index, $x, $y);
}

function glVertexAttribL2ui64vNV(int $index, $v) {
  static $proc;
  return ($proc ??= GL::getProcAddress('vertexAttribL2ui64vNV'))($index, $v);
}

function glVertexAttribL3d(int $index, float $x, float $y, float $z) {
  static $proc;
  return ($proc ??= GL::getProcAddress('vertexAttribL3d'))($index, $x, $y, $z);
}

function glVertexAttribL3dEXT(int $index, float $x, float $y, float $z) {
  static $proc;
  return ($proc ??= GL::getProcAddress('vertexAttribL3dEXT'))($index, $x, $y, $z);
}

function glVertexAttribL3dv(int $index, $v) {
  static $proc;
  return ($proc ??= GL::getProcAddress('vertexAttribL3dv'))($index, $v);
}

function glVertexAttribL3dvEXT(int $index, $v) {
  static $proc;
  return ($proc ??= GL::getProcAddress('vertexAttribL3dvEXT'))($index, $v);
}

function glVertexAttribL3i64NV(int $index, int $x, int $y, int $z) {
  static $proc;
  return ($proc ??= GL::getProcAddress('vertexAttribL3i64NV'))($index, $x, $y, $z);
}

function glVertexAttribL3i64vNV(int $index, $v) {
  static $proc;
  return ($proc ??= GL::getProcAddress('vertexAttribL3i64vNV'))($index, $v);
}

function glVertexAttribL3ui64NV(int $index, int $x, int $y, int $z) {
  static $proc;
  return ($proc ??= GL::getProcAddress('vertexAttribL3ui64NV'))($index, $x, $y, $z);
}

function glVertexAttribL3ui64vNV(int $index, $v) {
  static $proc;
  return ($proc ??= GL::getProcAddress('vertexAttribL3ui64vNV'))($index, $v);
}

function glVertexAttribL4d(int $index, float $x, float $y, float $z, float $w) {
  static $proc;
  return ($proc ??= GL::getProcAddress('vertexAttribL4d'))($index, $x, $y, $z, $w);
}

function glVertexAttribL4dEXT(int $index, float $x, float $y, float $z, float $w) {
  static $proc;
  return ($proc ??= GL::getProcAddress('vertexAttribL4dEXT'))($index, $x, $y, $z, $w);
}

function glVertexAttribL4dv(int $index, $v) {
  static $proc;
  return ($proc ??= GL::getProcAddress('vertexAttribL4dv'))($index, $v);
}

function glVertexAttribL4dvEXT(int $index, $v) {
  static $proc;
  return ($proc ??= GL::getProcAddress('vertexAttribL4dvEXT'))($index, $v);
}

function glVertexAttribL4i64NV(int $index, int $x, int $y, int $z, int $w) {
  static $proc;
  return ($proc ??= GL::getProcAddress('vertexAttribL4i64NV'))($index, $x, $y, $z, $w);
}

function glVertexAttribL4i64vNV(int $index, $v) {
  static $proc;
  return ($proc ??= GL::getProcAddress('vertexAttribL4i64vNV'))($index, $v);
}

function glVertexAttribL4ui64NV(int $index, int $x, int $y, int $z, int $w) {
  static $proc;
  return ($proc ??= GL::getProcAddress('vertexAttribL4ui64NV'))($index, $x, $y, $z, $w);
}

function glVertexAttribL4ui64vNV(int $index, $v) {
  static $proc;
  return ($proc ??= GL::getProcAddress('vertexAttribL4ui64vNV'))($index, $v);
}

function glVertexAttribLFormat(int $attribindex, int $size, int $type, int $relativeoffset) {
  static $proc;
  return ($proc ??= GL::getProcAddress('vertexAttribLFormat'))($attribindex, $size, $type, $relativeoffset);
}

function glVertexAttribLFormatNV(int $index, int $size, int $type, int $stride) {
  static $proc;
  return ($proc ??= GL::getProcAddress('vertexAttribLFormatNV'))($index, $size, $type, $stride);
}

function glVertexAttribLPointer(int $index, int $size, int $type, int $stride, $pointer) {
  static $proc;
  return ($proc ??= GL::getProcAddress('vertexAttribLPointer'))($index, $size, $type, $stride, $pointer);
}

function glVertexAttribLPointerEXT(int $index, int $size, int $type, int $stride, $pointer) {
  static $proc;
  return ($proc ??= GL::getProcAddress('vertexAttribLPointerEXT'))($index, $size, $type, $stride, $pointer);
}

function glVertexAttribP1ui(int $index, int $type, int $normalized, int $value) {
  static $proc;
  return ($proc ??= GL::getProcAddress('vertexAttribP1ui'))($index, $type, $normalized, $value);
}

function glVertexAttribP1uiv(int $index, int $type, int $normalized, $value) {
  static $proc;
  return ($proc ??= GL::getProcAddress('vertexAttribP1uiv'))($index, $type, $normalized, $value);
}

function glVertexAttribP2ui(int $index, int $type, int $normalized, int $value) {
  static $proc;
  return ($proc ??= GL::getProcAddress('vertexAttribP2ui'))($index, $type, $normalized, $value);
}

function glVertexAttribP2uiv(int $index, int $type, int $normalized, $value) {
  static $proc;
  return ($proc ??= GL::getProcAddress('vertexAttribP2uiv'))($index, $type, $normalized, $value);
}

function glVertexAttribP3ui(int $index, int $type, int $normalized, int $value) {
  static $proc;
  return ($proc ??= GL::getProcAddress('vertexAttribP3ui'))($index, $type, $normalized, $value);
}

function glVertexAttribP3uiv(int $index, int $type, int $normalized, $value) {
  static $proc;
  return ($proc ??= GL::getProcAddress('vertexAttribP3uiv'))($index, $type, $normalized, $value);
}

function glVertexAttribP4ui(int $index, int $type, int $normalized, int $value) {
  static $proc;
  return ($proc ??= GL::getProcAddress('vertexAttribP4ui'))($index, $type, $normalized, $value);
}

function glVertexAttribP4uiv(int $index, int $type, int $normalized, $value) {
  static $proc;
  return ($proc ??= GL::getProcAddress('vertexAttribP4uiv'))($index, $type, $normalized, $value);
}

function glVertexAttribParameteriAMD(int $index, int $pname, int $param) {
  static $proc;
  return ($proc ??= GL::getProcAddress('vertexAttribParameteriAMD'))($index, $pname, $param);
}

function glVertexAttribPointer(int $index, int $size, int $type, int $normalized, int $stride, int $pointer) {
  static $proc;
  return ($proc ??= GL::getProcAddress('vertexAttribPointer'))($index, $size, $type, $normalized, $stride, $pointer);
}

function glVertexAttribPointerARB(int $index, int $size, int $type, int $normalized, int $stride, $pointer) {
  static $proc;
  return ($proc ??= GL::getProcAddress('vertexAttribPointerARB'))($index, $size, $type, $normalized, $stride, $pointer);
}

function glVertexAttribPointerNV(int $index, int $fsize, int $type, int $stride, $pointer) {
  static $proc;
  return ($proc ??= GL::getProcAddress('vertexAttribPointerNV'))($index, $fsize, $type, $stride, $pointer);
}

function glVertexAttribs1dvNV(int $index, int $count, $v) {
  static $proc;
  return ($proc ??= GL::getProcAddress('vertexAttribs1dvNV'))($index, $count, $v);
}

function glVertexAttribs1fvNV(int $index, int $count, $v) {
  static $proc;
  return ($proc ??= GL::getProcAddress('vertexAttribs1fvNV'))($index, $count, $v);
}

function glVertexAttribs1hvNV(int $index, int $n, $v) {
  static $proc;
  return ($proc ??= GL::getProcAddress('vertexAttribs1hvNV'))($index, $n, $v);
}

function glVertexAttribs1svNV(int $index, int $count, $v) {
  static $proc;
  return ($proc ??= GL::getProcAddress('vertexAttribs1svNV'))($index, $count, $v);
}

function glVertexAttribs2dvNV(int $index, int $count, $v) {
  static $proc;
  return ($proc ??= GL::getProcAddress('vertexAttribs2dvNV'))($index, $count, $v);
}

function glVertexAttribs2fvNV(int $index, int $count, $v) {
  static $proc;
  return ($proc ??= GL::getProcAddress('vertexAttribs2fvNV'))($index, $count, $v);
}

function glVertexAttribs2hvNV(int $index, int $n, $v) {
  static $proc;
  return ($proc ??= GL::getProcAddress('vertexAttribs2hvNV'))($index, $n, $v);
}

function glVertexAttribs2svNV(int $index, int $count, $v) {
  static $proc;
  return ($proc ??= GL::getProcAddress('vertexAttribs2svNV'))($index, $count, $v);
}

function glVertexAttribs3dvNV(int $index, int $count, $v) {
  static $proc;
  return ($proc ??= GL::getProcAddress('vertexAttribs3dvNV'))($index, $count, $v);
}

function glVertexAttribs3fvNV(int $index, int $count, $v) {
  static $proc;
  return ($proc ??= GL::getProcAddress('vertexAttribs3fvNV'))($index, $count, $v);
}

function glVertexAttribs3hvNV(int $index, int $n, $v) {
  static $proc;
  return ($proc ??= GL::getProcAddress('vertexAttribs3hvNV'))($index, $n, $v);
}

function glVertexAttribs3svNV(int $index, int $count, $v) {
  static $proc;
  return ($proc ??= GL::getProcAddress('vertexAttribs3svNV'))($index, $count, $v);
}

function glVertexAttribs4dvNV(int $index, int $count, $v) {
  static $proc;
  return ($proc ??= GL::getProcAddress('vertexAttribs4dvNV'))($index, $count, $v);
}

function glVertexAttribs4fvNV(int $index, int $count, $v) {
  static $proc;
  return ($proc ??= GL::getProcAddress('vertexAttribs4fvNV'))($index, $count, $v);
}

function glVertexAttribs4hvNV(int $index, int $n, $v) {
  static $proc;
  return ($proc ??= GL::getProcAddress('vertexAttribs4hvNV'))($index, $n, $v);
}

function glVertexAttribs4svNV(int $index, int $count, $v) {
  static $proc;
  return ($proc ??= GL::getProcAddress('vertexAttribs4svNV'))($index, $count, $v);
}

function glVertexAttribs4ubvNV(int $index, int $count, $v) {
  static $proc;
  return ($proc ??= GL::getProcAddress('vertexAttribs4ubvNV'))($index, $count, $v);
}

function glVertexBindingDivisor(int $bindingindex, int $divisor) {
  static $proc;
  return ($proc ??= GL::getProcAddress('vertexBindingDivisor'))($bindingindex, $divisor);
}

function glVertexBlendARB(int $count) {
  static $proc;
  return ($proc ??= GL::getProcAddress('vertexBlendARB'))($count);
}

function glVertexBlendEnvfATI(int $pname, float $param) {
  static $proc;
  return ($proc ??= GL::getProcAddress('vertexBlendEnvfATI'))($pname, $param);
}

function glVertexBlendEnviATI(int $pname, int $param) {
  static $proc;
  return ($proc ??= GL::getProcAddress('vertexBlendEnviATI'))($pname, $param);
}

function glVertexFormatNV(int $size, int $type, int $stride) {
  static $proc;
  return ($proc ??= GL::getProcAddress('vertexFormatNV'))($size, $type, $stride);
}

function glVertexP2ui(int $type, int $value) {
  static $proc;
  return ($proc ??= GL::getProcAddress('vertexP2ui'))($type, $value);
}

function glVertexP2uiv(int $type, $value) {
  static $proc;
  return ($proc ??= GL::getProcAddress('vertexP2uiv'))($type, $value);
}

function glVertexP3ui(int $type, int $value) {
  static $proc;
  return ($proc ??= GL::getProcAddress('vertexP3ui'))($type, $value);
}

function glVertexP3uiv(int $type, $value) {
  static $proc;
  return ($proc ??= GL::getProcAddress('vertexP3uiv'))($type, $value);
}

function glVertexP4ui(int $type, int $value) {
  static $proc;
  return ($proc ??= GL::getProcAddress('vertexP4ui'))($type, $value);
}

function glVertexP4uiv(int $type, $value) {
  static $proc;
  return ($proc ??= GL::getProcAddress('vertexP4uiv'))($type, $value);
}

function glVertexPointer(int $size, int $type, int $stride, $pointer) {
  static $proc;
  return ($proc ??= GL::getProcAddress('vertexPointer'))($size, $type, $stride, $pointer);
}

function glVertexPointerEXT(int $size, int $type, int $stride, int $count, $pointer) {
  static $proc;
  return ($proc ??= GL::getProcAddress('vertexPointerEXT'))($size, $type, $stride, $count, $pointer);
}

function glVertexPointerListIBM(int $size, int $type, int $stride, $pointer, int $ptrstride) {
  static $proc;
  return ($proc ??= GL::getProcAddress('vertexPointerListIBM'))($size, $type, $stride, $pointer, $ptrstride);
}

function glVertexPointervINTEL(int $size, int $type, $pointer) {
  static $proc;
  return ($proc ??= GL::getProcAddress('vertexPointervINTEL'))($size, $type, $pointer);
}

function glVertexStream1dATI(int $stream, float $x) {
  static $proc;
  return ($proc ??= GL::getProcAddress('vertexStream1dATI'))($stream, $x);
}

function glVertexStream1dvATI(int $stream, $coords) {
  static $proc;
  return ($proc ??= GL::getProcAddress('vertexStream1dvATI'))($stream, $coords);
}

function glVertexStream1fATI(int $stream, float $x) {
  static $proc;
  return ($proc ??= GL::getProcAddress('vertexStream1fATI'))($stream, $x);
}

function glVertexStream1fvATI(int $stream, $coords) {
  static $proc;
  return ($proc ??= GL::getProcAddress('vertexStream1fvATI'))($stream, $coords);
}

function glVertexStream1iATI(int $stream, int $x) {
  static $proc;
  return ($proc ??= GL::getProcAddress('vertexStream1iATI'))($stream, $x);
}

function glVertexStream1ivATI(int $stream, $coords) {
  static $proc;
  return ($proc ??= GL::getProcAddress('vertexStream1ivATI'))($stream, $coords);
}

function glVertexStream1sATI(int $stream, int $x) {
  static $proc;
  return ($proc ??= GL::getProcAddress('vertexStream1sATI'))($stream, $x);
}

function glVertexStream1svATI(int $stream, $coords) {
  static $proc;
  return ($proc ??= GL::getProcAddress('vertexStream1svATI'))($stream, $coords);
}

function glVertexStream2dATI(int $stream, float $x, float $y) {
  static $proc;
  return ($proc ??= GL::getProcAddress('vertexStream2dATI'))($stream, $x, $y);
}

function glVertexStream2dvATI(int $stream, $coords) {
  static $proc;
  return ($proc ??= GL::getProcAddress('vertexStream2dvATI'))($stream, $coords);
}

function glVertexStream2fATI(int $stream, float $x, float $y) {
  static $proc;
  return ($proc ??= GL::getProcAddress('vertexStream2fATI'))($stream, $x, $y);
}

function glVertexStream2fvATI(int $stream, $coords) {
  static $proc;
  return ($proc ??= GL::getProcAddress('vertexStream2fvATI'))($stream, $coords);
}

function glVertexStream2iATI(int $stream, int $x, int $y) {
  static $proc;
  return ($proc ??= GL::getProcAddress('vertexStream2iATI'))($stream, $x, $y);
}

function glVertexStream2ivATI(int $stream, $coords) {
  static $proc;
  return ($proc ??= GL::getProcAddress('vertexStream2ivATI'))($stream, $coords);
}

function glVertexStream2sATI(int $stream, int $x, int $y) {
  static $proc;
  return ($proc ??= GL::getProcAddress('vertexStream2sATI'))($stream, $x, $y);
}

function glVertexStream2svATI(int $stream, $coords) {
  static $proc;
  return ($proc ??= GL::getProcAddress('vertexStream2svATI'))($stream, $coords);
}

function glVertexStream3dATI(int $stream, float $x, float $y, float $z) {
  static $proc;
  return ($proc ??= GL::getProcAddress('vertexStream3dATI'))($stream, $x, $y, $z);
}

function glVertexStream3dvATI(int $stream, $coords) {
  static $proc;
  return ($proc ??= GL::getProcAddress('vertexStream3dvATI'))($stream, $coords);
}

function glVertexStream3fATI(int $stream, float $x, float $y, float $z) {
  static $proc;
  return ($proc ??= GL::getProcAddress('vertexStream3fATI'))($stream, $x, $y, $z);
}

function glVertexStream3fvATI(int $stream, $coords) {
  static $proc;
  return ($proc ??= GL::getProcAddress('vertexStream3fvATI'))($stream, $coords);
}

function glVertexStream3iATI(int $stream, int $x, int $y, int $z) {
  static $proc;
  return ($proc ??= GL::getProcAddress('vertexStream3iATI'))($stream, $x, $y, $z);
}

function glVertexStream3ivATI(int $stream, $coords) {
  static $proc;
  return ($proc ??= GL::getProcAddress('vertexStream3ivATI'))($stream, $coords);
}

function glVertexStream3sATI(int $stream, int $x, int $y, int $z) {
  static $proc;
  return ($proc ??= GL::getProcAddress('vertexStream3sATI'))($stream, $x, $y, $z);
}

function glVertexStream3svATI(int $stream, $coords) {
  static $proc;
  return ($proc ??= GL::getProcAddress('vertexStream3svATI'))($stream, $coords);
}

function glVertexStream4dATI(int $stream, float $x, float $y, float $z, float $w) {
  static $proc;
  return ($proc ??= GL::getProcAddress('vertexStream4dATI'))($stream, $x, $y, $z, $w);
}

function glVertexStream4dvATI(int $stream, $coords) {
  static $proc;
  return ($proc ??= GL::getProcAddress('vertexStream4dvATI'))($stream, $coords);
}

function glVertexStream4fATI(int $stream, float $x, float $y, float $z, float $w) {
  static $proc;
  return ($proc ??= GL::getProcAddress('vertexStream4fATI'))($stream, $x, $y, $z, $w);
}

function glVertexStream4fvATI(int $stream, $coords) {
  static $proc;
  return ($proc ??= GL::getProcAddress('vertexStream4fvATI'))($stream, $coords);
}

function glVertexStream4iATI(int $stream, int $x, int $y, int $z, int $w) {
  static $proc;
  return ($proc ??= GL::getProcAddress('vertexStream4iATI'))($stream, $x, $y, $z, $w);
}

function glVertexStream4ivATI(int $stream, $coords) {
  static $proc;
  return ($proc ??= GL::getProcAddress('vertexStream4ivATI'))($stream, $coords);
}

function glVertexStream4sATI(int $stream, int $x, int $y, int $z, int $w) {
  static $proc;
  return ($proc ??= GL::getProcAddress('vertexStream4sATI'))($stream, $x, $y, $z, $w);
}

function glVertexStream4svATI(int $stream, $coords) {
  static $proc;
  return ($proc ??= GL::getProcAddress('vertexStream4svATI'))($stream, $coords);
}

function glVertexWeightPointerEXT(int $size, int $type, int $stride, $pointer) {
  static $proc;
  return ($proc ??= GL::getProcAddress('vertexWeightPointerEXT'))($size, $type, $stride, $pointer);
}

function glVertexWeightfEXT(float $weight) {
  static $proc;
  return ($proc ??= GL::getProcAddress('vertexWeightfEXT'))($weight);
}

function glVertexWeightfvEXT($weight) {
  static $proc;
  return ($proc ??= GL::getProcAddress('vertexWeightfvEXT'))($weight);
}

function glVertexWeighthNV(int $weight) {
  static $proc;
  return ($proc ??= GL::getProcAddress('vertexWeighthNV'))($weight);
}

function glVertexWeighthvNV($weight) {
  static $proc;
  return ($proc ??= GL::getProcAddress('vertexWeighthvNV'))($weight);
}

function glVideoCaptureNV(int $video_capture_slot, $sequence_num, $capture_time) {
  static $proc;
  return ($proc ??= GL::getProcAddress('videoCaptureNV'))($video_capture_slot, $sequence_num, $capture_time);
}

function glVideoCaptureStreamParameterdvNV(int $video_capture_slot, int $stream, int $pname, $params) {
  static $proc;
  return ($proc ??= GL::getProcAddress('videoCaptureStreamParameterdvNV'))($video_capture_slot, $stream, $pname, $params);
}

function glVideoCaptureStreamParameterfvNV(int $video_capture_slot, int $stream, int $pname, $params) {
  static $proc;
  return ($proc ??= GL::getProcAddress('videoCaptureStreamParameterfvNV'))($video_capture_slot, $stream, $pname, $params);
}

function glVideoCaptureStreamParameterivNV(int $video_capture_slot, int $stream, int $pname, $params) {
  static $proc;
  return ($proc ??= GL::getProcAddress('videoCaptureStreamParameterivNV'))($video_capture_slot, $stream, $pname, $params);
}

function glViewport(int $x, int $y, int $width, int $height) {
  static $proc;
  return ($proc ??= GL::getProcAddress('viewport'))($x, $y, $width, $height);
}

function glViewportArrayv(int $first, int $count, $v) {
  static $proc;
  return ($proc ??= GL::getProcAddress('viewportArrayv'))($first, $count, $v);
}

function glViewportArrayvNV(int $first, int $count, $v) {
  static $proc;
  return ($proc ??= GL::getProcAddress('viewportArrayvNV'))($first, $count, $v);
}

function glViewportArrayvOES(int $first, int $count, $v) {
  static $proc;
  return ($proc ??= GL::getProcAddress('viewportArrayvOES'))($first, $count, $v);
}

function glViewportIndexedf(int $index, float $x, float $y, float $w, float $h) {
  static $proc;
  return ($proc ??= GL::getProcAddress('viewportIndexedf'))($index, $x, $y, $w, $h);
}

function glViewportIndexedfOES(int $index, float $x, float $y, float $w, float $h) {
  static $proc;
  return ($proc ??= GL::getProcAddress('viewportIndexedfOES'))($index, $x, $y, $w, $h);
}

function glViewportIndexedfNV(int $index, float $x, float $y, float $w, float $h) {
  static $proc;
  return ($proc ??= GL::getProcAddress('viewportIndexedfNV'))($index, $x, $y, $w, $h);
}

function glViewportIndexedfv(int $index, $v) {
  static $proc;
  return ($proc ??= GL::getProcAddress('viewportIndexedfv'))($index, $v);
}

function glViewportIndexedfvOES(int $index, $v) {
  static $proc;
  return ($proc ??= GL::getProcAddress('viewportIndexedfvOES'))($index, $v);
}

function glViewportIndexedfvNV(int $index, $v) {
  static $proc;
  return ($proc ??= GL::getProcAddress('viewportIndexedfvNV'))($index, $v);
}

function glViewportPositionWScaleNV(int $index, float $xcoeff, float $ycoeff) {
  static $proc;
  return ($proc ??= GL::getProcAddress('viewportPositionWScaleNV'))($index, $xcoeff, $ycoeff);
}

function glViewportSwizzleNV(int $index, int $swizzlex, int $swizzley, int $swizzlez, int $swizzlew) {
  static $proc;
  return ($proc ??= GL::getProcAddress('viewportSwizzleNV'))($index, $swizzlex, $swizzley, $swizzlez, $swizzlew);
}

function glWaitSync(int $sync, int $flags, int $timeout) {
  static $proc;
  return ($proc ??= GL::getProcAddress('waitSync'))($sync, $flags, $timeout);
}

function glWaitSyncAPPLE(int $sync, int $flags, int $timeout) {
  static $proc;
  return ($proc ??= GL::getProcAddress('waitSyncAPPLE'))($sync, $flags, $timeout);
}

function glWeightPathsNV(int $resultPath, int $numPaths, $paths, $weights) {
  static $proc;
  return ($proc ??= GL::getProcAddress('weightPathsNV'))($resultPath, $numPaths, $paths, $weights);
}

function glWeightPointerARB(int $size, int $type, int $stride, $pointer) {
  static $proc;
  return ($proc ??= GL::getProcAddress('weightPointerARB'))($size, $type, $stride, $pointer);
}

function glWeightPointerOES(int $size, int $type, int $stride, $pointer) {
  static $proc;
  return ($proc ??= GL::getProcAddress('weightPointerOES'))($size, $type, $stride, $pointer);
}

function glWeightbvARB(int $size, $weights) {
  static $proc;
  return ($proc ??= GL::getProcAddress('weightbvARB'))($size, $weights);
}

function glWeightdvARB(int $size, $weights) {
  static $proc;
  return ($proc ??= GL::getProcAddress('weightdvARB'))($size, $weights);
}

function glWeightfvARB(int $size, $weights) {
  static $proc;
  return ($proc ??= GL::getProcAddress('weightfvARB'))($size, $weights);
}

function glWeightivARB(int $size, $weights) {
  static $proc;
  return ($proc ??= GL::getProcAddress('weightivARB'))($size, $weights);
}

function glWeightsvARB(int $size, $weights) {
  static $proc;
  return ($proc ??= GL::getProcAddress('weightsvARB'))($size, $weights);
}

function glWeightubvARB(int $size, $weights) {
  static $proc;
  return ($proc ??= GL::getProcAddress('weightubvARB'))($size, $weights);
}

function glWeightuivARB(int $size, $weights) {
  static $proc;
  return ($proc ??= GL::getProcAddress('weightuivARB'))($size, $weights);
}

function glWeightusvARB(int $size, $weights) {
  static $proc;
  return ($proc ??= GL::getProcAddress('weightusvARB'))($size, $weights);
}

function glWindowPos2d(float $x, float $y) {
  static $proc;
  return ($proc ??= GL::getProcAddress('windowPos2d'))($x, $y);
}

function glWindowPos2dARB(float $x, float $y) {
  static $proc;
  return ($proc ??= GL::getProcAddress('windowPos2dARB'))($x, $y);
}

function glWindowPos2dMESA(float $x, float $y) {
  static $proc;
  return ($proc ??= GL::getProcAddress('windowPos2dMESA'))($x, $y);
}

function glWindowPos2dv($v) {
  static $proc;
  return ($proc ??= GL::getProcAddress('windowPos2dv'))($v);
}

function glWindowPos2dvARB($v) {
  static $proc;
  return ($proc ??= GL::getProcAddress('windowPos2dvARB'))($v);
}

function glWindowPos2dvMESA($v) {
  static $proc;
  return ($proc ??= GL::getProcAddress('windowPos2dvMESA'))($v);
}

function glWindowPos2f(float $x, float $y) {
  static $proc;
  return ($proc ??= GL::getProcAddress('windowPos2f'))($x, $y);
}

function glWindowPos2fARB(float $x, float $y) {
  static $proc;
  return ($proc ??= GL::getProcAddress('windowPos2fARB'))($x, $y);
}

function glWindowPos2fMESA(float $x, float $y) {
  static $proc;
  return ($proc ??= GL::getProcAddress('windowPos2fMESA'))($x, $y);
}

function glWindowPos2fv($v) {
  static $proc;
  return ($proc ??= GL::getProcAddress('windowPos2fv'))($v);
}

function glWindowPos2fvARB($v) {
  static $proc;
  return ($proc ??= GL::getProcAddress('windowPos2fvARB'))($v);
}

function glWindowPos2fvMESA($v) {
  static $proc;
  return ($proc ??= GL::getProcAddress('windowPos2fvMESA'))($v);
}

function glWindowPos2i(int $x, int $y) {
  static $proc;
  return ($proc ??= GL::getProcAddress('windowPos2i'))($x, $y);
}

function glWindowPos2iARB(int $x, int $y) {
  static $proc;
  return ($proc ??= GL::getProcAddress('windowPos2iARB'))($x, $y);
}

function glWindowPos2iMESA(int $x, int $y) {
  static $proc;
  return ($proc ??= GL::getProcAddress('windowPos2iMESA'))($x, $y);
}

function glWindowPos2iv($v) {
  static $proc;
  return ($proc ??= GL::getProcAddress('windowPos2iv'))($v);
}

function glWindowPos2ivARB($v) {
  static $proc;
  return ($proc ??= GL::getProcAddress('windowPos2ivARB'))($v);
}

function glWindowPos2ivMESA($v) {
  static $proc;
  return ($proc ??= GL::getProcAddress('windowPos2ivMESA'))($v);
}

function glWindowPos2s(int $x, int $y) {
  static $proc;
  return ($proc ??= GL::getProcAddress('windowPos2s'))($x, $y);
}

function glWindowPos2sARB(int $x, int $y) {
  static $proc;
  return ($proc ??= GL::getProcAddress('windowPos2sARB'))($x, $y);
}

function glWindowPos2sMESA(int $x, int $y) {
  static $proc;
  return ($proc ??= GL::getProcAddress('windowPos2sMESA'))($x, $y);
}

function glWindowPos2sv($v) {
  static $proc;
  return ($proc ??= GL::getProcAddress('windowPos2sv'))($v);
}

function glWindowPos2svARB($v) {
  static $proc;
  return ($proc ??= GL::getProcAddress('windowPos2svARB'))($v);
}

function glWindowPos2svMESA($v) {
  static $proc;
  return ($proc ??= GL::getProcAddress('windowPos2svMESA'))($v);
}

function glWindowPos3d(float $x, float $y, float $z) {
  static $proc;
  return ($proc ??= GL::getProcAddress('windowPos3d'))($x, $y, $z);
}

function glWindowPos3dARB(float $x, float $y, float $z) {
  static $proc;
  return ($proc ??= GL::getProcAddress('windowPos3dARB'))($x, $y, $z);
}

function glWindowPos3dMESA(float $x, float $y, float $z) {
  static $proc;
  return ($proc ??= GL::getProcAddress('windowPos3dMESA'))($x, $y, $z);
}

function glWindowPos3dv($v) {
  static $proc;
  return ($proc ??= GL::getProcAddress('windowPos3dv'))($v);
}

function glWindowPos3dvARB($v) {
  static $proc;
  return ($proc ??= GL::getProcAddress('windowPos3dvARB'))($v);
}

function glWindowPos3dvMESA($v) {
  static $proc;
  return ($proc ??= GL::getProcAddress('windowPos3dvMESA'))($v);
}

function glWindowPos3f(float $x, float $y, float $z) {
  static $proc;
  return ($proc ??= GL::getProcAddress('windowPos3f'))($x, $y, $z);
}

function glWindowPos3fARB(float $x, float $y, float $z) {
  static $proc;
  return ($proc ??= GL::getProcAddress('windowPos3fARB'))($x, $y, $z);
}

function glWindowPos3fMESA(float $x, float $y, float $z) {
  static $proc;
  return ($proc ??= GL::getProcAddress('windowPos3fMESA'))($x, $y, $z);
}

function glWindowPos3fv($v) {
  static $proc;
  return ($proc ??= GL::getProcAddress('windowPos3fv'))($v);
}

function glWindowPos3fvARB($v) {
  static $proc;
  return ($proc ??= GL::getProcAddress('windowPos3fvARB'))($v);
}

function glWindowPos3fvMESA($v) {
  static $proc;
  return ($proc ??= GL::getProcAddress('windowPos3fvMESA'))($v);
}

function glWindowPos3i(int $x, int $y, int $z) {
  static $proc;
  return ($proc ??= GL::getProcAddress('windowPos3i'))($x, $y, $z);
}

function glWindowPos3iARB(int $x, int $y, int $z) {
  static $proc;
  return ($proc ??= GL::getProcAddress('windowPos3iARB'))($x, $y, $z);
}

function glWindowPos3iMESA(int $x, int $y, int $z) {
  static $proc;
  return ($proc ??= GL::getProcAddress('windowPos3iMESA'))($x, $y, $z);
}

function glWindowPos3iv($v) {
  static $proc;
  return ($proc ??= GL::getProcAddress('windowPos3iv'))($v);
}

function glWindowPos3ivARB($v) {
  static $proc;
  return ($proc ??= GL::getProcAddress('windowPos3ivARB'))($v);
}

function glWindowPos3ivMESA($v) {
  static $proc;
  return ($proc ??= GL::getProcAddress('windowPos3ivMESA'))($v);
}

function glWindowPos3s(int $x, int $y, int $z) {
  static $proc;
  return ($proc ??= GL::getProcAddress('windowPos3s'))($x, $y, $z);
}

function glWindowPos3sARB(int $x, int $y, int $z) {
  static $proc;
  return ($proc ??= GL::getProcAddress('windowPos3sARB'))($x, $y, $z);
}

function glWindowPos3sMESA(int $x, int $y, int $z) {
  static $proc;
  return ($proc ??= GL::getProcAddress('windowPos3sMESA'))($x, $y, $z);
}

function glWindowPos3sv($v) {
  static $proc;
  return ($proc ??= GL::getProcAddress('windowPos3sv'))($v);
}

function glWindowPos3svARB($v) {
  static $proc;
  return ($proc ??= GL::getProcAddress('windowPos3svARB'))($v);
}

function glWindowPos3svMESA($v) {
  static $proc;
  return ($proc ??= GL::getProcAddress('windowPos3svMESA'))($v);
}

function glWindowPos4dMESA(float $x, float $y, float $z, float $w) {
  static $proc;
  return ($proc ??= GL::getProcAddress('windowPos4dMESA'))($x, $y, $z, $w);
}

function glWindowPos4dvMESA($v) {
  static $proc;
  return ($proc ??= GL::getProcAddress('windowPos4dvMESA'))($v);
}

function glWindowPos4fMESA(float $x, float $y, float $z, float $w) {
  static $proc;
  return ($proc ??= GL::getProcAddress('windowPos4fMESA'))($x, $y, $z, $w);
}

function glWindowPos4fvMESA($v) {
  static $proc;
  return ($proc ??= GL::getProcAddress('windowPos4fvMESA'))($v);
}

function glWindowPos4iMESA(int $x, int $y, int $z, int $w) {
  static $proc;
  return ($proc ??= GL::getProcAddress('windowPos4iMESA'))($x, $y, $z, $w);
}

function glWindowPos4ivMESA($v) {
  static $proc;
  return ($proc ??= GL::getProcAddress('windowPos4ivMESA'))($v);
}

function glWindowPos4sMESA(int $x, int $y, int $z, int $w) {
  static $proc;
  return ($proc ??= GL::getProcAddress('windowPos4sMESA'))($x, $y, $z, $w);
}

function glWindowPos4svMESA($v) {
  static $proc;
  return ($proc ??= GL::getProcAddress('windowPos4svMESA'))($v);
}

function glWindowRectanglesEXT(int $mode, int $count, $box) {
  static $proc;
  return ($proc ??= GL::getProcAddress('windowRectanglesEXT'))($mode, $count, $box);
}

function glWriteMaskEXT(int $res, int $in, int $outX, int $outY, int $outZ, int $outW) {
  static $proc;
  return ($proc ??= GL::getProcAddress('writeMaskEXT'))($res, $in, $outX, $outY, $outZ, $outW);
}