package vendor_gl

#assert(size_of(bool) == size_of(u8))

when !GL_DEBUG {
	// VERSION_1_0
	CullFace               :: proc "c" (mode: u32)                                                                                         {        impl_CullFace(mode)                                                                         }
	FrontFace              :: proc "c" (mode: u32)                                                                                         {        impl_FrontFace(mode)                                                                        }
	Hint                   :: proc "c" (target, mode: u32)                                                                                 {        impl_Hint(target, mode)                                                                     }
	LineWidth              :: proc "c" (width: f32)                                                                                        {        impl_LineWidth(width)                                                                       }
	PointSize              :: proc "c" (size: f32)                                                                                         {        impl_PointSize(size)                                                                        }
	PolygonMode            :: proc "c" (face, mode: u32)                                                                                   {        impl_PolygonMode(face, mode)                                                                }
	Scissor                :: proc "c" (x, y, width, height: i32)                                                                          {        impl_Scissor(x, y, width, height)                                                           }
	TexParameterf          :: proc "c" (target, pname: u32, param: f32)                                                                    {        impl_TexParameterf(target, pname, param)                                                    }
	TexParameterfv         :: proc "c" (target, pname: u32, params: [^]f32)                                                                {        impl_TexParameterfv(target, pname, params)                                                  }
	TexParameteri          :: proc "c" (target, pname: u32, param: i32)                                                                    {        impl_TexParameteri(target, pname, param)                                                    }
	TexParameteriv         :: proc "c" (target, pname: u32, params: [^]i32)                                                                {        impl_TexParameteriv(target, pname, params)                                                  }
	TexImage1D             :: proc "c" (target: u32, level, internalformat, width, border: i32, format, type: u32, pixels: rawptr)         {        impl_TexImage1D(target, level, internalformat, width, border, format, type, pixels)         }
	TexImage2D             :: proc "c" (target: u32, level, internalformat, width, height, border: i32, format, type: u32, pixels: rawptr) {        impl_TexImage2D(target, level, internalformat, width, height, border, format, type, pixels) }
	DrawBuffer             :: proc "c" (buf: u32)                                                                                          {        impl_DrawBuffer(buf)                                                                        }
	Clear                  :: proc "c" (mask: u32)                                                                                         {        impl_Clear(mask)                                                                            }
	ClearColor             :: proc "c" (red, green, blue, alpha: f32)                                                                      {        impl_ClearColor(red, green, blue, alpha)                                                    }
	ClearStencil           :: proc "c" (s: i32)                                                                                            {        impl_ClearStencil(s)                                                                        }
	ClearDepth             :: proc "c" (depth: f64)                                                                                        {        impl_ClearDepth(depth)                                                                      }
	StencilMask            :: proc "c" (mask: u32)                                                                                         {        impl_StencilMask(mask)                                                                      }
	ColorMask              :: proc "c" (red, green, blue, alpha: bool)                                                                     {        impl_ColorMask(red, green, blue, alpha)                                                     }
	DepthMask              :: proc "c" (flag: bool)                                                                                        {        impl_DepthMask(flag)                                                                        }
	Disable                :: proc "c" (cap: u32)                                                                                          {        impl_Disable(cap)                                                                           }
	Enable                 :: proc "c" (cap: u32)                                                                                          {        impl_Enable(cap)                                                                            }
	Finish                 :: proc "c" ()                                                                                                  {        impl_Finish()                                                                               }
	Flush                  :: proc "c" ()                                                                                                  {        impl_Flush()                                                                                }
	BlendFunc              :: proc "c" (sfactor, dfactor: u32)                                                                             {        impl_BlendFunc(sfactor, dfactor)                                                            }
	LogicOp                :: proc "c" (opcode: u32)                                                                                       {        impl_LogicOp(opcode)                                                                        }
	StencilFunc            :: proc "c" (func: u32, ref: i32, mask: u32)                                                                    {        impl_StencilFunc(func, ref, mask)                                                           }
	StencilOp              :: proc "c" (fail, zfail, zpass: u32)                                                                           {        impl_StencilOp(fail, zfail, zpass)                                                          }
	DepthFunc              :: proc "c" (func: u32)                                                                                         {        impl_DepthFunc(func)                                                                        }
	PixelStoref            :: proc "c" (pname: u32, param: f32)                                                                            {        impl_PixelStoref(pname, param)                                                              }
	PixelStorei            :: proc "c" (pname: u32, param: i32)                                                                            {        impl_PixelStorei(pname, param)                                                              }
	ReadBuffer             :: proc "c" (src: u32)                                                                                          {        impl_ReadBuffer(src)                                                                        }
	ReadPixels             :: proc "c" (x, y, width, height: i32, format, type: u32, pixels: rawptr)                                       {        impl_ReadPixels(x, y, width, height, format, type, pixels)                                  }
	GetBooleanv            :: proc "c" (pname: u32, data: ^bool)                                                                           {        impl_GetBooleanv(pname, data)                                                               }
	GetDoublev             :: proc "c" (pname: u32, data: ^f64)                                                                            {        impl_GetDoublev(pname, data)                                                                }
	GetError               :: proc "c" () -> u32                                                                                           { return impl_GetError()                                                                             }
	GetFloatv              :: proc "c" (pname: u32, data: ^f32)                                                                            {        impl_GetFloatv(pname, data)                                                                 }
	GetIntegerv            :: proc "c" (pname: u32, data: ^i32)                                                                            {        impl_GetIntegerv(pname, data)                                                               }
	GetString              :: proc "c" (name: u32) -> cstring                                                                              { return impl_GetString(name)                                                                        }
	GetTexImage            :: proc "c" (target: u32,  level: i32, format, type: u32, pixels: rawptr)                                       {        impl_GetTexImage(target,  level, format, type, pixels)                                      }
	GetTexParameterfv      :: proc "c" (target, pname: u32, params: [^]f32)                                                                {        impl_GetTexParameterfv(target, pname, params)                                               }
	GetTexParameteriv      :: proc "c" (target, pname: u32, params: [^]i32)                                                                {        impl_GetTexParameteriv(target, pname, params)                                               }
	GetTexLevelParameterfv :: proc "c" (target: u32, level: i32, pname: u32, params: [^]f32)                                               {        impl_GetTexLevelParameterfv(target, level, pname, params)                                   }
	GetTexLevelParameteriv :: proc "c" (target: u32, level: i32, pname: u32, params: [^]i32)                                               {        impl_GetTexLevelParameteriv(target, level, pname, params)                                   }
	IsEnabled              :: proc "c" (cap: u32) -> bool                                                                                  { return impl_IsEnabled(cap)                                                                         }
	DepthRange             :: proc "c" (near, far: f64)                                                                                    {        impl_DepthRange(near, far)                                                                  }
	Viewport               :: proc "c" (x, y, width, height: i32)                                                                          {        impl_Viewport(x, y, width, height)                                                          }

	// VERSION_1_1
	DrawArrays        :: proc "c" (mode: u32, first: i32, count: i32)                                                                                    {        impl_DrawArrays(mode, first, count)                                                      }
	DrawElements      :: proc "c" (mode: u32, count: i32, type: u32, indices: rawptr)                                                                    {        impl_DrawElements(mode, count, type, indices)                                            }
	PolygonOffset     :: proc "c" (factor: f32, units: f32)                                                                                              {        impl_PolygonOffset(factor, units)                                                        }
	CopyTexImage1D    :: proc "c" (target: u32, level: i32, internalformat: u32, x: i32, y: i32, width: i32, border: i32)                                {        impl_CopyTexImage1D(target, level, internalformat, x, y, width, border)                  }
	CopyTexImage2D    :: proc "c" (target: u32, level: i32, internalformat: u32, x: i32, y: i32, width: i32, height: i32, border: i32)                   {        impl_CopyTexImage2D(target, level, internalformat, x, y, width, height, border)          }
	CopyTexSubImage1D :: proc "c" (target: u32, level: i32, xoffset: i32, x: i32, y: i32, width: i32)                                                    {        impl_CopyTexSubImage1D(target, level, xoffset, x, y, width)                              }
	CopyTexSubImage2D :: proc "c" (target: u32, level: i32, xoffset: i32, yoffset: i32, x: i32, y: i32, width: i32, height: i32)                         {        impl_CopyTexSubImage2D(target, level, xoffset, yoffset, x, y, width, height)             }
	TexSubImage1D     :: proc "c" (target: u32, level: i32, xoffset: i32, width: i32, format: u32, type: u32, pixels: rawptr)                            {        impl_TexSubImage1D(target, level, xoffset, width, format, type, pixels)                  }
	TexSubImage2D     :: proc "c" (target: u32, level: i32, xoffset: i32, yoffset: i32, width: i32, height: i32, format: u32, type: u32, pixels: rawptr) {        impl_TexSubImage2D(target, level, xoffset, yoffset, width, height, format, type, pixels) }
	BindTexture       :: proc "c" (target: u32, texture: u32)                                                                                            {        impl_BindTexture(target, texture)                                                        }
	DeleteTextures    :: proc "c" (n: i32, textures: [^]u32)                                                                                             {        impl_DeleteTextures(n, textures)                                                         }
	GenTextures       :: proc "c" (n: i32, textures: [^]u32)                                                                                             {        impl_GenTextures(n, textures)                                                            }
	IsTexture         :: proc "c" (texture: u32) -> bool                                                                                                 { return impl_IsTexture(texture)                                                                  }

	// VERSION_1_2
	DrawRangeElements :: proc "c" (mode, start, end: u32, count: i32, type: u32, indices: rawptr)                                               { impl_DrawRangeElements(mode, start, end, count, type, indices)                                           }
	TexImage3D        :: proc "c" (target: u32, level, internalformat, width, height, depth, border: i32, format, type: u32, data: rawptr)    { impl_TexImage3D(target, level, internalformat, width, height, depth, border, format, type, data)       }
	TexSubImage3D     :: proc "c" (target: u32, level, xoffset, yoffset, zoffset, width, height, depth: i32, format, type: u32, pixels: rawptr) { impl_TexSubImage3D(target, level, xoffset, yoffset, zoffset, width, height, depth, format, type, pixels) }
	CopyTexSubImage3D :: proc "c" (target: u32, level, xoffset, yoffset, zoffset, x, y, width, height: i32)                                     { impl_CopyTexSubImage3D(target, level, xoffset, yoffset, zoffset, x, y, width, height)                    }

	// VERSION_1_3
	ActiveTexture           :: proc "c" (texture: u32)                                                                                                                                      { impl_ActiveTexture(texture)                                                                                           }
	SampleCoverage          :: proc "c" (value: f32, invert: bool)                                                                                                                          { impl_SampleCoverage(value, invert)                                                                                    }
	CompressedTexImage3D    :: proc "c" (target: u32, level: i32, internalformat: u32, width: i32, height: i32, depth: i32, border: i32, imageSize: i32, data: rawptr)                      { impl_CompressedTexImage3D(target, level, internalformat, width, height, depth, border, imageSize, data)               }
	CompressedTexImage2D    :: proc "c" (target: u32, level: i32, internalformat: u32, width: i32, height: i32, border: i32, imageSize: i32, data: rawptr)                                  { impl_CompressedTexImage2D(target, level, internalformat, width, height, border, imageSize, data)                      }
	CompressedTexImage1D    :: proc "c" (target: u32, level: i32, internalformat: u32, width: i32, border: i32, imageSize: i32, data: rawptr)                                               { impl_CompressedTexImage1D(target, level, internalformat, width, border, imageSize, data)                              }
	CompressedTexSubImage3D :: proc "c" (target: u32, level: i32, xoffset: i32, yoffset: i32, zoffset: i32, width: i32, height: i32, depth: i32, format: u32, imageSize: i32, data: rawptr) { impl_CompressedTexSubImage3D(target, level, xoffset, yoffset, zoffset, width, height, depth, format, imageSize, data) }
	CompressedTexSubImage2D :: proc "c" (target: u32, level: i32, xoffset: i32, yoffset: i32, width: i32, height: i32, format: u32, imageSize: i32, data: rawptr)                           { impl_CompressedTexSubImage2D(target, level, xoffset, yoffset, width, height, format, imageSize, data)                 }
	CompressedTexSubImage1D :: proc "c" (target: u32, level: i32, xoffset: i32, width: i32, format: u32, imageSize: i32, data: rawptr)                                                      { impl_CompressedTexSubImage1D(target, level, xoffset, width, format, imageSize, data)                                  }
	GetCompressedTexImage   :: proc "c" (target: u32, level: i32, img: rawptr)                                                                                                              { impl_GetCompressedTexImage(target, level, img)                                                                        }

	// VERSION_1_4
	BlendFuncSeparate :: proc "c" (sfactorRGB: u32, dfactorRGB: u32, sfactorAlpha: u32, dfactorAlpha: u32)  { impl_BlendFuncSeparate(sfactorRGB, dfactorRGB, sfactorAlpha, dfactorAlpha) }
	MultiDrawArrays   :: proc "c" (mode: u32, first: [^]i32, count: [^]i32, drawcount: i32)                 { impl_MultiDrawArrays(mode, first, count, drawcount)                    }
	MultiDrawElements :: proc "c" (mode: u32, count: [^]i32, type: u32, indices: [^]rawptr, drawcount: i32) { impl_MultiDrawElements(mode, count, type, indices, drawcount)           }
	PointParameterf   :: proc "c" (pname: u32, param: f32)                                                  { impl_PointParameterf(pname, param)                                         }
	PointParameterfv  :: proc "c" (pname: u32, params: [^]f32)                                              { impl_PointParameterfv(pname, params)                                     }
	PointParameteri   :: proc "c" (pname: u32, param: i32)                                                  { impl_PointParameteri(pname, param)                                         }
	PointParameteriv  :: proc "c" (pname: u32, params: [^]i32)                                              { impl_PointParameteriv(pname, params)                                     }
	BlendColor        :: proc "c" (red: f32, green: f32, blue: f32, alpha: f32)                             { impl_BlendColor(red, green, blue, alpha)                                   }
	BlendEquation     :: proc "c" (mode: u32)                                                               { impl_BlendEquation(mode)                                                   }

	// VERSION_1_5
	GenQueries           :: proc "c" (n: i32, ids: [^]u32)                               {        impl_GenQueries(n, ids)                                       }
	DeleteQueries        :: proc "c" (n: i32, ids: [^]u32)                               {        impl_DeleteQueries(n, ids)                                    }
	IsQuery              :: proc "c" (id: u32) -> bool                                   { ret := impl_IsQuery(id);                                  return ret }
	BeginQuery           :: proc "c" (target: u32, id: u32)                              {        impl_BeginQuery(target, id)                                   }
	EndQuery             :: proc "c" (target: u32)                                       {        impl_EndQuery(target)                                         }
	GetQueryiv           :: proc "c" (target: u32, pname: u32, params: [^]i32)           {        impl_GetQueryiv(target, pname, params)                        }
	GetQueryObjectiv     :: proc "c" (id: u32, pname: u32, params: [^]i32)               {        impl_GetQueryObjectiv(id, pname, params)                      }
	GetQueryObjectuiv    :: proc "c" (id: u32, pname: u32, params: [^]u32)               {        impl_GetQueryObjectuiv(id, pname, params)                     }
	BindBuffer           :: proc "c" (target: u32, buffer: u32)                          {        impl_BindBuffer(target, buffer)                               }
	DeleteBuffers        :: proc "c" (n: i32, buffers: [^]u32)                           {        impl_DeleteBuffers(n, buffers)                                }
	GenBuffers           :: proc "c" (n: i32, buffers: [^]u32)                           {        impl_GenBuffers(n, buffers)                                   }
	IsBuffer             :: proc "c" (buffer: u32) -> bool                               { ret := impl_IsBuffer(buffer);                             return ret }
	BufferData           :: proc "c" (target: u32, size: int, data: rawptr, usage: u32)  {        impl_BufferData(target, size, data, usage)                    }
	BufferSubData        :: proc "c" (target: u32, offset: int, size: int, data: rawptr) {        impl_BufferSubData(target, offset, size, data)                }
	GetBufferSubData     :: proc "c" (target: u32, offset: int, size: int, data: rawptr) {        impl_GetBufferSubData(target, offset, size, data)             }
	MapBuffer            :: proc "c" (target: u32, access: u32) -> rawptr                { ret := impl_MapBuffer(target, access);                    return ret }
	UnmapBuffer          :: proc "c" (target: u32) -> bool                               { ret := impl_UnmapBuffer(target);                          return ret }
	GetBufferParameteriv :: proc "c" (target: u32, pname: u32, params: [^]i32)           {        impl_GetBufferParameteriv(target, pname, params)              }
	GetBufferPointerv    :: proc "c" (target: u32, pname: u32, params: [^]rawptr)        {        impl_GetBufferPointerv(target, pname, params)                 }

	// VERSION_2_0
	BlendEquationSeparate    :: proc "c" (modeRGB: u32, modeAlpha: u32)                                                               {        impl_BlendEquationSeparate(modeRGB, modeAlpha)                                        }
	DrawBuffers              :: proc "c" (n: i32, bufs: [^]u32)                                                                       {        impl_DrawBuffers(n, bufs)                                                             }
	StencilOpSeparate        :: proc "c" (face: u32, sfail: u32, dpfail: u32, dppass: u32)                                            {        impl_StencilOpSeparate(face, sfail, dpfail, dppass)                                   }
	StencilFuncSeparate      :: proc "c" (face: u32, func: u32, ref: i32, mask: u32)                                                  {        impl_StencilFuncSeparate(face, func, ref, mask)                                       }
	StencilMaskSeparate      :: proc "c" (face: u32, mask: u32)                                                                       {        impl_StencilMaskSeparate(face, mask)                                                  }
	AttachShader             :: proc "c" (program: u32, shader: u32)                                                                  {        impl_AttachShader(program, shader)                                                    }
	BindAttribLocation       :: proc "c" (program: u32, index: u32, name: cstring)                                                    {        impl_BindAttribLocation(program, index, name)                                         }
	CompileShader            :: proc "c" (shader: u32)                                                                                {        impl_CompileShader(shader)                                                            }
	CreateProgram            :: proc "c" () -> u32                                                                                    { ret := impl_CreateProgram();                                                      return ret }
	CreateShader             :: proc "c" (type: u32) -> u32                                                                           { ret := impl_CreateShader(type);                                                  return ret }
	DeleteProgram            :: proc "c" (program: u32)                                                                               {        impl_DeleteProgram(program)                                                           }
	DeleteShader             :: proc "c" (shader: u32)                                                                                {        impl_DeleteShader(shader)                                                             }
	DetachShader             :: proc "c" (program: u32, shader: u32)                                                                  {        impl_DetachShader(program, shader)                                                    }
	DisableVertexAttribArray :: proc "c" (index: u32)                                                                                 {        impl_DisableVertexAttribArray(index)                                                  }
	EnableVertexAttribArray  :: proc "c" (index: u32)                                                                                 {        impl_EnableVertexAttribArray(index)                                                   }
	GetActiveAttrib          :: proc "c" (program: u32, index: u32, bufSize: i32, length: ^i32, size: ^i32, type: ^u32, name: [^]u8)  {        impl_GetActiveAttrib(program, index, bufSize, length, size, type, name)              }
	GetActiveUniform         :: proc "c" (program: u32, index: u32, bufSize: i32, length: ^i32, size: ^i32, type: ^u32, name: [^]u8)  {        impl_GetActiveUniform(program, index, bufSize, length, size, type, name)             }
	GetAttachedShaders       :: proc "c" (program: u32, maxCount: i32, count: [^]i32, shaders: [^]u32)                                {        impl_GetAttachedShaders(program, maxCount, count, shaders)                            }
	GetAttribLocation        :: proc "c" (program: u32, name: cstring) -> i32                                                         { ret := impl_GetAttribLocation(program, name);                                     return ret }
	GetProgramiv             :: proc "c" (program: u32, pname: u32, params: [^]i32)                                                   {        impl_GetProgramiv(program, pname, params)                                             }
	GetProgramInfoLog        :: proc "c" (program: u32, bufSize: i32, length: ^i32, infoLog: [^]u8)                                   {        impl_GetProgramInfoLog(program, bufSize, length, infoLog)                             }
	GetShaderiv              :: proc "c" (shader: u32, pname: u32, params: [^]i32)                                                    {        impl_GetShaderiv(shader, pname, params)                                               }
	GetShaderInfoLog         :: proc "c" (shader: u32, bufSize: i32, length: ^i32, infoLog: [^]u8)                                    {        impl_GetShaderInfoLog(shader, bufSize, length, infoLog)                               }
	GetShaderSource          :: proc "c" (shader: u32, bufSize: i32, length: ^i32, source: [^]u8)                                     {        impl_GetShaderSource(shader, bufSize, length, source)                                 }
	GetUniformLocation       :: proc "c" (program: u32, name: cstring) -> i32                                                         { ret := impl_GetUniformLocation(program, name);                                    return ret }
	GetUniformfv             :: proc "c" (program: u32, location: i32, params: [^]f32)                                                {        impl_GetUniformfv(program, location, params)                                          }
	GetUniformiv             :: proc "c" (program: u32, location: i32, params: [^]i32)                                                {        impl_GetUniformiv(program, location, params)                                          }
	GetVertexAttribdv        :: proc "c" (index: u32, pname: u32, params: [^]f64)                                                     {        impl_GetVertexAttribdv(index, pname, params)                                          }
	GetVertexAttribfv        :: proc "c" (index: u32, pname: u32, params: [^]f32)                                                     {        impl_GetVertexAttribfv(index, pname, params)                                          }
	GetVertexAttribiv        :: proc "c" (index: u32, pname: u32, params: [^]i32)                                                     {        impl_GetVertexAttribiv(index, pname, params)                                          }
	GetVertexAttribPointerv  :: proc "c" (index: u32, pname: u32, pointer: ^uintptr)                                                   {        impl_GetVertexAttribPointerv(index, pname, pointer)                                   }
	IsProgram                :: proc "c" (program: u32) -> bool                                                                       { ret := impl_IsProgram(program);                                                   return ret }
	IsShader                 :: proc "c" (shader: u32) -> bool                                                                        { ret := impl_IsShader(shader);                                                     return ret }
	LinkProgram              :: proc "c" (program: u32)                                                                               {        impl_LinkProgram(program)                                                             }
	ShaderSource             :: proc "c" (shader: u32, count: i32, string: [^]cstring, length: [^]i32)                                {        impl_ShaderSource(shader, count, string, length)                                      }
	UseProgram               :: proc "c" (program: u32)                                                                               {        impl_UseProgram(program)                                                              }
	Uniform1f                :: proc "c" (location: i32, v0: f32)                                                                     {        impl_Uniform1f(location, v0)                                                          }
	Uniform2f                :: proc "c" (location: i32, v0: f32, v1: f32)                                                            {        impl_Uniform2f(location, v0, v1)                                                      }
	Uniform3f                :: proc "c" (location: i32, v0: f32, v1: f32, v2: f32)                                                   {        impl_Uniform3f(location, v0, v1, v2)                                                  }
	Uniform4f                :: proc "c" (location: i32, v0: f32, v1: f32, v2: f32, v3: f32)                                          {        impl_Uniform4f(location, v0, v1, v2, v3)                                              }
	Uniform1i                :: proc "c" (location: i32, v0: i32)                                                                     {        impl_Uniform1i(location, v0)                                                          }
	Uniform2i                :: proc "c" (location: i32, v0: i32, v1: i32)                                                            {        impl_Uniform2i(location, v0, v1)                                                      }
	Uniform3i                :: proc "c" (location: i32, v0: i32, v1: i32, v2: i32)                                                   {        impl_Uniform3i(location, v0, v1, v2)                                                  }
	Uniform4i                :: proc "c" (location: i32, v0: i32, v1: i32, v2: i32, v3: i32)                                          {        impl_Uniform4i(location, v0, v1, v2, v3)                                              }
	Uniform1fv               :: proc "c" (location: i32, count: i32, value: [^]f32)                                                {        impl_Uniform1fv(location, count, value)                                               }
	Uniform2fv               :: proc "c" (location: i32, count: i32, value: [^]f32)                                                {        impl_Uniform2fv(location, count, value)                                               }
	Uniform3fv               :: proc "c" (location: i32, count: i32, value: [^]f32)                                                {        impl_Uniform3fv(location, count, value)                                               }
	Uniform4fv               :: proc "c" (location: i32, count: i32, value: [^]f32)                                                {        impl_Uniform4fv(location, count, value)                                               }
	Uniform1iv               :: proc "c" (location: i32, count: i32, value: [^]i32)                                                {        impl_Uniform1iv(location, count, value)                                               }
	Uniform2iv               :: proc "c" (location: i32, count: i32, value: [^]i32)                                                {        impl_Uniform2iv(location, count, value)                                               }
	Uniform3iv               :: proc "c" (location: i32, count: i32, value: [^]i32)                                                {        impl_Uniform3iv(location, count, value)                                               }
	Uniform4iv               :: proc "c" (location: i32, count: i32, value: [^]i32)                                                {        impl_Uniform4iv(location, count, value)                                               }
	UniformMatrix2fv         :: proc "c" (location: i32, count: i32, transpose: bool, value: [^]f32)                               {        impl_UniformMatrix2fv(location, count, transpose, value)                              }
	UniformMatrix3fv         :: proc "c" (location: i32, count: i32, transpose: bool, value: [^]f32)                               {        impl_UniformMatrix3fv(location, count, transpose, value)                              }
	UniformMatrix4fv         :: proc "c" (location: i32, count: i32, transpose: bool, value: [^]f32)                               {        impl_UniformMatrix4fv(location, count, transpose, value)                              }
	ValidateProgram          :: proc "c" (program: u32)                                                                               {        impl_ValidateProgram(program)                                                         }
	VertexAttrib1d           :: proc "c" (index: u32, x: f64)                                                                         {        impl_VertexAttrib1d(index, x)                                                         }
	VertexAttrib1dv          :: proc "c" (index: u32, v: ^f64)                                                                        {        impl_VertexAttrib1dv(index, v)                                                        }
	VertexAttrib1f           :: proc "c" (index: u32, x: f32)                                                                         {        impl_VertexAttrib1f(index, x)                                                         }
	VertexAttrib1fv          :: proc "c" (index: u32, v: ^f32)                                                                        {        impl_VertexAttrib1fv(index, v)                                                        }
	VertexAttrib1s           :: proc "c" (index: u32, x: i16)                                                                         {        impl_VertexAttrib1s(index, x)                                                         }
	VertexAttrib1sv          :: proc "c" (index: u32, v: ^i16)                                                                      {        impl_VertexAttrib1sv(index, v)                                                        }
	VertexAttrib2d           :: proc "c" (index: u32, x: f64, y: f64)                                                                 {        impl_VertexAttrib2d(index, x, y)                                                      }
	VertexAttrib2dv          :: proc "c" (index: u32, v: ^[2]f64)                                                                      {        impl_VertexAttrib2dv(index, v)                                                        }
	VertexAttrib2f           :: proc "c" (index: u32, x: f32, y: f32)                                                                 {        impl_VertexAttrib2f(index, x, y)                                                      }
	VertexAttrib2fv          :: proc "c" (index: u32, v: ^[2]f32)                                                                      {        impl_VertexAttrib2fv(index, v)                                                        }
	VertexAttrib2s           :: proc "c" (index: u32, x: i16, y: i16)                                                                 {        impl_VertexAttrib2s(index, x, y)                                                      }
	VertexAttrib2sv          :: proc "c" (index: u32, v: ^[2]i16)                                                                      {        impl_VertexAttrib2sv(index, v)                                                        }
	VertexAttrib3d           :: proc "c" (index: u32, x: f64, y: f64, z: f64)                                                         {        impl_VertexAttrib3d(index, x, y, z)                                                   }
	VertexAttrib3dv          :: proc "c" (index: u32, v: ^[3]f64)                                                                      {        impl_VertexAttrib3dv(index, v)                                                        }
	VertexAttrib3f           :: proc "c" (index: u32, x: f32, y: f32, z: f32)                                                         {        impl_VertexAttrib3f(index, x, y, z)                                                   }
	VertexAttrib3fv          :: proc "c" (index: u32, v: ^[3]f32)                                                                      {        impl_VertexAttrib3fv(index, v)                                                        }
	VertexAttrib3s           :: proc "c" (index: u32, x: i16, y: i16, z: i16)                                                         {        impl_VertexAttrib3s(index, x, y, z)                                                   }
	VertexAttrib3sv          :: proc "c" (index: u32, v: ^[3]i16)                                                                      {        impl_VertexAttrib3sv(index, v)                                                        }
	VertexAttrib4Nbv         :: proc "c" (index: u32, v: ^[4]i8)                                                                       {        impl_VertexAttrib4Nbv(index, v)                                                       }
	VertexAttrib4Niv         :: proc "c" (index: u32, v: ^[4]i32)                                                                      {        impl_VertexAttrib4Niv(index, v)                                                       }
	VertexAttrib4Nsv         :: proc "c" (index: u32, v: ^[4]i16)                                                                      {        impl_VertexAttrib4Nsv(index, v)                                                       }
	VertexAttrib4Nub         :: proc "c" (index: u32, x: u8, y: u8, z: u8, w: u8)                                                     {        impl_VertexAttrib4Nub(index, x, y, z, w)                                              }
	VertexAttrib4Nubv        :: proc "c" (index: u32, v: ^[4]u8)                                                                       {        impl_VertexAttrib4Nubv(index, v)                                                      }
	VertexAttrib4Nuiv        :: proc "c" (index: u32, v: ^[4]u32)                                                                      {        impl_VertexAttrib4Nuiv(index, v)                                                      }
	VertexAttrib4Nusv        :: proc "c" (index: u32, v: ^[4]u16)                                                                      {        impl_VertexAttrib4Nusv(index, v)                                                      }
	VertexAttrib4bv          :: proc "c" (index: u32, v: ^[4]i8)                                                                       {        impl_VertexAttrib4bv(index, v)                                                        }
	VertexAttrib4d           :: proc "c" (index: u32, x: f64, y: f64, z: f64, w: f64)                                                 {        impl_VertexAttrib4d(index, x, y, z, w)                                                }
	VertexAttrib4dv          :: proc "c" (index: u32, v: ^[4]f64)                                                                      {        impl_VertexAttrib4dv(index, v)                                                        }
	VertexAttrib4f           :: proc "c" (index: u32, x: f32, y: f32, z: f32, w: f32)                                                 {        impl_VertexAttrib4f(index, x, y, z, w)                                                }
	VertexAttrib4fv          :: proc "c" (index: u32, v: ^[4]f32)                                                                      {        impl_VertexAttrib4fv(index, v)                                                        }
	VertexAttrib4iv          :: proc "c" (index: u32, v: ^[4]i32)                                                                      {        impl_VertexAttrib4iv(index, v)                                                        }
	VertexAttrib4s           :: proc "c" (index: u32, x: i16, y: i16, z: i16, w: i16)                                                 {        impl_VertexAttrib4s(index, x, y, z, w)                                                }
	VertexAttrib4sv          :: proc "c" (index: u32, v: ^[4]i16)                                                                      {        impl_VertexAttrib4sv(index, v)                                                        }
	VertexAttrib4ubv         :: proc "c" (index: u32, v: ^[4]u8)                                                                       {        impl_VertexAttrib4ubv(index, v)                                                       }
	VertexAttrib4uiv         :: proc "c" (index: u32, v: ^[4]u32)                                                                      {        impl_VertexAttrib4uiv(index, v)                                                       }
	VertexAttrib4usv         :: proc "c" (index: u32, v: ^[4]u16)                                                                      {        impl_VertexAttrib4usv(index, v)                                                       }
	VertexAttribPointer      :: proc "c" (index: u32, size: i32, type: u32, normalized: bool, stride: i32, pointer: uintptr)           {        impl_VertexAttribPointer(index, size, type, normalized, stride, pointer)             }

	// VERSION_2_1
	UniformMatrix2x3fv :: proc "c" (location: i32, count: i32, transpose: bool, value: [^]f32) { impl_UniformMatrix2x3fv(location, count, transpose, value) }
	UniformMatrix3x2fv :: proc "c" (location: i32, count: i32, transpose: bool, value: [^]f32) { impl_UniformMatrix3x2fv(location, count, transpose, value) }
	UniformMatrix2x4fv :: proc "c" (location: i32, count: i32, transpose: bool, value: [^]f32) { impl_UniformMatrix2x4fv(location, count, transpose, value) }
	UniformMatrix4x2fv :: proc "c" (location: i32, count: i32, transpose: bool, value: [^]f32) { impl_UniformMatrix4x2fv(location, count, transpose, value) }
	UniformMatrix3x4fv :: proc "c" (location: i32, count: i32, transpose: bool, value: [^]f32) { impl_UniformMatrix3x4fv(location, count, transpose, value) }
	UniformMatrix4x3fv :: proc "c" (location: i32, count: i32, transpose: bool, value: [^]f32) { impl_UniformMatrix4x3fv(location, count, transpose, value) }


	// VERSION_3_0
	ColorMaski                          :: proc "c" (index: u32, r: bool, g: bool, b: bool, a: bool)                                                                         {        impl_ColorMaski(index, r, g, b, a)                                                                     }
	GetBooleani_v                       :: proc "c" (target: u32, index: u32, data: ^bool)                                                                                   {        impl_GetBooleani_v(target, index, data)                                                                }
	GetIntegeri_v                       :: proc "c" (target: u32, index: u32, data: ^i32)                                                                                    {        impl_GetIntegeri_v(target, index, data)                                                                }
	Enablei                             :: proc "c" (target: u32, index: u32)                                                                                                {        impl_Enablei(target, index)                                                                            }
	Disablei                            :: proc "c" (target: u32, index: u32)                                                                                                {        impl_Disablei(target, index)                                                                           }
	IsEnabledi                          :: proc "c" (target: u32, index: u32) -> bool                                                                                        { ret := impl_IsEnabledi(target, index);                                                             return ret }
	BeginTransformFeedback              :: proc "c" (primitiveMode: u32)                                                                                                     {        impl_BeginTransformFeedback(primitiveMode)                                                             }
	EndTransformFeedback                :: proc "c" ()                                                                                                                       {        impl_EndTransformFeedback()                                                                            }
	BindBufferRange                     :: proc "c" (target: u32, index: u32, buffer: u32, offset: int, size: int)                                                           {        impl_BindBufferRange(target, index, buffer, offset, size)                                              }
	BindBufferBase                      :: proc "c" (target: u32, index: u32, buffer: u32)                                                                                   {        impl_BindBufferBase(target, index, buffer)                                                             }
	TransformFeedbackVaryings           :: proc "c" (program: u32, count: i32, varyings: [^]cstring, bufferMode: u32)                                                        {        impl_TransformFeedbackVaryings(program, count, varyings, bufferMode)                                   }
	GetTransformFeedbackVarying         :: proc "c" (program: u32, index: u32, bufSize: i32, length: ^i32, size: ^i32, type: ^u32, name: [^]u8)                              {        impl_GetTransformFeedbackVarying(program, index, bufSize, length, size, type, name)                   }
	ClampColor                          :: proc "c" (target: u32, clamp: u32)                                                                                                {        impl_ClampColor(target, clamp)                                                                         }
	BeginConditionalRender              :: proc "c" (id: u32, mode: u32)                                                                                                     {        impl_BeginConditionalRender(id, mode)                                                                  }
	EndConditionalRender                :: proc "c" ()                                                                                                                       {        impl_EndConditionalRender()                                                                            }
	VertexAttribIPointer                :: proc "c" (index: u32, size: i32, type: u32, stride: i32, pointer: uintptr)                                                         {        impl_VertexAttribIPointer(index, size, type, stride, pointer)                                         }
	GetVertexAttribIiv                  :: proc "c" (index: u32, pname: u32, params: [^]i32)                                                                                 {        impl_GetVertexAttribIiv(index, pname, params)                                                          }
	GetVertexAttribIuiv                 :: proc "c" (index: u32, pname: u32, params: [^]u32)                                                                                 {        impl_GetVertexAttribIuiv(index, pname, params)                                                         }
	VertexAttribI1i                     :: proc "c" (index: u32, x: i32)                                                                                                     {        impl_VertexAttribI1i(index, x)                                                                         }
	VertexAttribI2i                     :: proc "c" (index: u32, x: i32, y: i32)                                                                                             {        impl_VertexAttribI2i(index, x, y)                                                                      }
	VertexAttribI3i                     :: proc "c" (index: u32, x: i32, y: i32, z: i32)                                                                                     {        impl_VertexAttribI3i(index, x, y, z)                                                                   }
	VertexAttribI4i                     :: proc "c" (index: u32, x: i32, y: i32, z: i32, w: i32)                                                                             {        impl_VertexAttribI4i(index, x, y, z, w)                                                                }
	VertexAttribI1ui                    :: proc "c" (index: u32, x: u32)                                                                                                     {        impl_VertexAttribI1ui(index, x)                                                                        }
	VertexAttribI2ui                    :: proc "c" (index: u32, x: u32, y: u32)                                                                                             {        impl_VertexAttribI2ui(index, x, y)                                                                     }
	VertexAttribI3ui                    :: proc "c" (index: u32, x: u32, y: u32, z: u32)                                                                                     {        impl_VertexAttribI3ui(index, x, y, z)                                                                  }
	VertexAttribI4ui                    :: proc "c" (index: u32, x: u32, y: u32, z: u32, w: u32)                                                                             {        impl_VertexAttribI4ui(index, x, y, z, w)                                                               }
	VertexAttribI1iv                    :: proc "c" (index: u32, v: [^]i32)                                                                                                    {        impl_VertexAttribI1iv(index, v)                                                                        }
	VertexAttribI2iv                    :: proc "c" (index: u32, v: [^]i32)                                                                                                    {        impl_VertexAttribI2iv(index, v)                                                                        }
	VertexAttribI3iv                    :: proc "c" (index: u32, v: [^]i32)                                                                                                    {        impl_VertexAttribI3iv(index, v)                                                                        }
	VertexAttribI4iv                    :: proc "c" (index: u32, v: [^]i32)                                                                                                    {        impl_VertexAttribI4iv(index, v)                                                                        }
	VertexAttribI1uiv                   :: proc "c" (index: u32, v: [^]u32)                                                                                                    {        impl_VertexAttribI1uiv(index, v)                                                                       }
	VertexAttribI2uiv                   :: proc "c" (index: u32, v: [^]u32)                                                                                                    {        impl_VertexAttribI2uiv(index, v)                                                                       }
	VertexAttribI3uiv                   :: proc "c" (index: u32, v: [^]u32)                                                                                                    {        impl_VertexAttribI3uiv(index, v)                                                                       }
	VertexAttribI4uiv                   :: proc "c" (index: u32, v: [^]u32)                                                                                                    {        impl_VertexAttribI4uiv(index, v)                                                                       }
	VertexAttribI4bv                    :: proc "c" (index: u32, v: [^]i8)                                                                                                     {        impl_VertexAttribI4bv(index, v)                                                                        }
	VertexAttribI4sv                    :: proc "c" (index: u32, v: [^]i16)                                                                                                    {        impl_VertexAttribI4sv(index, v)                                                                        }
	VertexAttribI4ubv                   :: proc "c" (index: u32, v: [^]u8)                                                                                                     {        impl_VertexAttribI4ubv(index, v)                                                                       }
	VertexAttribI4usv                   :: proc "c" (index: u32, v: [^]u16)                                                                                                    {        impl_VertexAttribI4usv(index, v)                                                                       }
	GetUniformuiv                       :: proc "c" (program: u32, location: i32, params: [^]u32)                                                                            {        impl_GetUniformuiv(program, location, params)                                                          }
	BindFragDataLocation                :: proc "c" (program: u32, color: u32, name: cstring)                                                                                {        impl_BindFragDataLocation(program, color, name)                                                        }
	GetFragDataLocation                 :: proc "c" (program: u32, name: cstring) -> i32                                                                                     { ret := impl_GetFragDataLocation(program, name);                                                    return ret }
	Uniform1ui                          :: proc "c" (location: i32, v0: u32)                                                                                                 {        impl_Uniform1ui(location, v0)                                                                          }
	Uniform2ui                          :: proc "c" (location: i32, v0: u32, v1: u32)                                                                                        {        impl_Uniform2ui(location, v0, v1)                                                                      }
	Uniform3ui                          :: proc "c" (location: i32, v0: u32, v1: u32, v2: u32)                                                                               {        impl_Uniform3ui(location, v0, v1, v2)                                                                  }
	Uniform4ui                          :: proc "c" (location: i32, v0: u32, v1: u32, v2: u32, v3: u32)                                                                      {        impl_Uniform4ui(location, v0, v1, v2, v3)                                                              }
	Uniform1uiv                         :: proc "c" (location: i32, count: i32, value: [^]u32)                                                                               {        impl_Uniform1uiv(location, count, value)                                                               }
	Uniform2uiv                         :: proc "c" (location: i32, count: i32, value: [^]u32)                                                                               {        impl_Uniform2uiv(location, count, value)                                                               }
	Uniform3uiv                         :: proc "c" (location: i32, count: i32, value: [^]u32)                                                                               {        impl_Uniform3uiv(location, count, value)                                                               }
	Uniform4uiv                         :: proc "c" (location: i32, count: i32, value: [^]u32)                                                                               {        impl_Uniform4uiv(location, count, value)                                                               }
	TexParameterIiv                     :: proc "c" (target: u32, pname: u32, params: [^]i32)                                                                                {        impl_TexParameterIiv(target, pname, params)                                                            }
	TexParameterIuiv                    :: proc "c" (target: u32, pname: u32, params: [^]u32)                                                                                {        impl_TexParameterIuiv(target, pname, params)                                                           }
	GetTexParameterIiv                  :: proc "c" (target: u32, pname: u32, params: [^]i32)                                                                                {        impl_GetTexParameterIiv(target, pname, params)                                                         }
	GetTexParameterIuiv                 :: proc "c" (target: u32, pname: u32, params: [^]u32)                                                                                {        impl_GetTexParameterIuiv(target, pname, params)                                                        }
	ClearBufferiv                       :: proc "c" (buffer: u32, drawbuffer: i32, value: ^i32)                                                                              {        impl_ClearBufferiv(buffer, drawbuffer, value)                                                          }
	ClearBufferuiv                      :: proc "c" (buffer: u32, drawbuffer: i32, value: ^u32)                                                                              {        impl_ClearBufferuiv(buffer, drawbuffer, value)                                                         }
	ClearBufferfv                       :: proc "c" (buffer: u32, drawbuffer: i32, value: ^f32)                                                                              {        impl_ClearBufferfv(buffer, drawbuffer, value)                                                          }
	ClearBufferfi                       :: proc "c" (buffer: u32, drawbuffer: i32, depth: f32, stencil: i32) -> rawptr                                                       { ret := impl_ClearBufferfi(buffer, drawbuffer, depth, stencil);                                     return ret }
	GetStringi                          :: proc "c" (name: u32, index: u32) -> cstring                                                                                       { ret := impl_GetStringi(name, index);                                                               return ret }
	IsRenderbuffer                      :: proc "c" (renderbuffer: u32) -> bool                                                                                              { ret := impl_IsRenderbuffer(renderbuffer);                                                          return ret }
	BindRenderbuffer                    :: proc "c" (target: u32, renderbuffer: u32)                                                                                         {        impl_BindRenderbuffer(target, renderbuffer)                                                            }
	DeleteRenderbuffers                 :: proc "c" (n: i32, renderbuffers: [^]u32)                                                                                          {        impl_DeleteRenderbuffers(n, renderbuffers)                                                             }
	GenRenderbuffers                    :: proc "c" (n: i32, renderbuffers: [^]u32)                                                                                          {        impl_GenRenderbuffers(n, renderbuffers)                                                                }
	RenderbufferStorage                 :: proc "c" (target: u32, internalformat: u32, width: i32, height: i32)                                                              {        impl_RenderbufferStorage(target, internalformat, width, height)                                        }
	GetRenderbufferParameteriv          :: proc "c" (target: u32, pname: u32, params: [^]i32)                                                                                {        impl_GetRenderbufferParameteriv(target, pname, params)                                                 }
	IsFramebuffer                       :: proc "c" (framebuffer: u32) -> bool                                                                                               { ret := impl_IsFramebuffer(framebuffer);                                                            return ret }
	BindFramebuffer                     :: proc "c" (target: u32, framebuffer: u32)                                                                                          {        impl_BindFramebuffer(target, framebuffer)                                                              }
	DeleteFramebuffers                  :: proc "c" (n: i32, framebuffers: [^]u32)                                                                                           {        impl_DeleteFramebuffers(n, framebuffers)                                                               }
	GenFramebuffers                     :: proc "c" (n: i32, framebuffers: [^]u32)                                                                                           {        impl_GenFramebuffers(n, framebuffers)                                                                  }
	CheckFramebufferStatus              :: proc "c" (target: u32) -> u32                                                                                                     { ret := impl_CheckFramebufferStatus(target);                                                        return ret }
	FramebufferTexture1D                :: proc "c" (target: u32, attachment: u32, textarget: u32, texture: u32, level: i32)                                                 {        impl_FramebufferTexture1D(target, attachment, textarget, texture, level)                               }
	FramebufferTexture2D                :: proc "c" (target: u32, attachment: u32, textarget: u32, texture: u32, level: i32)                                                 {        impl_FramebufferTexture2D(target, attachment, textarget, texture, level)                               }
	FramebufferTexture3D                :: proc "c" (target: u32, attachment: u32, textarget: u32, texture: u32, level: i32, zoffset: i32)                                   {        impl_FramebufferTexture3D(target, attachment, textarget, texture, level, zoffset)                      }
	FramebufferRenderbuffer             :: proc "c" (target: u32, attachment: u32, renderbuffertarget: u32, renderbuffer: u32)                                               {        impl_FramebufferRenderbuffer(target, attachment, renderbuffertarget, renderbuffer)                     }
	GetFramebufferAttachmentParameteriv :: proc "c" (target: u32, attachment: u32, pname: u32, params: [^]i32)                                                               {        impl_GetFramebufferAttachmentParameteriv(target, attachment, pname, params)                            }
	GenerateMipmap                      :: proc "c" (target: u32)                                                                                                            {        impl_GenerateMipmap(target)                                                                            }
	BlitFramebuffer                     :: proc "c" (srcX0: i32, srcY0: i32, srcX1: i32, srcY1: i32, dstX0: i32, dstY0: i32, dstX1: i32, dstY1: i32, mask: u32, filter: u32) {        impl_BlitFramebuffer(srcX0, srcY0, srcX1, srcY1, dstX0, dstY0, dstX1, dstY1, mask, filter)             }
	RenderbufferStorageMultisample      :: proc "c" (target: u32, samples: i32, internalformat: u32, width: i32, height: i32)                                                {        impl_RenderbufferStorageMultisample(target, samples, internalformat, width, height)                    }
	FramebufferTextureLayer             :: proc "c" (target: u32, attachment: u32, texture: u32, level: i32, layer: i32)                                                     {        impl_FramebufferTextureLayer(target, attachment, texture, level, layer)                                }
	MapBufferRange                      :: proc "c" (target: u32, offset: int, length: int, access: u32) -> rawptr                                                           { ret := impl_MapBufferRange(target, offset, length, access);                                        return ret }
	FlushMappedBufferRange              :: proc "c" (target: u32, offset: int, length: int)                                                                                  {        impl_FlushMappedBufferRange(target, offset, length)                                                    }
	BindVertexArray                     :: proc "c" (array: u32)                                                                                                             {        impl_BindVertexArray(array)                                                                            }
	DeleteVertexArrays                  :: proc "c" (n: i32, arrays: [^]u32)                                                                                                 {        impl_DeleteVertexArrays(n, arrays)                                                                     }
	GenVertexArrays                     :: proc "c" (n: i32, arrays: [^]u32)                                                                                                 {        impl_GenVertexArrays(n, arrays)                                                                        }
	IsVertexArray                       :: proc "c" (array: u32) -> bool                                                                                                     { ret := impl_IsVertexArray(array);                                                                  return ret }

	// VERSION_3_1
	DrawArraysInstanced       :: proc "c" (mode: u32, first: i32, count: i32, instancecount: i32)                                     {        impl_DrawArraysInstanced(mode, first, count, instancecount)                                               }
	DrawElementsInstanced     :: proc "c" (mode: u32, count: i32, type: u32, indices: rawptr, instancecount: i32)                     {        impl_DrawElementsInstanced(mode, count, type, indices, instancecount)                                    }
	TexBuffer                 :: proc "c" (target: u32, internalformat: u32, buffer: u32)                                             {        impl_TexBuffer(target, internalformat, buffer)                                                            }
	PrimitiveRestartIndex     :: proc "c" (index: u32)                                                                                {        impl_PrimitiveRestartIndex(index)                                                                         }
	CopyBufferSubData         :: proc "c" (readTarget: u32, writeTarget: u32, readOffset: int, writeOffset: int, size: int)           {        impl_CopyBufferSubData(readTarget, writeTarget, readOffset, writeOffset, size)                            }
	GetUniformIndices         :: proc "c" (program: u32, uniformCount: i32, uniformNames: [^]cstring, uniformIndices: [^]u32)         {        impl_GetUniformIndices(program, uniformCount, uniformNames, uniformIndices)                               }
	GetActiveUniformsiv       :: proc "c" (program: u32, uniformCount: i32, uniformIndices: [^]u32, pname: u32, params: [^]i32)       {        impl_GetActiveUniformsiv(program, uniformCount, uniformIndices, pname, params)                            }
	GetActiveUniformName      :: proc "c" (program: u32, uniformIndex: u32, bufSize: i32, length: ^i32, uniformName: [^]u8)           {        impl_GetActiveUniformName(program, uniformIndex, bufSize, length, uniformName)                            }
	GetUniformBlockIndex      :: proc "c" (program: u32, uniformBlockName: cstring) -> u32                                            { ret := impl_GetUniformBlockIndex(program, uniformBlockName);                                          return ret }
	GetActiveUniformBlockiv   :: proc "c" (program: u32, uniformBlockIndex: u32, pname: u32, params: [^]i32)                          {        impl_GetActiveUniformBlockiv(program, uniformBlockIndex, pname, params)                                   }
	GetActiveUniformBlockName :: proc "c" (program: u32, uniformBlockIndex: u32, bufSize: i32, length: ^i32, uniformBlockName: [^]u8) {        impl_GetActiveUniformBlockName(program, uniformBlockIndex, bufSize, length, uniformBlockName)             }
	UniformBlockBinding       :: proc "c" (program: u32, uniformBlockIndex: u32, uniformBlockBinding: u32)                            {        impl_UniformBlockBinding(program, uniformBlockIndex, uniformBlockBinding)                                 }

	// VERSION_3_2
	DrawElementsBaseVertex          :: proc "c" (mode: u32, count: i32, type: u32, indices: rawptr, basevertex: i32)                                            {        impl_DrawElementsBaseVertex(mode, count, type, indices, basevertex)                                                }
	DrawRangeElementsBaseVertex     :: proc "c" (mode: u32, start: u32, end: u32, count: i32, type: u32, indices: rawptr, basevertex: i32)                      {        impl_DrawRangeElementsBaseVertex(mode, start, end, count, type, indices, basevertex)                               }
	DrawElementsInstancedBaseVertex :: proc "c" (mode: u32, count: i32, type: u32, indices: rawptr, instancecount: i32, basevertex: i32)                        {        impl_DrawElementsInstancedBaseVertex(mode, count, type, indices, instancecount, basevertex)                        }
	MultiDrawElementsBaseVertex     :: proc "c" (mode: u32, count: [^]i32, type: u32, indices: [^]rawptr, drawcount: i32, basevertex: [^]i32)                   {        impl_MultiDrawElementsBaseVertex(mode, count, type, indices, drawcount, basevertex)                                }
	ProvokingVertex                 :: proc "c" (mode: u32)                                                                                                     {        impl_ProvokingVertex(mode)                                                                                          }
	FenceSync                       :: proc "c" (condition: u32, flags: u32) -> sync_t                                                                          { ret := impl_FenceSync(condition, flags);                                                                        return ret }
	IsSync                          :: proc "c" (sync: sync_t) -> bool                                                                                          { ret := impl_IsSync(sync);                                                                                       return ret }
	DeleteSync                      :: proc "c" (sync: sync_t)                                                                                                  {        impl_DeleteSync(sync)                                                                                               }
	ClientWaitSync                  :: proc "c" (sync: sync_t, flags: u32, timeout: u64) -> u32                                                                 { ret := impl_ClientWaitSync(sync, flags, timeout);                                                               return ret }
	WaitSync                        :: proc "c" (sync: sync_t, flags: u32, timeout: u64)                                                                        {        impl_WaitSync(sync, flags, timeout)                                                                                 }
	GetInteger64v                   :: proc "c" (pname: u32, data: ^i64)                                                                                        {        impl_GetInteger64v(pname, data)                                                                                     }
	GetSynciv                       :: proc "c" (sync: sync_t, pname: u32, bufSize: i32, length: ^i32, values: [^]i32)                                          {        impl_GetSynciv(sync, pname, bufSize, length, values)                                                                }
	GetInteger64i_v                 :: proc "c" (target: u32, index: u32, data: ^i64)                                                                           {        impl_GetInteger64i_v(target, index, data)                                                                           }
	GetBufferParameteri64v          :: proc "c" (target: u32, pname: u32, params: [^]i64)                                                                       {        impl_GetBufferParameteri64v(target, pname, params)                                                                  }
	FramebufferTexture              :: proc "c" (target: u32, attachment: u32, texture: u32, level: i32)                                                        {        impl_FramebufferTexture(target, attachment, texture, level)                                                         }
	TexImage2DMultisample           :: proc "c" (target: u32, samples: i32, internalformat: u32, width: i32, height: i32, fixedsamplelocations: bool)             {        impl_TexImage2DMultisample(target, samples, internalformat, width, height, fixedsamplelocations)                    }
	TexImage3DMultisample           :: proc "c" (target: u32, samples: i32, internalformat: u32, width: i32, height: i32, depth: i32, fixedsamplelocations: bool) {        impl_TexImage3DMultisample(target, samples, internalformat, width, height, depth, fixedsamplelocations)             }
	GetMultisamplefv                :: proc "c" (pname: u32, index: u32, val: ^f32)                                                                             {        impl_GetMultisamplefv(pname, index, val)                                                                            }
	SampleMaski                     :: proc "c" (maskNumber: u32, mask: u32)                                                                                    {        impl_SampleMaski(maskNumber, mask)                                                                                  }

	// VERSION_3_3
	BindFragDataLocationIndexed :: proc "c" (program: u32, colorNumber: u32, index: u32, name: cstring) {        impl_BindFragDataLocationIndexed(program, colorNumber, index, name)             }
	GetFragDataIndex            :: proc "c" (program: u32, name: cstring) -> i32                        { ret := impl_GetFragDataIndex(program, name);                                return ret }
	GenSamplers                 :: proc "c" (count: i32, samplers: [^]u32)                              {        impl_GenSamplers(count, samplers)                                               }
	DeleteSamplers              :: proc "c" (count: i32, samplers: [^]u32)                              {        impl_DeleteSamplers(count, samplers)                                            }
	IsSampler                   :: proc "c" (sampler: u32) -> bool                                      { ret := impl_IsSampler(sampler);                                             return ret }
	BindSampler                 :: proc "c" (unit: u32, sampler: u32)                                   {        impl_BindSampler(unit, sampler)                                                 }
	SamplerParameteri           :: proc "c" (sampler: u32, pname: u32, param: i32)                      {        impl_SamplerParameteri(sampler, pname, param)                                   }
	SamplerParameteriv          :: proc "c" (sampler: u32, pname: u32, param: ^i32)                     {        impl_SamplerParameteriv(sampler, pname, param)                                  }
	SamplerParameterf           :: proc "c" (sampler: u32, pname: u32, param: f32)                      {        impl_SamplerParameterf(sampler, pname, param)                                   }
	SamplerParameterfv          :: proc "c" (sampler: u32, pname: u32, param: ^f32)                     {        impl_SamplerParameterfv(sampler, pname, param)                                  }
	SamplerParameterIiv         :: proc "c" (sampler: u32, pname: u32, param: ^i32)                     {        impl_SamplerParameterIiv(sampler, pname, param)                                 }
	SamplerParameterIuiv        :: proc "c" (sampler: u32, pname: u32, param: ^u32)                     {        impl_SamplerParameterIuiv(sampler, pname, param)                                }
	GetSamplerParameteriv       :: proc "c" (sampler: u32, pname: u32, params: [^]i32)                  {        impl_GetSamplerParameteriv(sampler, pname, params)                              }
	GetSamplerParameterIiv      :: proc "c" (sampler: u32, pname: u32, params: [^]i32)                  {        impl_GetSamplerParameterIiv(sampler, pname, params)                             }
	GetSamplerParameterfv       :: proc "c" (sampler: u32, pname: u32, params: [^]f32)                  {        impl_GetSamplerParameterfv(sampler, pname, params)                              }
	GetSamplerParameterIuiv     :: proc "c" (sampler: u32, pname: u32, params: [^]u32)                  {        impl_GetSamplerParameterIuiv(sampler, pname, params)                            }
	QueryCounter                :: proc "c" (id: u32, target: u32)                                      {        impl_QueryCounter(id, target)                                                   }
	GetQueryObjecti64v          :: proc "c" (id: u32, pname: u32, params: [^]i64)                       {        impl_GetQueryObjecti64v(id, pname, params)                                      }
	GetQueryObjectui64v         :: proc "c" (id: u32, pname: u32, params: [^]u64)                       {        impl_GetQueryObjectui64v(id, pname, params)                                     }
	VertexAttribDivisor         :: proc "c" (index: u32, divisor: u32)                                  {        impl_VertexAttribDivisor(index, divisor)                                        }
	VertexAttribP1ui            :: proc "c" (index: u32, type: u32, normalized: bool, value: u32)       {        impl_VertexAttribP1ui(index, type, normalized, value)                          }
	VertexAttribP1uiv           :: proc "c" (index: u32, type: u32, normalized: bool, value: ^u32)      {        impl_VertexAttribP1uiv(index, type, normalized, value)                         }
	VertexAttribP2ui            :: proc "c" (index: u32, type: u32, normalized: bool, value: u32)       {        impl_VertexAttribP2ui(index, type, normalized, value)                          }
	VertexAttribP2uiv           :: proc "c" (index: u32, type: u32, normalized: bool, value: ^u32)      {        impl_VertexAttribP2uiv(index, type, normalized, value)                         }
	VertexAttribP3ui            :: proc "c" (index: u32, type: u32, normalized: bool, value: u32)       {        impl_VertexAttribP3ui(index, type, normalized, value)                          }
	VertexAttribP3uiv           :: proc "c" (index: u32, type: u32, normalized: bool, value: ^u32)      {        impl_VertexAttribP3uiv(index, type, normalized, value)                         }
	VertexAttribP4ui            :: proc "c" (index: u32, type: u32, normalized: bool, value: u32)       {        impl_VertexAttribP4ui(index, type, normalized, value)                          }
	VertexAttribP4uiv           :: proc "c" (index: u32, type: u32, normalized: bool, value: ^u32)      {        impl_VertexAttribP4uiv(index, type, normalized, value)                         }
	VertexP2ui                  :: proc "c" (type: u32, value: u32)                                     {        impl_VertexP2ui(type, value)                                                   }
	VertexP2uiv                 :: proc "c" (type: u32, value: ^u32)                                    {        impl_VertexP2uiv(type, value)                                                  }
	VertexP3ui                  :: proc "c" (type: u32, value: u32)                                     {        impl_VertexP3ui(type, value)                                                   }
	VertexP3uiv                 :: proc "c" (type: u32, value: ^u32)                                    {        impl_VertexP3uiv(type, value)                                                  }
	VertexP4ui                  :: proc "c" (type: u32, value: u32)                                     {        impl_VertexP4ui(type, value)                                                   }
	VertexP4uiv                 :: proc "c" (type: u32, value: ^u32)                                    {        impl_VertexP4uiv(type, value)                                                  }
	TexCoordP1ui                :: proc "c" (type: u32, coords: u32)                                    {        impl_TexCoordP1ui(type, coords)                                                }
	TexCoordP1uiv               :: proc "c" (type: u32, coords: [^]u32)                                 {        impl_TexCoordP1uiv(type, coords)                                               }
	TexCoordP2ui                :: proc "c" (type: u32, coords: u32)                                    {        impl_TexCoordP2ui(type, coords)                                                }
	TexCoordP2uiv               :: proc "c" (type: u32, coords: [^]u32)                                 {        impl_TexCoordP2uiv(type, coords)                                               }
	TexCoordP3ui                :: proc "c" (type: u32, coords: u32)                                    {        impl_TexCoordP3ui(type, coords)                                                }
	TexCoordP3uiv               :: proc "c" (type: u32, coords: [^]u32)                                 {        impl_TexCoordP3uiv(type, coords)                                               }
	TexCoordP4ui                :: proc "c" (type: u32, coords: u32)                                    {        impl_TexCoordP4ui(type, coords)                                                }
	TexCoordP4uiv               :: proc "c" (type: u32, coords: [^]u32)                                 {        impl_TexCoordP4uiv(type, coords)                                               }
	MultiTexCoordP1ui           :: proc "c" (texture: u32, type: u32, coords: u32)                      {        impl_MultiTexCoordP1ui(texture, type, coords)                                  }
	MultiTexCoordP1uiv          :: proc "c" (texture: u32, type: u32, coords: [^]u32)                   {        impl_MultiTexCoordP1uiv(texture, type, coords)                                 }
	MultiTexCoordP2ui           :: proc "c" (texture: u32, type: u32, coords: u32)                      {        impl_MultiTexCoordP2ui(texture, type, coords)                                  }
	MultiTexCoordP2uiv          :: proc "c" (texture: u32, type: u32, coords: [^]u32)                   {        impl_MultiTexCoordP2uiv(texture, type, coords)                                 }
	MultiTexCoordP3ui           :: proc "c" (texture: u32, type: u32, coords: u32)                      {        impl_MultiTexCoordP3ui(texture, type, coords)                                  }
	MultiTexCoordP3uiv          :: proc "c" (texture: u32, type: u32, coords: [^]u32)                   {        impl_MultiTexCoordP3uiv(texture, type, coords)                                 }
	MultiTexCoordP4ui           :: proc "c" (texture: u32, type: u32, coords: u32)                      {        impl_MultiTexCoordP4ui(texture, type, coords)                                  }
	MultiTexCoordP4uiv          :: proc "c" (texture: u32, type: u32, coords: [^]u32)                   {        impl_MultiTexCoordP4uiv(texture, type, coords)                                 }
	NormalP3ui                  :: proc "c" (type: u32, coords: u32)                                    {        impl_NormalP3ui(type, coords)                                                  }
	NormalP3uiv                 :: proc "c" (type: u32, coords: [^]u32)                                 {        impl_NormalP3uiv(type, coords)                                                 }
	ColorP3ui                   :: proc "c" (type: u32, color: u32)                                     {        impl_ColorP3ui(type, color)                                                    }
	ColorP3uiv                  :: proc "c" (type: u32, color: ^u32)                                    {        impl_ColorP3uiv(type, color)                                                   }
	ColorP4ui                   :: proc "c" (type: u32, color: u32)                                     {        impl_ColorP4ui(type, color)                                                    }
	ColorP4uiv                  :: proc "c" (type: u32, color: ^u32)                                    {        impl_ColorP4uiv(type, color)                                                   }
	SecondaryColorP3ui          :: proc "c" (type: u32, color: u32)                                     {        impl_SecondaryColorP3ui(type, color)                                           }
	SecondaryColorP3uiv         :: proc "c" (type: u32, color: ^u32)                                    {        impl_SecondaryColorP3uiv(type, color)                                          }

	// VERSION_4_0
	MinSampleShading               :: proc "c" (value: f32)                                                                         {        impl_MinSampleShading(value)                                                                        }
	BlendEquationi                 :: proc "c" (buf: u32, mode: u32)                                                                {        impl_BlendEquationi(buf, mode)                                                                      }
	BlendEquationSeparatei         :: proc "c" (buf: u32, modeRGB: u32, modeAlpha: u32)                                             {        impl_BlendEquationSeparatei(buf, modeRGB, modeAlpha)                                                }
	BlendFunci                     :: proc "c" (buf: u32, src: u32, dst: u32)                                                       {        impl_BlendFunci(buf, src, dst)                                                                      }
	BlendFuncSeparatei             :: proc "c" (buf: u32, srcRGB: u32, dstRGB: u32, srcAlpha: u32, dstAlpha: u32)                   {        impl_BlendFuncSeparatei(buf, srcRGB, dstRGB, srcAlpha, dstAlpha)                                    }
	DrawArraysIndirect             :: proc "c" (mode: u32, indirect: ^DrawArraysIndirectCommand)                                    {        impl_DrawArraysIndirect(mode, indirect)                                                             }
	DrawElementsIndirect           :: proc "c" (mode: u32, type: u32, indirect: ^DrawElementsIndirectCommand)                       {        impl_DrawElementsIndirect(mode, type, indirect)                                                    }
	Uniform1d                      :: proc "c" (location: i32, x: f64)                                                              {        impl_Uniform1d(location, x)                                                                         }
	Uniform2d                      :: proc "c" (location: i32, x: f64, y: f64)                                                      {        impl_Uniform2d(location, x, y)                                                                      }
	Uniform3d                      :: proc "c" (location: i32, x: f64, y: f64, z: f64)                                              {        impl_Uniform3d(location, x, y, z)                                                                   }
	Uniform4d                      :: proc "c" (location: i32, x: f64, y: f64, z: f64, w: f64)                                      {        impl_Uniform4d(location, x, y, z, w)                                                                }
	Uniform1dv                     :: proc "c" (location: i32, count: i32, value: [^]f64)                                          {        impl_Uniform1dv(location, count, value)                                                             }
	Uniform2dv                     :: proc "c" (location: i32, count: i32, value: [^]f64)                                          {        impl_Uniform2dv(location, count, value)                                                             }
	Uniform3dv                     :: proc "c" (location: i32, count: i32, value: [^]f64)                                          {        impl_Uniform3dv(location, count, value)                                                             }
	Uniform4dv                     :: proc "c" (location: i32, count: i32, value: [^]f64)                                          {        impl_Uniform4dv(location, count, value)                                                             }
	UniformMatrix2dv               :: proc "c" (location: i32, count: i32, transpose: bool, value: [^]f64)                       {        impl_UniformMatrix2dv(location, count, transpose, value)                                            }
	UniformMatrix3dv               :: proc "c" (location: i32, count: i32, transpose: bool, value: [^]f64)                       {        impl_UniformMatrix3dv(location, count, transpose, value)                                            }
	UniformMatrix4dv               :: proc "c" (location: i32, count: i32, transpose: bool, value: [^]f64)                       {        impl_UniformMatrix4dv(location, count, transpose, value)                                            }
	UniformMatrix2x3dv             :: proc "c" (location: i32, count: i32, transpose: bool, value: [^]f64)                       {        impl_UniformMatrix2x3dv(location, count, transpose, value)                                          }
	UniformMatrix2x4dv             :: proc "c" (location: i32, count: i32, transpose: bool, value: [^]f64)                       {        impl_UniformMatrix2x4dv(location, count, transpose, value)                                          }
	UniformMatrix3x2dv             :: proc "c" (location: i32, count: i32, transpose: bool, value: [^]f64)                       {        impl_UniformMatrix3x2dv(location, count, transpose, value)                                          }
	UniformMatrix3x4dv             :: proc "c" (location: i32, count: i32, transpose: bool, value: [^]f64)                       {        impl_UniformMatrix3x4dv(location, count, transpose, value)                                          }
	UniformMatrix4x2dv             :: proc "c" (location: i32, count: i32, transpose: bool, value: [^]f64)                       {        impl_UniformMatrix4x2dv(location, count, transpose, value)                                          }
	UniformMatrix4x3dv             :: proc "c" (location: i32, count: i32, transpose: bool, value: [^]f64)                       {        impl_UniformMatrix4x3dv(location, count, transpose, value)                                          }
	GetUniformdv                   :: proc "c" (program: u32, location: i32, params: [^]f64)                                        {        impl_GetUniformdv(program, location, params)                                                        }
	GetSubroutineUniformLocation   :: proc "c" (program: u32, shadertype: u32, name: cstring) -> i32                                { ret := impl_GetSubroutineUniformLocation(program, shadertype, name);                           return ret }
	GetSubroutineIndex             :: proc "c" (program: u32, shadertype: u32, name: cstring) -> u32                                { ret := impl_GetSubroutineIndex(program, shadertype, name);                                     return ret }
	GetActiveSubroutineUniformiv   :: proc "c" (program: u32, shadertype: u32, index: u32, pname: u32, values: [^]i32)              {        impl_GetActiveSubroutineUniformiv(program, shadertype, index, pname, values)                       }
	GetActiveSubroutineUniformName :: proc "c" (program: u32, shadertype: u32, index: u32, bufsize: i32, length: ^i32, name: [^]u8) {        impl_GetActiveSubroutineUniformName(program, shadertype, index, bufsize, length, name)             }
	GetActiveSubroutineName        :: proc "c" (program: u32, shadertype: u32, index: u32, bufsize: i32, length: ^i32, name: [^]u8) {        impl_GetActiveSubroutineName(program, shadertype, index, bufsize, length, name)                    }
	UniformSubroutinesuiv          :: proc "c" (shadertype: u32, count: i32, indices: [^]u32)                                         {        impl_UniformSubroutinesuiv(shadertype, count, indices)                                             }
	GetUniformSubroutineuiv        :: proc "c" (shadertype: u32, location: i32, params: [^]u32)                                     {        impl_GetUniformSubroutineuiv(shadertype, location, params)                                         }
	GetProgramStageiv              :: proc "c" (program: u32, shadertype: u32, pname: u32, values: [^]i32)                          {        impl_GetProgramStageiv(program, shadertype, pname, values)                                         }
	PatchParameteri                :: proc "c" (pname: u32, value: i32)                                                             {        impl_PatchParameteri(pname, value)                                                                  }
	PatchParameterfv               :: proc "c" (pname: u32, values: [^]f32)                                                         {        impl_PatchParameterfv(pname, values)                                                                }
	BindTransformFeedback          :: proc "c" (target: u32, id: u32)                                                               {        impl_BindTransformFeedback(target, id)                                                              }
	DeleteTransformFeedbacks       :: proc "c" (n: i32, ids: [^]u32)                                                                {        impl_DeleteTransformFeedbacks(n, ids)                                                               }
	GenTransformFeedbacks          :: proc "c" (n: i32, ids: [^]u32)                                                                {        impl_GenTransformFeedbacks(n, ids)                                                                  }
	IsTransformFeedback            :: proc "c" (id: u32) -> bool                                                                    { ret := impl_IsTransformFeedback(id);                                                            return ret }
	PauseTransformFeedback         :: proc "c" ()                                                                                   {        impl_PauseTransformFeedback()                                                                       }
	ResumeTransformFeedback        :: proc "c" ()                                                                                   {        impl_ResumeTransformFeedback()                                                                      }
	DrawTransformFeedback          :: proc "c" (mode: u32, id: u32)                                                                 {        impl_DrawTransformFeedback(mode, id)                                                                }
	DrawTransformFeedbackStream    :: proc "c" (mode: u32, id: u32, stream: u32)                                                    {        impl_DrawTransformFeedbackStream(mode, id, stream)                                                  }
	BeginQueryIndexed              :: proc "c" (target: u32, index: u32, id: u32)                                                   {        impl_BeginQueryIndexed(target, index, id)                                                           }
	EndQueryIndexed                :: proc "c" (target: u32, index: u32)                                                            {        impl_EndQueryIndexed(target, index)                                                                 }
	GetQueryIndexediv              :: proc "c" (target: u32, index: u32, pname: u32, params: [^]i32)                                {        impl_GetQueryIndexediv(target, index, pname, params)                                                }
	GetTextureHandleARB            :: proc "c" (texture: u32) -> u64
	{        return impl_GetTextureHandleARB(texture)                                                }
	GetTextureSamplerHandleARB     :: proc "c" (texture, sampler: u32) -> u64
	{        return impl_GetTextureSamplerHandleARB(texture, sampler)                                                }
	GetImageHandleARB              :: proc "c" (texture: u32, level: i32, layered: bool, layer: i32, format: u32) -> u64
	{        return impl_GetImageHandleARB(texture, level, layered, layer, format)                                                }
	MakeTextureHandleResidentARB   :: proc "c" (handle: u64)
	{        impl_MakeTextureHandleResidentARB(handle)                                                }
	MakeImageHandleResidentARB     :: proc "c" (handle: u64, access: u32)
	{        impl_MakeImageHandleResidentARB(handle, access)                                                }
	MakeTextureHandleNonResidentARB:: proc "c" (handle: u64)
	{        impl_MakeTextureHandleNonResidentARB(handle)                                                }
	MakeImageHandleNonResidentARB  :: proc "c" (handle: u64)
	{        impl_MakeImageHandleNonResidentARB(handle)                                                }

	// VERSION_4_1
	ReleaseShaderCompiler     :: proc "c" ()                                                                             {        impl_ReleaseShaderCompiler()                                                             }
	ShaderBinary              :: proc "c" (count: i32, shaders: ^u32, binaryformat: u32, binary: rawptr, length: i32)    {        impl_ShaderBinary(count, shaders, binaryformat, binary, length)                          }
	GetShaderPrecisionFormat  :: proc "c" (shadertype: u32, precisiontype: u32, range: ^i32, precision: ^i32)            {        impl_GetShaderPrecisionFormat(shadertype, precisiontype, range, precision)             }
	DepthRangef               :: proc "c" (n: f32, f: f32)                                                               {        impl_DepthRangef(n, f)                                                                   }
	ClearDepthf               :: proc "c" (d: f32)                                                                       {        impl_ClearDepthf(d)                                                                      }
	GetProgramBinary          :: proc "c" (program: u32, bufSize: i32, length: ^i32, binaryFormat: ^u32, binary: rawptr) {        impl_GetProgramBinary(program, bufSize, length, binaryFormat, binary)                    }
	ProgramBinary             :: proc "c" (program: u32, binaryFormat: u32, binary: rawptr, length: i32)                 {        impl_ProgramBinary(program, binaryFormat, binary, length)                                }
	ProgramParameteri         :: proc "c" (program: u32, pname: u32, value: i32)                                         {        impl_ProgramParameteri(program, pname, value)                                            }
	UseProgramStages          :: proc "c" (pipeline: u32, stages: u32, program: u32)                                     {        impl_UseProgramStages(pipeline, stages, program)                                         }
	ActiveShaderProgram       :: proc "c" (pipeline: u32, program: u32)                                                  {        impl_ActiveShaderProgram(pipeline, program)                                              }
	CreateShaderProgramv      :: proc "c" (type: u32, count: i32, strings: [^]cstring) -> u32                            { ret := impl_CreateShaderProgramv(type, count, strings);                             return ret }
	BindProgramPipeline       :: proc "c" (pipeline: u32)                                                                {        impl_BindProgramPipeline(pipeline)                                                       }
	DeleteProgramPipelines    :: proc "c" (n: i32, pipelines: [^]u32)                                                    {        impl_DeleteProgramPipelines(n, pipelines)                                                }
	GenProgramPipelines       :: proc "c" (n: i32, pipelines: [^]u32)                                                    {        impl_GenProgramPipelines(n, pipelines)                                                   }
	IsProgramPipeline         :: proc "c" (pipeline: u32) -> bool                                                        { ret := impl_IsProgramPipeline(pipeline);                                             return ret }
	GetProgramPipelineiv      :: proc "c" (pipeline: u32, pname: u32, params: [^]i32)                                    {        impl_GetProgramPipelineiv(pipeline, pname, params)                                       }
	ProgramUniform1i          :: proc "c" (program: u32, location: i32, v0: i32)                                         {        impl_ProgramUniform1i(program, location, v0)                                             }
	ProgramUniform1iv         :: proc "c" (program: u32, location: i32, count: i32, value: [^]i32)                      {        impl_ProgramUniform1iv(program, location, count, value)                                  }
	ProgramUniform1f          :: proc "c" (program: u32, location: i32, v0: f32)                                         {        impl_ProgramUniform1f(program, location, v0)                                             }
	ProgramUniform1fv         :: proc "c" (program: u32, location: i32, count: i32, value: [^]f32)                      {        impl_ProgramUniform1fv(program, location, count, value)                                  }
	ProgramUniform1d          :: proc "c" (program: u32, location: i32, v0: f64)                                         {        impl_ProgramUniform1d(program, location, v0)                                             }
	ProgramUniform1dv         :: proc "c" (program: u32, location: i32, count: i32, value: [^]f64)                      {        impl_ProgramUniform1dv(program, location, count, value)                                  }
	ProgramUniform1ui         :: proc "c" (program: u32, location: i32, v0: u32)                                         {        impl_ProgramUniform1ui(program, location, v0)                                            }
	ProgramUniform1uiv        :: proc "c" (program: u32, location: i32, count: i32, value: [^]u32)                      {        impl_ProgramUniform1uiv(program, location, count, value)                                 }
	ProgramUniform2i          :: proc "c" (program: u32, location: i32, v0: i32, v1: i32)                                {        impl_ProgramUniform2i(program, location, v0, v1)                                         }
	ProgramUniform2iv         :: proc "c" (program: u32, location: i32, count: i32, value: [^]i32)                       {        impl_ProgramUniform2iv(program, location, count, value)                                  }
	ProgramUniform2f          :: proc "c" (program: u32, location: i32, v0: f32, v1: f32)                                {        impl_ProgramUniform2f(program, location, v0, v1)                                         }
	ProgramUniform2fv         :: proc "c" (program: u32, location: i32, count: i32, value: [^]f32)                       {        impl_ProgramUniform2fv(program, location, count, value)                                  }
	ProgramUniform2d          :: proc "c" (program: u32, location: i32, v0: f64, v1: f64)                                {        impl_ProgramUniform2d(program, location, v0, v1)                                         }
	ProgramUniform2dv         :: proc "c" (program: u32, location: i32, count: i32, value: [^]f64)                       {        impl_ProgramUniform2dv(program, location, count, value)                                  }
	ProgramUniform2ui         :: proc "c" (program: u32, location: i32, v0: u32, v1: u32)                                {        impl_ProgramUniform2ui(program, location, v0, v1)                                        }
	ProgramUniform2uiv        :: proc "c" (program: u32, location: i32, count: i32, value: [^]u32)                       {        impl_ProgramUniform2uiv(program, location, count, value)                                 }
	ProgramUniform3i          :: proc "c" (program: u32, location: i32, v0: i32, v1: i32, v2: i32)                       {        impl_ProgramUniform3i(program, location, v0, v1, v2)                                     }
	ProgramUniform3iv         :: proc "c" (program: u32, location: i32, count: i32, value: [^]i32)                       {        impl_ProgramUniform3iv(program, location, count, value)                                  }
	ProgramUniform3f          :: proc "c" (program: u32, location: i32, v0: f32, v1: f32, v2: f32)                       {        impl_ProgramUniform3f(program, location, v0, v1, v2)                                     }
	ProgramUniform3fv         :: proc "c" (program: u32, location: i32, count: i32, value: [^]f32)                       {        impl_ProgramUniform3fv(program, location, count, value)                                  }
	ProgramUniform3d          :: proc "c" (program: u32, location: i32, v0: f64, v1: f64, v2: f64)                       {        impl_ProgramUniform3d(program, location, v0, v1, v2)                                     }
	ProgramUniform3dv         :: proc "c" (program: u32, location: i32, count: i32, value: [^]f64)                       {        impl_ProgramUniform3dv(program, location, count, value)                                  }
	ProgramUniform3ui         :: proc "c" (program: u32, location: i32, v0: u32, v1: u32, v2: u32)                       {        impl_ProgramUniform3ui(program, location, v0, v1, v2)                                    }
	ProgramUniform3uiv        :: proc "c" (program: u32, location: i32, count: i32, value: [^]u32)                       {        impl_ProgramUniform3uiv(program, location, count, value)                                 }
	ProgramUniform4i          :: proc "c" (program: u32, location: i32, v0: i32, v1: i32, v2: i32, v3: i32)              {        impl_ProgramUniform4i(program, location, v0, v1, v2, v3)                                 }
	ProgramUniform4iv         :: proc "c" (program: u32, location: i32, count: i32, value: [^]i32)                       {        impl_ProgramUniform4iv(program, location, count, value)                                  }
	ProgramUniform4f          :: proc "c" (program: u32, location: i32, v0: f32, v1: f32, v2: f32, v3: f32)              {        impl_ProgramUniform4f(program, location, v0, v1, v2, v3)                                 }
	ProgramUniform4fv         :: proc "c" (program: u32, location: i32, count: i32, value: [^]f32)                       {        impl_ProgramUniform4fv(program, location, count, value)                                  }
	ProgramUniform4d          :: proc "c" (program: u32, location: i32, v0: f64, v1: f64, v2: f64, v3: f64)              {        impl_ProgramUniform4d(program, location, v0, v1, v2, v3)                                 }
	ProgramUniform4dv         :: proc "c" (program: u32, location: i32, count: i32, value: [^]f64)                       {        impl_ProgramUniform4dv(program, location, count, value)                                  }
	ProgramUniform4ui         :: proc "c" (program: u32, location: i32, v0: u32, v1: u32, v2: u32, v3: u32)              {        impl_ProgramUniform4ui(program, location, v0, v1, v2, v3)                                }
	ProgramUniform4uiv        :: proc "c" (program: u32, location: i32, count: i32, value: [^]u32)                       {        impl_ProgramUniform4uiv(program, location, count, value)                                 }
	ProgramUniformMatrix2fv   :: proc "c" (program: u32, location: i32, count: i32, transpose: bool, value: [^]f32)  {        impl_ProgramUniformMatrix2fv(program, location, count, transpose, value)                 }
	ProgramUniformMatrix3fv   :: proc "c" (program: u32, location: i32, count: i32, transpose: bool, value: [^]f32)  {        impl_ProgramUniformMatrix3fv(program, location, count, transpose, value)                 }
	ProgramUniformMatrix4fv   :: proc "c" (program: u32, location: i32, count: i32, transpose: bool, value: [^]f32)  {        impl_ProgramUniformMatrix4fv(program, location, count, transpose, value)                 }
	ProgramUniformMatrix2dv   :: proc "c" (program: u32, location: i32, count: i32, transpose: bool, value: [^]f64)  {        impl_ProgramUniformMatrix2dv(program, location, count, transpose, value)                 }
	ProgramUniformMatrix3dv   :: proc "c" (program: u32, location: i32, count: i32, transpose: bool, value: [^]f64)  {        impl_ProgramUniformMatrix3dv(program, location, count, transpose, value)                 }
	ProgramUniformMatrix4dv   :: proc "c" (program: u32, location: i32, count: i32, transpose: bool, value: [^]f64)  {        impl_ProgramUniformMatrix4dv(program, location, count, transpose, value)                 }
	ProgramUniformMatrix2x3fv :: proc "c" (program: u32, location: i32, count: i32, transpose: bool, value: [^]f32)  {        impl_ProgramUniformMatrix2x3fv(program, location, count, transpose, value)               }
	ProgramUniformMatrix3x2fv :: proc "c" (program: u32, location: i32, count: i32, transpose: bool, value: [^]f32)  {        impl_ProgramUniformMatrix3x2fv(program, location, count, transpose, value)               }
	ProgramUniformMatrix2x4fv :: proc "c" (program: u32, location: i32, count: i32, transpose: bool, value: [^]f32)  {        impl_ProgramUniformMatrix2x4fv(program, location, count, transpose, value)               }
	ProgramUniformMatrix4x2fv :: proc "c" (program: u32, location: i32, count: i32, transpose: bool, value: [^]f32)  {        impl_ProgramUniformMatrix4x2fv(program, location, count, transpose, value)               }
	ProgramUniformMatrix3x4fv :: proc "c" (program: u32, location: i32, count: i32, transpose: bool, value: [^]f32)  {        impl_ProgramUniformMatrix3x4fv(program, location, count, transpose, value)               }
	ProgramUniformMatrix4x3fv :: proc "c" (program: u32, location: i32, count: i32, transpose: bool, value: [^]f32)  {        impl_ProgramUniformMatrix4x3fv(program, location, count, transpose, value)               }
	ProgramUniformMatrix2x3dv :: proc "c" (program: u32, location: i32, count: i32, transpose: bool, value: [^]f64)  {        impl_ProgramUniformMatrix2x3dv(program, location, count, transpose, value)               }
	ProgramUniformMatrix3x2dv :: proc "c" (program: u32, location: i32, count: i32, transpose: bool, value: [^]f64)  {        impl_ProgramUniformMatrix3x2dv(program, location, count, transpose, value)               }
	ProgramUniformMatrix2x4dv :: proc "c" (program: u32, location: i32, count: i32, transpose: bool, value: [^]f64)  {        impl_ProgramUniformMatrix2x4dv(program, location, count, transpose, value)               }
	ProgramUniformMatrix4x2dv :: proc "c" (program: u32, location: i32, count: i32, transpose: bool, value: [^]f64)  {        impl_ProgramUniformMatrix4x2dv(program, location, count, transpose, value)               }
	ProgramUniformMatrix3x4dv :: proc "c" (program: u32, location: i32, count: i32, transpose: bool, value: [^]f64)  {        impl_ProgramUniformMatrix3x4dv(program, location, count, transpose, value)               }
	ProgramUniformMatrix4x3dv :: proc "c" (program: u32, location: i32, count: i32, transpose: bool, value: [^]f64)  {        impl_ProgramUniformMatrix4x3dv(program, location, count, transpose, value)               }
	ValidateProgramPipeline   :: proc "c" (pipeline: u32)                                                                {        impl_ValidateProgramPipeline(pipeline)                                                   }
	GetProgramPipelineInfoLog :: proc "c" (pipeline: u32, bufSize: i32, length: ^i32, infoLog: [^]u8)                    {        impl_GetProgramPipelineInfoLog(pipeline, bufSize, length, infoLog)                       }
	VertexAttribL1d           :: proc "c" (index: u32, x: f64)                                                           {        impl_VertexAttribL1d(index, x)                                                           }
	VertexAttribL2d           :: proc "c" (index: u32, x: f64, y: f64)                                                   {        impl_VertexAttribL2d(index, x, y)                                                        }
	VertexAttribL3d           :: proc "c" (index: u32, x: f64, y: f64, z: f64)                                           {        impl_VertexAttribL3d(index, x, y, z)                                                     }
	VertexAttribL4d           :: proc "c" (index: u32, x: f64, y: f64, z: f64, w: f64)                                   {        impl_VertexAttribL4d(index, x, y, z, w)                                                  }
	VertexAttribL1dv          :: proc "c" (index: u32, v: ^f64)                                                       {        impl_VertexAttribL1dv(index, v)                                                          }
	VertexAttribL2dv          :: proc "c" (index: u32, v: ^[2]f64)                                                       {        impl_VertexAttribL2dv(index, v)                                                          }
	VertexAttribL3dv          :: proc "c" (index: u32, v: ^[3]f64)                                                       {        impl_VertexAttribL3dv(index, v)                                                          }
	VertexAttribL4dv          :: proc "c" (index: u32, v: ^[4]f64)                                                       {        impl_VertexAttribL4dv(index, v)                                                          }
	VertexAttribLPointer      :: proc "c" (index: u32, size: i32, type: u32, stride: i32, pointer: uintptr)               {        impl_VertexAttribLPointer(index, size, type, stride, pointer)                           }
	GetVertexAttribLdv        :: proc "c" (index: u32, pname: u32, params: [^]f64)                                       {        impl_GetVertexAttribLdv(index, pname, params)                                            }
	ViewportArrayv            :: proc "c" (first: u32, count: i32, v: [^]f32)                                            {        impl_ViewportArrayv(first, count, v)                                                     }
	ViewportIndexedf          :: proc "c" (index: u32, x: f32, y: f32, w: f32, h: f32)                                   {        impl_ViewportIndexedf(index, x, y, w, h)                                                 }
	ViewportIndexedfv         :: proc "c" (index: u32, v: ^[4]f32)                                                          {        impl_ViewportIndexedfv(index, v)                                                         }
	ScissorArrayv             :: proc "c" (first: u32, count: i32, v: [^]i32)                                            {        impl_ScissorArrayv(first, count, v)                                                      }
	ScissorIndexed            :: proc "c" (index: u32, left: i32, bottom: i32, width: i32, height: i32)                  {        impl_ScissorIndexed(index, left, bottom, width, height)                                  }
	ScissorIndexedv           :: proc "c" (index: u32, v: ^[4]i32)                                                          {        impl_ScissorIndexedv(index, v)                                                           }
	DepthRangeArrayv          :: proc "c" (first: u32, count: i32, v: [^]f64)                                            {        impl_DepthRangeArrayv(first, count, v)                                                   }
	DepthRangeIndexed         :: proc "c" (index: u32, n: f64, f: f64)                                                   {        impl_DepthRangeIndexed(index, n, f)                                                      }
	GetFloati_v               :: proc "c" (target: u32, index: u32, data: ^f32)                                          {        impl_GetFloati_v(target, index, data)                                                    }
	GetDoublei_v              :: proc "c" (target: u32, index: u32, data: ^f64)                                          {        impl_GetDoublei_v(target, index, data)                                                   }

	// VERSION_4_2
	DrawArraysInstancedBaseInstance             :: proc "c" (mode: u32, first: i32, count: i32, instancecount: i32, baseinstance: u32)                                   { impl_DrawArraysInstancedBaseInstance(mode, first, count, instancecount, baseinstance)                                  }
	DrawElementsInstancedBaseInstance           :: proc "c" (mode: u32, count: i32, type: u32, indices: rawptr, instancecount: i32, baseinstance: u32)                   { impl_DrawElementsInstancedBaseInstance(mode, count, type, indices, instancecount, baseinstance)                       }
	DrawElementsInstancedBaseVertexBaseInstance :: proc "c" (mode: u32, count: i32, type: u32, indices: rawptr, instancecount: i32, basevertex: i32, baseinstance: u32)  { impl_DrawElementsInstancedBaseVertexBaseInstance(mode, count, type, indices, instancecount, basevertex, baseinstance) }
	GetInternalformativ                         :: proc "c" (target: u32, internalformat: u32, pname: u32, bufSize: i32, params: [^]i32)                                 { impl_GetInternalformativ(target, internalformat, pname, bufSize, params)                                               }
	GetActiveAtomicCounterBufferiv              :: proc "c" (program: u32, bufferIndex: u32, pname: u32, params: [^]i32)                                                 { impl_GetActiveAtomicCounterBufferiv(program, bufferIndex, pname, params)                                               }
	BindImageTexture                            :: proc "c" (unit: u32, texture: u32, level: i32, layered: bool, layer: i32, access: u32, format: u32)                     { impl_BindImageTexture(unit, texture, level, layered, layer, access, format)                                            }
	MemoryBarrier                               :: proc "c" (barriers: u32)                                                                                              { impl_MemoryBarrier(barriers)                                                                                           }
	TexStorage1D                                :: proc "c" (target: u32, levels: i32, internalformat: u32, width: i32)                                                  { impl_TexStorage1D(target, levels, internalformat, width)                                                               }
	TexStorage2D                                :: proc "c" (target: u32, levels: i32, internalformat: u32, width: i32, height: i32)                                     { impl_TexStorage2D(target, levels, internalformat, width, height)                                                       }
	TexStorage3D                                :: proc "c" (target: u32, levels: i32, internalformat: u32, width: i32, height: i32, depth: i32)                         { impl_TexStorage3D(target, levels, internalformat, width, height, depth)                                                }
	DrawTransformFeedbackInstanced              :: proc "c" (mode: u32, id: u32, instancecount: i32)                                                                     { impl_DrawTransformFeedbackInstanced(mode, id, instancecount)                                                           }
	DrawTransformFeedbackStreamInstanced        :: proc "c" (mode: u32, id: u32, stream: u32, instancecount: i32)                                                        { impl_DrawTransformFeedbackStreamInstanced(mode, id, stream, instancecount)                                             }

	// VERSION_4_3
	ClearBufferData                 :: proc "c" (target: u32, internalformat: u32, format: u32, type: u32, data: rawptr)                                                                                                                                   {        impl_ClearBufferData(target, internalformat, format, type, data)                                                                                                }
	ClearBufferSubData              :: proc "c" (target: u32, internalformat: u32, offset: int, size: int, format: u32, type: u32, data: rawptr)                                                                                                           {        impl_ClearBufferSubData(target, internalformat, offset, size, format, type, data)                                                                               }
	DispatchCompute                 :: proc "c" (num_groups_x: u32, num_groups_y: u32, num_groups_z: u32)                                                                                                                                                  {        impl_DispatchCompute(num_groups_x, num_groups_y, num_groups_z)                                                                                                   }
	DispatchComputeIndirect         :: proc "c" (indirect: ^DispatchIndirectCommand)                                                                                                                                                                       {        impl_DispatchComputeIndirect(indirect)                                                                                                                           }
	CopyImageSubData                :: proc "c" (srcName: u32, srcTarget: u32, srcLevel: i32, srcX: i32, srcY: i32, srcZ: i32, dstName: u32, dstTarget: u32, dstLevel: i32, dstX: i32, dstY: i32, dstZ: i32, srcWidth: i32, srcHeight: i32, srcDepth: i32) {        impl_CopyImageSubData(srcName, srcTarget, srcLevel, srcX, srcY, srcZ, dstName, dstTarget, dstLevel, dstX, dstY, dstZ, srcWidth, srcHeight, srcDepth)             }
	FramebufferParameteri           :: proc "c" (target: u32, pname: u32, param: i32)                                                                                                                                                                      {        impl_FramebufferParameteri(target, pname, param)                                                                                                                 }
	GetFramebufferParameteriv       :: proc "c" (target: u32, pname: u32, params: [^]i32)                                                                                                                                                                  {        impl_GetFramebufferParameteriv(target, pname, params)                                                                                                            }
	GetInternalformati64v           :: proc "c" (target: u32, internalformat: u32, pname: u32, bufSize: i32, params: [^]i64)                                                                                                                               {        impl_GetInternalformati64v(target, internalformat, pname, bufSize, params)                                                                                       }
	InvalidateTexSubImage           :: proc "c" (texture: u32, level: i32, xoffset: i32, yoffset: i32, zoffset: i32, width: i32, height: i32, depth: i32)                                                                                                  {        impl_InvalidateTexSubImage(texture, level, xoffset, yoffset, zoffset, width, height, depth)                                                                      }
	InvalidateTexImage              :: proc "c" (texture: u32, level: i32)                                                                                                                                                                                 {        impl_InvalidateTexImage(texture, level)                                                                                                                          }
	InvalidateBufferSubData         :: proc "c" (buffer: u32, offset: int, length: int)                                                                                                                                                                    {        impl_InvalidateBufferSubData(buffer, offset, length)                                                                                                             }
	InvalidateBufferData            :: proc "c" (buffer: u32)                                                                                                                                                                                              {        impl_InvalidateBufferData(buffer)                                                                                                                                }
	InvalidateFramebuffer           :: proc "c" (target: u32, numAttachments: i32, attachments: [^]u32)                                                                                                                                                    {        impl_InvalidateFramebuffer(target, numAttachments, attachments)                                                                                                  }
	InvalidateSubFramebuffer        :: proc "c" (target: u32, numAttachments: i32, attachments: [^]u32, x: i32, y: i32, width: i32, height: i32)                                                                                                           {        impl_InvalidateSubFramebuffer(target, numAttachments, attachments, x, y, width, height)                                                                          }
	MultiDrawArraysIndirect         :: proc "c" (mode: u32, indirect: [^]DrawArraysIndirectCommand, drawcount: i32, stride: i32)                                                                                                                           {        impl_MultiDrawArraysIndirect(mode, indirect, drawcount, stride)                                                                                                  }
	MultiDrawElementsIndirect       :: proc "c" (mode: u32, type: u32, indirect: [^]DrawElementsIndirectCommand, drawcount: i32, stride: i32)                                                                                                              {        impl_MultiDrawElementsIndirect(mode, type, indirect, drawcount, stride)                                                                                         }
	GetProgramInterfaceiv           :: proc "c" (program: u32, programInterface: u32, pname: u32, params: [^]i32)                                                                                                                                          {        impl_GetProgramInterfaceiv(program, programInterface, pname, params)                                                                                             }
	GetProgramResourceIndex         :: proc "c" (program: u32, programInterface: u32, name: cstring) -> u32                                                                                                                                                { ret := impl_GetProgramResourceIndex(program, programInterface, name) ;                                                                                       return ret }
	GetProgramResourceName          :: proc "c" (program: u32, programInterface: u32, index: u32, bufSize: i32, length: ^i32, name: [^]u8)                                                                                                                 {        impl_GetProgramResourceName(program, programInterface, index, bufSize, length, name)                                                                             }
	GetProgramResourceiv            :: proc "c" (program: u32, programInterface: u32, index: u32, propCount: i32, props: [^]u32, bufSize: i32, length: ^i32, params: [^]i32)                                                                               {        impl_GetProgramResourceiv(program, programInterface, index, propCount, props, bufSize, length, params)                                                           }
	GetProgramResourceLocation      :: proc "c" (program: u32, programInterface: u32, name: cstring) -> i32                                                                                                                                                { ret := impl_GetProgramResourceLocation(program, programInterface, name);                                                                                     return ret }
	GetProgramResourceLocationIndex :: proc "c" (program: u32, programInterface: u32, name: cstring) -> i32                                                                                                                                                { ret := impl_GetProgramResourceLocationIndex(program, programInterface, name);                                                                                return ret }
	ShaderStorageBlockBinding       :: proc "c" (program: u32, storageBlockIndex: u32, storageBlockBinding: u32)                                                                                                                                           {        impl_ShaderStorageBlockBinding(program, storageBlockIndex, storageBlockBinding)                                                                                  }
	TexBufferRange                  :: proc "c" (target: u32, internalformat: u32, buffer: u32, offset: int, size: int)                                                                                                                                    {        impl_TexBufferRange(target, internalformat, buffer, offset, size)                                                                                                }
	TexStorage2DMultisample         :: proc "c" (target: u32, samples: i32, internalformat: u32, width: i32, height: i32, fixedsamplelocations: bool)                                                                                                      {        impl_TexStorage2DMultisample(target, samples, internalformat, width, height, fixedsamplelocations)                                                               }
	TexStorage3DMultisample         :: proc "c" (target: u32, samples: i32, internalformat: u32, width: i32, height: i32, depth: i32, fixedsamplelocations: bool)                                                                                          {        impl_TexStorage3DMultisample(target, samples, internalformat, width, height, depth, fixedsamplelocations)                                                        }
	TextureView                     :: proc "c" (texture: u32, target: u32, origtexture: u32, internalformat: u32, minlevel: u32, numlevels: u32, minlayer: u32, numlayers: u32)                                                                           {        impl_TextureView(texture, target, origtexture, internalformat, minlevel, numlevels, minlayer, numlayers)                                                         }
	BindVertexBuffer                :: proc "c" (bindingindex: u32, buffer: u32, offset: int, stride: i32)                                                                                                                                                 {        impl_BindVertexBuffer(bindingindex, buffer, offset, stride)                                                                                                      }
	VertexAttribFormat              :: proc "c" (attribindex: u32, size: i32, type: u32, normalized: bool, relativeoffset: u32)                                                                                                                            {        impl_VertexAttribFormat(attribindex, size, type, normalized, relativeoffset)                                                                                    }
	VertexAttribIFormat             :: proc "c" (attribindex: u32, size: i32, type: u32, relativeoffset: u32)                                                                                                                                              {        impl_VertexAttribIFormat(attribindex, size, type, relativeoffset)                                                                                               }
	VertexAttribLFormat             :: proc "c" (attribindex: u32, size: i32, type: u32, relativeoffset: u32)                                                                                                                                              {        impl_VertexAttribLFormat(attribindex, size, type, relativeoffset)                                                                                               }
	VertexAttribBinding             :: proc "c" (attribindex: u32, bindingindex: u32)                                                                                                                                                                      {        impl_VertexAttribBinding(attribindex, bindingindex)                                                                                                              }
	VertexBindingDivisor            :: proc "c" (bindingindex: u32, divisor: u32)                                                                                                                                                                          {        impl_VertexBindingDivisor(bindingindex, divisor)                                                                                                                 }
	DebugMessageControl             :: proc "c" (source: u32, type: u32, severity: u32, count: i32, ids: [^]u32, enabled: bool)                                                                                                                            {        impl_DebugMessageControl(source, type, severity, count, ids, enabled)                                                                                           }
	DebugMessageInsert              :: proc "c" (source: u32, type: u32, id: u32, severity: u32, length: i32, message: cstring)                                                                                                                                    {        impl_DebugMessageInsert(source, type, id, severity, length, message)                                                                                                }
	DebugMessageCallback            :: proc "c" (callback: debug_proc_t, userParam: rawptr)                                                                                                                                                                {        impl_DebugMessageCallback(callback, userParam)                                                                                                                   }
	GetDebugMessageLog              :: proc "c" (count: u32, bufSize: i32, sources: [^]u32, types: [^]u32, ids: [^]u32, severities: [^]u32, lengths: [^]i32, messageLog: [^]u8) -> u32                                                                     { ret := impl_GetDebugMessageLog(count, bufSize, sources, types, ids, severities, lengths, messageLog);                                                        return ret }
	PushDebugGroup                  :: proc "c" (source: u32, id: u32, length: i32, message: cstring)                                                                                                                                                      {        impl_PushDebugGroup(source, id, length, message)                                                                                                                 }
	PopDebugGroup                   :: proc "c" ()                                                                                                                                                                                                         {        impl_PopDebugGroup()                                                                                                                                             }
	ObjectLabel                     :: proc "c" (identifier: u32, name: u32, length: i32, label: cstring)                                                                                                                                                    {        impl_ObjectLabel(identifier, name, length, label)                                                                                                                }
	GetObjectLabel                  :: proc "c" (identifier: u32, name: u32, bufSize: i32, length: ^i32, label: [^]u8)                                                                                                                                     {        impl_GetObjectLabel(identifier, name, bufSize, length, label)                                                                                                    }
	ObjectPtrLabel                  :: proc "c" (ptr: rawptr, length: i32, label: cstring)                                                                                                                                                                   {        impl_ObjectPtrLabel(ptr, length, label)                                                                                                                          }
	GetObjectPtrLabel               :: proc "c" (ptr: rawptr, bufSize: i32, length: ^i32, label: [^]u8)                                                                                                                                                    {        impl_GetObjectPtrLabel(ptr, bufSize, length, label)                                                                                                              }

	// VERSION_4_4
	BufferStorage     :: proc "c" (target: u32, size: int, data: rawptr, flags: u32)                                                                                              { impl_BufferStorage(target, size, data, flags)                                                              }
	ClearTexImage     :: proc "c" (texture: u32, level: i32, format: u32, type: u32, data: rawptr)                                                                                { impl_ClearTexImage(texture, level, format, type, data)                                                     }
	ClearTexSubImage  :: proc "c" (texture: u32, level: i32, xoffset: i32, yoffset: i32, zoffset: i32, width: i32, height: i32, depth: i32, format: u32, type: u32, data: rawptr) { impl_ClearTexSubImage(texture, level, xoffset, yoffset, zoffset, width, height, depth, format, type, data) }
	BindBuffersBase   :: proc "c" (target: u32, first: u32, count: i32, buffers: [^]u32)                                                                                          { impl_BindBuffersBase(target, first, count, buffers)                                                        }
	BindBuffersRange  :: proc "c" (target: u32, first: u32, count: i32, buffers: [^]u32, offsets: [^]uintptr, sizes: [^]int)                                                      { impl_BindBuffersRange(target, first, count, buffers, offsets, sizes)                                       }
	BindTextures      :: proc "c" (first: u32, count: i32, textures: [^]u32)                                                                                                      { impl_BindTextures(first, count, textures)                                                                  }
	BindSamplers      :: proc "c" (first: u32, count: i32, samplers: [^]u32)                                                                                                      { impl_BindSamplers(first, count, samplers)                                                                  }
	BindImageTextures :: proc "c" (first: u32, count: i32, textures: [^]u32)                                                                                                      { impl_BindImageTextures(first, count, textures)                                                             }
	BindVertexBuffers :: proc "c" (first: u32, count: i32, buffers: [^]u32, offsets: [^]uintptr, strides: [^]i32)                                                                 { impl_BindVertexBuffers(first, count, buffers, offsets, strides)                                            }

	// VERSION_4_5
	ClipControl                              :: proc "c" (origin: u32, depth: u32)                                                                                                                                            {        impl_ClipControl(origin, depth)                                                                                                               }
	CreateTransformFeedbacks                 :: proc "c" (n: i32, ids: [^]u32)                                                                                                                                                {        impl_CreateTransformFeedbacks(n, ids)                                                                                                         }
	TransformFeedbackBufferBase              :: proc "c" (xfb: u32, index: u32, buffer: u32)                                                                                                                                  {        impl_TransformFeedbackBufferBase(xfb, index, buffer)                                                                                          }
	TransformFeedbackBufferRange             :: proc "c" (xfb: u32, index: u32, buffer: u32, offset: int, size: int)                                                                                                          {        impl_TransformFeedbackBufferRange(xfb, index, buffer, offset, size)                                                                           }
	GetTransformFeedbackiv                   :: proc "c" (xfb: u32, pname: u32, param: ^i32)                                                                                                                                  {        impl_GetTransformFeedbackiv(xfb, pname, param)                                                                                                }
	GetTransformFeedbacki_v                  :: proc "c" (xfb: u32, pname: u32, index: u32, param: ^i32)                                                                                                                      {        impl_GetTransformFeedbacki_v(xfb, pname, index, param)                                                                                        }
	GetTransformFeedbacki64_v                :: proc "c" (xfb: u32, pname: u32, index: u32, param: ^i64)                                                                                                                      {        impl_GetTransformFeedbacki64_v(xfb, pname, index, param)                                                                                      }
	CreateBuffers                            :: proc "c" (n: i32, buffers: [^]u32)                                                                                                                                            {        impl_CreateBuffers(n, buffers)                                                                                                                }
	NamedBufferStorage                       :: proc "c" (buffer: u32, size: int, data: rawptr, flags: u32)                                                                                                                   {        impl_NamedBufferStorage(buffer, size, data, flags)                                                                                            }
	NamedBufferData                          :: proc "c" (buffer: u32, size: int, data: rawptr, usage: u32)                                                                                                                   {        impl_NamedBufferData(buffer, size, data, usage)                                                                                               }
	NamedBufferSubData                       :: proc "c" (buffer: u32, offset: int, size: int, data: rawptr)                                                                                                                  {        impl_NamedBufferSubData(buffer, offset, size, data)                                                                                           }
	CopyNamedBufferSubData                   :: proc "c" (readBuffer: u32, writeBuffer: u32, readOffset: int, writeOffset: int, size: int)                                                                                    {        impl_CopyNamedBufferSubData(readBuffer, writeBuffer, readOffset, writeOffset, size)                                                           }
	ClearNamedBufferData                     :: proc "c" (buffer: u32, internalformat: u32, format: u32, type: u32, data: rawptr)                                                                                             {        impl_ClearNamedBufferData(buffer, internalformat, format, type, data)                                                                        }
	ClearNamedBufferSubData                  :: proc "c" (buffer: u32, internalformat: u32, offset: int, size: int, format: u32, type: u32, data: rawptr)                                                                     {        impl_ClearNamedBufferSubData(buffer, internalformat, offset, size, format, type, data)                                                       }
	MapNamedBuffer                           :: proc "c" (buffer: u32, access: u32) -> rawptr                                                                                                                                 { ret := impl_MapNamedBuffer(buffer, access);                                                                                               return ret }
	MapNamedBufferRange                      :: proc "c" (buffer: u32, offset: int, length: int, access: u32) -> rawptr                                                                                                       { ret := impl_MapNamedBufferRange(buffer, offset, length, access);                                                                          return ret }
	UnmapNamedBuffer                         :: proc "c" (buffer: u32) -> bool                                                                                                                                                { ret := impl_UnmapNamedBuffer(buffer);                                                                                                     return ret }
	FlushMappedNamedBufferRange              :: proc "c" (buffer: u32, offset: int, length: int)                                                                                                                              {        impl_FlushMappedNamedBufferRange(buffer, offset, length)                                                                                      }
	GetNamedBufferParameteriv                :: proc "c" (buffer: u32, pname: u32, params: [^]i32)                                                                                                                            {        impl_GetNamedBufferParameteriv(buffer, pname, params)                                                                                         }
	GetNamedBufferParameteri64v              :: proc "c" (buffer: u32, pname: u32, params: [^]i64)                                                                                                                            {        impl_GetNamedBufferParameteri64v(buffer, pname, params)                                                                                       }
	GetNamedBufferPointerv                   :: proc "c" (buffer: u32, pname: u32, params: [^]rawptr)                                                                                                                         {        impl_GetNamedBufferPointerv(buffer, pname, params)                                                                                            }
	GetNamedBufferSubData                    :: proc "c" (buffer: u32, offset: int, size: int, data: rawptr)                                                                                                                  {        impl_GetNamedBufferSubData(buffer, offset, size, data)                                                                                        }
	CreateFramebuffers                       :: proc "c" (n: i32, framebuffers: [^]u32)                                                                                                                                       {        impl_CreateFramebuffers(n, framebuffers)                                                                                                      }
	NamedFramebufferRenderbuffer             :: proc "c" (framebuffer: u32, attachment: u32, renderbuffertarget: u32, renderbuffer: u32)                                                                                      {        impl_NamedFramebufferRenderbuffer(framebuffer, attachment, renderbuffertarget, renderbuffer)                                                  }
	NamedFramebufferParameteri               :: proc "c" (framebuffer: u32, pname: u32, param: i32)                                                                                                                           {        impl_NamedFramebufferParameteri(framebuffer, pname, param)                                                                                    }
	NamedFramebufferTexture                  :: proc "c" (framebuffer: u32, attachment: u32, texture: u32, level: i32)                                                                                                        {        impl_NamedFramebufferTexture(framebuffer, attachment, texture, level)                                                                         }
	NamedFramebufferTextureLayer             :: proc "c" (framebuffer: u32, attachment: u32, texture: u32, level: i32, layer: i32)                                                                                            {        impl_NamedFramebufferTextureLayer(framebuffer, attachment, texture, level, layer)                                                             }
	NamedFramebufferDrawBuffer               :: proc "c" (framebuffer: u32, buf: u32)                                                                                                                                         {        impl_NamedFramebufferDrawBuffer(framebuffer, buf)                                                                                             }
	NamedFramebufferDrawBuffers              :: proc "c" (framebuffer: u32, n: i32, bufs: [^]u32)                                                                                                                             {        impl_NamedFramebufferDrawBuffers(framebuffer, n, bufs)                                                                                        }
	NamedFramebufferReadBuffer               :: proc "c" (framebuffer: u32, src: u32)                                                                                                                                         {        impl_NamedFramebufferReadBuffer(framebuffer, src)                                                                                             }
	InvalidateNamedFramebufferData           :: proc "c" (framebuffer: u32, numAttachments: i32, attachments: [^]u32)                                                                                                           {        impl_InvalidateNamedFramebufferData(framebuffer, numAttachments, attachments)                                                                 }
	InvalidateNamedFramebufferSubData        :: proc "c" (framebuffer: u32, numAttachments: i32, attachments: [^]u32, x: i32, y: i32, width: i32, height: i32)                                                                  {        impl_InvalidateNamedFramebufferSubData(framebuffer, numAttachments, attachments, x, y, width, height)                                         }
	ClearNamedFramebufferiv                  :: proc "c" (framebuffer: u32, buffer: u32, drawbuffer: i32, value: ^i32)                                                                                                        {        impl_ClearNamedFramebufferiv(framebuffer, buffer, drawbuffer, value)                                                                          }
	ClearNamedFramebufferuiv                 :: proc "c" (framebuffer: u32, buffer: u32, drawbuffer: i32, value: ^u32)                                                                                                        {        impl_ClearNamedFramebufferuiv(framebuffer, buffer, drawbuffer, value)                                                                         }
	ClearNamedFramebufferfv                  :: proc "c" (framebuffer: u32, buffer: u32, drawbuffer: i32, value: ^f32)                                                                                                        {        impl_ClearNamedFramebufferfv(framebuffer, buffer, drawbuffer, value)                                                                          }
	ClearNamedFramebufferfi                  :: proc "c" (framebuffer: u32, buffer: u32, drawbuffer: i32, depth: f32, stencil: i32)                                                                                           {        impl_ClearNamedFramebufferfi(framebuffer, buffer, drawbuffer, depth, stencil)                                                                 }
	BlitNamedFramebuffer                     :: proc "c" (readFramebuffer: u32, drawFramebuffer: u32, srcX0: i32, srcY0: i32, srcX1: i32, srcY1: i32, dstX0: i32, dstY0: i32, dstX1: i32, dstY1: i32, mask: u32, filter: u32) {        impl_BlitNamedFramebuffer(readFramebuffer, drawFramebuffer, srcX0, srcY0, srcX1, srcY1, dstX0, dstY0, dstX1, dstY1, mask, filter)             }
	CheckNamedFramebufferStatus              :: proc "c" (framebuffer: u32, target: u32) -> u32                                                                                                                               { ret := impl_CheckNamedFramebufferStatus(framebuffer, target);                                                                             return ret }
	GetNamedFramebufferParameteriv           :: proc "c" (framebuffer: u32, pname: u32, param: ^i32)                                                                                                                          {        impl_GetNamedFramebufferParameteriv(framebuffer, pname, param)                                                                                }
	GetNamedFramebufferAttachmentParameteriv :: proc "c" (framebuffer: u32, attachment: u32, pname: u32, params: [^]i32)                                                                                                      {        impl_GetNamedFramebufferAttachmentParameteriv(framebuffer, attachment, pname, params)                                                         }
	CreateRenderbuffers                      :: proc "c" (n: i32, renderbuffers: [^]u32)                                                                                                                                      {        impl_CreateRenderbuffers(n, renderbuffers)                                                                                                    }
	NamedRenderbufferStorage                 :: proc "c" (renderbuffer: u32, internalformat: u32, width: i32, height: i32)                                                                                                    {        impl_NamedRenderbufferStorage(renderbuffer, internalformat, width, height)                                                                    }
	NamedRenderbufferStorageMultisample      :: proc "c" (renderbuffer: u32, samples: i32, internalformat: u32, width: i32, height: i32)                                                                                      {        impl_NamedRenderbufferStorageMultisample(renderbuffer, samples, internalformat, width, height)                                                }
	GetNamedRenderbufferParameteriv          :: proc "c" (renderbuffer: u32, pname: u32, params: [^]i32)                                                                                                                      {        impl_GetNamedRenderbufferParameteriv(renderbuffer, pname, params)                                                                             }
	CreateTextures                           :: proc "c" (target: u32, n: i32, textures: [^]u32)                                                                                                                              {        impl_CreateTextures(target, n, textures)                                                                                                      }
	TextureBuffer                            :: proc "c" (texture: u32, internalformat: u32, buffer: u32)                                                                                                                     {        impl_TextureBuffer(texture, internalformat, buffer)                                                                                           }
	TextureBufferRange                       :: proc "c" (texture: u32, internalformat: u32, buffer: u32, offset: int, size: int)                                                                                             {        impl_TextureBufferRange(texture, internalformat, buffer, offset, size)                                                                        }
	TextureStorage1D                         :: proc "c" (texture: u32, levels: i32, internalformat: u32, width: i32)                                                                                                         {        impl_TextureStorage1D(texture, levels, internalformat, width)                                                                                 }
	TextureStorage2D                         :: proc "c" (texture: u32, levels: i32, internalformat: u32, width: i32, height: i32)                                                                                            {        impl_TextureStorage2D(texture, levels, internalformat, width, height)                                                                         }
	TextureStorage3D                         :: proc "c" (texture: u32, levels: i32, internalformat: u32, width: i32, height: i32, depth: i32)                                                                                {        impl_TextureStorage3D(texture, levels, internalformat, width, height, depth)                                                                  }
	TextureStorage2DMultisample              :: proc "c" (texture: u32, samples: i32, internalformat: u32, width: i32, height: i32, fixedsamplelocations: bool)                                                               {        impl_TextureStorage2DMultisample(texture, samples, internalformat, width, height, fixedsamplelocations)                                       }
	TextureStorage3DMultisample              :: proc "c" (texture: u32, samples: i32, internalformat: u32, width: i32, height: i32, depth: i32, fixedsamplelocations: bool)                                                   {        impl_TextureStorage3DMultisample(texture, samples, internalformat, width, height, depth, fixedsamplelocations)                                }
	TextureSubImage1D                        :: proc "c" (texture: u32, level: i32, xoffset: i32, width: i32, format: u32, type: u32, pixels: rawptr)                                                                         {        impl_TextureSubImage1D(texture, level, xoffset, width, format, type, pixels)                                                                 }
	TextureSubImage2D                        :: proc "c" (texture: u32, level: i32, xoffset: i32, yoffset: i32, width: i32, height: i32, format: u32, type: u32, pixels: rawptr)                                              {        impl_TextureSubImage2D(texture, level, xoffset, yoffset, width, height, format, type, pixels)                                                }
	TextureSubImage3D                        :: proc "c" (texture: u32, level: i32, xoffset: i32, yoffset: i32, zoffset: i32, width: i32, height: i32, depth: i32, format: u32, type: u32, pixels: rawptr)                    {        impl_TextureSubImage3D(texture, level, xoffset, yoffset, zoffset, width, height, depth, format, type, pixels)                                }
	CompressedTextureSubImage1D              :: proc "c" (texture: u32, level: i32, xoffset: i32, width: i32, format: u32, imageSize: i32, data: rawptr)                                                                      {        impl_CompressedTextureSubImage1D(texture, level, xoffset, width, format, imageSize, data)                                                     }
	CompressedTextureSubImage2D              :: proc "c" (texture: u32, level: i32, xoffset: i32, yoffset: i32, width: i32, height: i32, format: u32, imageSize: i32, data: rawptr)                                           {        impl_CompressedTextureSubImage2D(texture, level, xoffset, yoffset, width, height, format, imageSize, data)                                    }
	CompressedTextureSubImage3D              :: proc "c" (texture: u32, level: i32, xoffset: i32, yoffset: i32, zoffset: i32, width: i32, height: i32, depth: i32, format: u32, imageSize: i32, data: rawptr)                 {        impl_CompressedTextureSubImage3D(texture, level, xoffset, yoffset, zoffset, width, height, depth, format, imageSize, data)                    }
	CopyTextureSubImage1D                    :: proc "c" (texture: u32, level: i32, xoffset: i32, x: i32, y: i32, width: i32)                                                                                                 {        impl_CopyTextureSubImage1D(texture, level, xoffset, x, y, width)                                                                              }
	CopyTextureSubImage2D                    :: proc "c" (texture: u32, level: i32, xoffset: i32, yoffset: i32, x: i32, y: i32, width: i32, height: i32)                                                                      {        impl_CopyTextureSubImage2D(texture, level, xoffset, yoffset, x, y, width, height)                                                             }
	CopyTextureSubImage3D                    :: proc "c" (texture: u32, level: i32, xoffset: i32, yoffset: i32, zoffset: i32, x: i32, y: i32, width: i32, height: i32)                                                        {        impl_CopyTextureSubImage3D(texture, level, xoffset, yoffset, zoffset, x, y, width, height)                                                    }
	TextureParameterf                        :: proc "c" (texture: u32, pname: u32, param: f32)                                                                                                                               {        impl_TextureParameterf(texture, pname, param)                                                                                                 }
	TextureParameterfv                       :: proc "c" (texture: u32, pname: u32, param: ^f32)                                                                                                                              {        impl_TextureParameterfv(texture, pname, param)                                                                                                }
	TextureParameteri                        :: proc "c" (texture: u32, pname: u32, param: i32)                                                                                                                               {        impl_TextureParameteri(texture, pname, param)                                                                                                 }
	TextureParameterIiv                      :: proc "c" (texture: u32, pname: u32, params: [^]i32)                                                                                                                           {        impl_TextureParameterIiv(texture, pname, params)                                                                                              }
	TextureParameterIuiv                     :: proc "c" (texture: u32, pname: u32, params: [^]u32)                                                                                                                           {        impl_TextureParameterIuiv(texture, pname, params)                                                                                             }
	TextureParameteriv                       :: proc "c" (texture: u32, pname: u32, param: ^i32)                                                                                                                              {        impl_TextureParameteriv(texture, pname, param)                                                                                                }
	GenerateTextureMipmap                    :: proc "c" (texture: u32)                                                                                                                                                       {        impl_GenerateTextureMipmap(texture)                                                                                                           }
	BindTextureUnit                          :: proc "c" (unit: u32, texture: u32)                                                                                                                                            {        impl_BindTextureUnit(unit, texture)                                                                                                           }
	GetTextureImage                          :: proc "c" (texture: u32, level: i32, format: u32, type: u32, bufSize: i32, pixels: rawptr)                                                                                     {        impl_GetTextureImage(texture, level, format, type, bufSize, pixels)                                                                          }
	GetCompressedTextureImage                :: proc "c" (texture: u32, level: i32, bufSize: i32, pixels: rawptr)                                                                                                             {        impl_GetCompressedTextureImage(texture, level, bufSize, pixels)                                                                               }
	GetTextureLevelParameterfv               :: proc "c" (texture: u32, level: i32, pname: u32, params: [^]f32)                                                                                                               {        impl_GetTextureLevelParameterfv(texture, level, pname, params)                                                                                }
	GetTextureLevelParameteriv               :: proc "c" (texture: u32, level: i32, pname: u32, params: [^]i32)                                                                                                               {        impl_GetTextureLevelParameteriv(texture, level, pname, params)                                                                                }
	GetTextureParameterfv                    :: proc "c" (texture: u32, pname: u32, params: [^]f32)                                                                                                                           {        impl_GetTextureParameterfv(texture, pname, params)                                                                                            }
	GetTextureParameterIiv                   :: proc "c" (texture: u32, pname: u32, params: [^]i32)                                                                                                                           {        impl_GetTextureParameterIiv(texture, pname, params)                                                                                           }
	GetTextureParameterIuiv                  :: proc "c" (texture: u32, pname: u32, params: [^]u32)                                                                                                                           {        impl_GetTextureParameterIuiv(texture, pname, params)                                                                                          }
	GetTextureParameteriv                    :: proc "c" (texture: u32, pname: u32, params: [^]i32)                                                                                                                           {        impl_GetTextureParameteriv(texture, pname, params)                                                                                            }
	CreateVertexArrays                       :: proc "c" (n: i32, arrays: [^]u32)                                                                                                                                             {        impl_CreateVertexArrays(n, arrays)                                                                                                            }
	DisableVertexArrayAttrib                 :: proc "c" (vaobj: u32, index: u32)                                                                                                                                             {        impl_DisableVertexArrayAttrib(vaobj, index)                                                                                                   }
	EnableVertexArrayAttrib                  :: proc "c" (vaobj: u32, index: u32)                                                                                                                                             {        impl_EnableVertexArrayAttrib(vaobj, index)                                                                                                    }
	VertexArrayElementBuffer                 :: proc "c" (vaobj: u32, buffer: u32)                                                                                                                                            {        impl_VertexArrayElementBuffer(vaobj, buffer)                                                                                                  }
	VertexArrayVertexBuffer                  :: proc "c" (vaobj: u32, bindingindex: u32, buffer: u32, offset: int, stride: i32)                                                                                               {        impl_VertexArrayVertexBuffer(vaobj, bindingindex, buffer, offset, stride)                                                                     }
	VertexArrayVertexBuffers                 :: proc "c" (vaobj: u32, first: u32, count: i32, buffers: [^]u32, offsets: [^]uintptr, strides: [^]i32)                                                                          {        impl_VertexArrayVertexBuffers(vaobj, first, count, buffers, offsets, strides)                                                                 }
	VertexArrayAttribBinding                 :: proc "c" (vaobj: u32, attribindex: u32, bindingindex: u32)                                                                                                                    {        impl_VertexArrayAttribBinding(vaobj, attribindex, bindingindex)                                                                               }
	VertexArrayAttribFormat                  :: proc "c" (vaobj: u32, attribindex: u32, size: i32, type: u32, normalized: bool, relativeoffset: u32)                                                                          {        impl_VertexArrayAttribFormat(vaobj, attribindex, size, type, normalized, relativeoffset)                                                     }
	VertexArrayAttribIFormat                 :: proc "c" (vaobj: u32, attribindex: u32, size: i32, type: u32, relativeoffset: u32)                                                                                            {        impl_VertexArrayAttribIFormat(vaobj, attribindex, size, type, relativeoffset)                                                                }
	VertexArrayAttribLFormat                 :: proc "c" (vaobj: u32, attribindex: u32, size: i32, type: u32, relativeoffset: u32)                                                                                            {        impl_VertexArrayAttribLFormat(vaobj, attribindex, size, type, relativeoffset)                                                                }
	VertexArrayBindingDivisor                :: proc "c" (vaobj: u32, bindingindex: u32, divisor: u32)                                                                                                                        {        impl_VertexArrayBindingDivisor(vaobj, bindingindex, divisor)                                                                                  }
	GetVertexArrayiv                         :: proc "c" (vaobj: u32, pname: u32, param: ^i32)                                                                                                                                {        impl_GetVertexArrayiv(vaobj, pname, param)                                                                                                    }
	GetVertexArrayIndexediv                  :: proc "c" (vaobj: u32, index: u32, pname: u32, param: ^i32)                                                                                                                    {        impl_GetVertexArrayIndexediv(vaobj, index, pname, param)                                                                                      }
	GetVertexArrayIndexed64iv                :: proc "c" (vaobj: u32, index: u32, pname: u32, param: ^i64)                                                                                                                    {        impl_GetVertexArrayIndexed64iv(vaobj, index, pname, param)                                                                                    }
	CreateSamplers                           :: proc "c" (n: i32, samplers: [^]u32)                                                                                                                                           {        impl_CreateSamplers(n, samplers)                                                                                                              }
	CreateProgramPipelines                   :: proc "c" (n: i32, pipelines: [^]u32)                                                                                                                                          {        impl_CreateProgramPipelines(n, pipelines)                                                                                                     }
	CreateQueries                            :: proc "c" (target: u32, n: i32, ids: [^]u32)                                                                                                                                   {        impl_CreateQueries(target, n, ids)                                                                                                            }
	GetQueryBufferObjecti64v                 :: proc "c" (id: u32, buffer: u32, pname: u32, offset: int)                                                                                                                      {        impl_GetQueryBufferObjecti64v(id, buffer, pname, offset)                                                                                      }
	GetQueryBufferObjectiv                   :: proc "c" (id: u32, buffer: u32, pname: u32, offset: int)                                                                                                                      {        impl_GetQueryBufferObjectiv(id, buffer, pname, offset)                                                                                        }
	GetQueryBufferObjectui64v                :: proc "c" (id: u32, buffer: u32, pname: u32, offset: int)                                                                                                                      {        impl_GetQueryBufferObjectui64v(id, buffer, pname, offset)                                                                                     }
	GetQueryBufferObjectuiv                  :: proc "c" (id: u32, buffer: u32, pname: u32, offset: int)                                                                                                                      {        impl_GetQueryBufferObjectuiv(id, buffer, pname, offset)                                                                                       }
	MemoryBarrierByRegion                    :: proc "c" (barriers: u32)                                                                                                                                                      {        impl_MemoryBarrierByRegion(barriers)                                                                                                          }
	GetTextureSubImage                       :: proc "c" (texture: u32, level: i32, xoffset: i32, yoffset: i32, zoffset: i32, width: i32, height: i32, depth: i32, format: u32, type: u32, bufSize: i32, pixels: rawptr)      {        impl_GetTextureSubImage(texture, level, xoffset, yoffset, zoffset, width, height, depth, format, type, bufSize, pixels)                      }
	GetCompressedTextureSubImage             :: proc "c" (texture: u32, level: i32, xoffset: i32, yoffset: i32, zoffset: i32, width: i32, height: i32, depth: i32, bufSize: i32, pixels: rawptr)                              {        impl_GetCompressedTextureSubImage(texture, level, xoffset, yoffset, zoffset, width, height, depth, bufSize, pixels)                           }
	GetGraphicsResetStatus                   :: proc "c" () -> u32                                                                                                                                                            { ret := impl_GetGraphicsResetStatus();                                                                                                     return ret }
	GetnCompressedTexImage                   :: proc "c" (target: u32, lod: i32, bufSize: i32, pixels: rawptr)                                                                                                                {        impl_GetnCompressedTexImage(target, lod, bufSize, pixels)                                                                                     }
	GetnTexImage                             :: proc "c" (target: u32, level: i32, format: u32, type: u32, bufSize: i32, pixels: rawptr)                                                                                      {        impl_GetnTexImage(target, level, format, type, bufSize, pixels)                                                                              }
	GetnUniformdv                            :: proc "c" (program: u32, location: i32, bufSize: i32, params: [^]f64)                                                                                                          {        impl_GetnUniformdv(program, location, bufSize, params)                                                                                        }
	GetnUniformfv                            :: proc "c" (program: u32, location: i32, bufSize: i32, params: [^]f32)                                                                                                          {        impl_GetnUniformfv(program, location, bufSize, params)                                                                                        }
	GetnUniformiv                            :: proc "c" (program: u32, location: i32, bufSize: i32, params: [^]i32)                                                                                                          {        impl_GetnUniformiv(program, location, bufSize, params)                                                                                        }
	GetnUniformuiv                           :: proc "c" (program: u32, location: i32, bufSize: i32, params: [^]u32)                                                                                                          {        impl_GetnUniformuiv(program, location, bufSize, params)                                                                                       }
	ReadnPixels                              :: proc "c" (x: i32, y: i32, width: i32, height: i32, format: u32, type: u32, bufSize: i32, data: rawptr)                                                                        {        impl_ReadnPixels(x, y, width, height, format, type, bufSize, data)                                                                           }
	GetnMapdv                                :: proc "c" (target: u32, query: u32, bufSize: i32, v: [^]f64)                                                                                                                     {        impl_GetnMapdv(target, query, bufSize, v)                                                                                                     }
	GetnMapfv                                :: proc "c" (target: u32, query: u32, bufSize: i32, v: [^]f32)                                                                                                                     {        impl_GetnMapfv(target, query, bufSize, v)                                                                                                     }
	GetnMapiv                                :: proc "c" (target: u32, query: u32, bufSize: i32, v: [^]i32)                                                                                                                     {        impl_GetnMapiv(target, query, bufSize, v)                                                                                                     }
	GetnPixelMapusv                          :: proc "c" (map_: u32, bufSize: i32, values: [^]u16)                                                                                                                            {        impl_GetnPixelMapusv(map_, bufSize, values)                                                                                                   }
	GetnPixelMapfv                           :: proc "c" (map_: u32, bufSize: i32, values: [^]f32)                                                                                                                            {        impl_GetnPixelMapfv(map_, bufSize, values)                                                                                                    }
	GetnPixelMapuiv                          :: proc "c" (map_: u32, bufSize: i32, values: [^]u32)                                                                                                                            {        impl_GetnPixelMapuiv(map_, bufSize, values)                                                                                                   }
	GetnPolygonStipple                       :: proc "c" (bufSize: i32, pattern: [^]u8)                                                                                                                                         {        impl_GetnPolygonStipple(bufSize, pattern)                                                                                                     }
	GetnColorTable                           :: proc "c" (target: u32, format: u32, type: u32, bufSize: i32, table: rawptr)                                                                                                   {        impl_GetnColorTable(target, format, type, bufSize, table)                                                                                    }
	GetnConvolutionFilter                    :: proc "c" (target: u32, format: u32, type: u32, bufSize: i32, image: rawptr)                                                                                                   {        impl_GetnConvolutionFilter(target, format, type, bufSize, image)                                                                             }
	GetnSeparableFilter                      :: proc "c" (target: u32, format: u32, type: u32, rowBufSize: i32, row: rawptr, columnBufSize: i32, column: rawptr, span: rawptr)                                                {        impl_GetnSeparableFilter(target, format, type, rowBufSize, row, columnBufSize, column, span)                                                 }
	GetnHistogram                            :: proc "c" (target: u32, reset: bool, format: u32, type: u32, bufSize: i32, values: rawptr)                                                                                     {        impl_GetnHistogram(target, reset, format, type, bufSize, values)                                                                             }
	GetnMinmax                               :: proc "c" (target: u32, reset: bool, format: u32, type: u32, bufSize: i32, values: rawptr)                                                                                     {        impl_GetnMinmax(target, reset, format, type, bufSize, values)                                                                                }
	TextureBarrier                           :: proc "c" ()                                                                                                                                                                   {        impl_TextureBarrier()                                                                                                                         }
	GetUnsignedBytevEXT                      :: proc "c" (pname: u32, data: ^byte)                                                                                                                                            {        impl_GetUnsignedBytevEXT(pname, data)                                                                                                         }
	TexPageCommitmentARB                     :: proc "c"(target: u32, level: i32, xoffset: i32, yoffset: i32, zoffset: i32, width: i32, height: i32, depth: i32, commit: bool)                                                {        impl_TexPageCommitmentARB(target, level, xoffset, yoffset, zoffset, width, height, depth, commit)                                             }

	// VERSION_4_6
	SpecializeShader               :: proc "c" (shader: u32, pEntryPoint: cstring, numSpecializationConstants: u32, pConstantIndex: ^u32, pConstantValue: ^u32) { impl_SpecializeShader(shader, pEntryPoint, numSpecializationConstants, pConstantIndex, pConstantValue) }
	MultiDrawArraysIndirectCount   :: proc "c" (mode: i32, indirect: [^]DrawArraysIndirectCommand, drawcount: i32, maxdrawcount, stride: i32)                   { impl_MultiDrawArraysIndirectCount(mode, indirect, drawcount, maxdrawcount, stride)                     }
	MultiDrawElementsIndirectCount :: proc "c" (mode: i32, type: i32, indirect: [^]DrawElementsIndirectCommand, drawcount: i32, maxdrawcount, stride: i32)      { impl_MultiDrawElementsIndirectCount(mode, type, indirect, drawcount, maxdrawcount, stride)             }
	PolygonOffsetClamp             :: proc "c" (factor, units, clamp: f32)                                                                                      { impl_PolygonOffsetClamp(factor, units, clamp)                                                          }
} else {
	import "core:runtime"
	import "core:fmt"

	debug_helper :: proc"c"(from_loc: runtime.Source_Code_Location, num_ret: int, args: ..any, loc := #caller_location) {
		context = runtime.default_context()

		Error_Enum :: enum {
			NO_ERROR = NO_ERROR,
			INVALID_VALUE = INVALID_VALUE,
			INVALID_ENUM = INVALID_ENUM,
			INVALID_OPERATION = INVALID_OPERATION,
			INVALID_FRAMEBUFFER_OPERATION = INVALID_FRAMEBUFFER_OPERATION,
			OUT_OF_MEMORY = OUT_OF_MEMORY,
			STACK_UNDERFLOW = STACK_UNDERFLOW,
			STACK_OVERFLOW = STACK_OVERFLOW,
			// TODO: What if the return enum is invalid?
		}

		// There can be multiple errors, so we're required to continuously call glGetError until there are no more errors
		for i := 0; /**/; i += 1 {
			err := cast(Error_Enum)impl_GetError()
			if err == .NO_ERROR { break }

			fmt.printf("%d: glGetError() returned GL_%v\n", i, err)

			// add function call
			fmt.printf("   call: gl%s(", loc.procedure)
			{
				// add input arguments
				for arg, i in args[num_ret:] {
				if i > 0 { fmt.printf(", ") }

				if v, ok := arg.(u32); ok { // TODO: Assumes all u32 are GLenum (they're not, GLbitfield and GLuint are also mapped to u32), fix later by better typing
					if err == .INVALID_ENUM {
						fmt.printf("INVALID_ENUM=%d", v)
					} else {
						fmt.printf("GL_%v=%d", GL_Enum(v), v)
					}
				} else {
					fmt.printf("%v", arg)
				}
				}

				// add return arguments
				if num_ret == 1 {
					fmt.printf(") -> %v \n", args[0])
				} else if num_ret > 1 {
					fmt.printf(") -> (")
					for arg, i in args[1:num_ret] {
						if i > 0 { fmt.printf(", ") }
						fmt.printf("%v", arg)
					}
					fmt.printf(")\n")
				} else {
					fmt.printf(")\n")
				}
			}

			// add location
		    fmt.printf("   in:   %s(%d:%d)\n", from_loc.file_path, from_loc.line, from_loc.column)
		}
	}

	CullFace               :: proc "c" (mode: u32, loc := #caller_location)                                                                                         {        impl_CullFace(mode);                                                                         debug_helper(loc, 0, mode)                                                                                   }
	FrontFace              :: proc "c" (mode: u32, loc := #caller_location)                                                                                         {        impl_FrontFace(mode);                                                                        debug_helper(loc, 0, mode)                                                                                   }
	Hint                   :: proc "c" (target, mode: u32, loc := #caller_location)                                                                                 {        impl_Hint(target, mode);                                                                     debug_helper(loc, 0, target, mode)                                                                           }
	LineWidth              :: proc "c" (width: f32, loc := #caller_location)                                                                                        {        impl_LineWidth(width);                                                                       debug_helper(loc, 0, width)                                                                                  }
	PointSize              :: proc "c" (size: f32, loc := #caller_location)                                                                                         {        impl_PointSize(size);                                                                        debug_helper(loc, 0, size)                                                                                   }
	PolygonMode            :: proc "c" (face, mode: u32, loc := #caller_location)                                                                                   {        impl_PolygonMode(face, mode);                                                                debug_helper(loc, 0, face, mode)                                                                             }
	Scissor                :: proc "c" (x, y, width, height: i32, loc := #caller_location)                                                                          {        impl_Scissor(x, y, width, height);                                                           debug_helper(loc, 0, x, y, width, height)                                                                    }
	TexParameterf          :: proc "c" (target, pname: u32, param: f32, loc := #caller_location)                                                                    {        impl_TexParameterf(target, pname, param);                                                    debug_helper(loc, 0, target, pname, param)                                                                   }
	TexParameterfv         :: proc "c" (target, pname: u32, params: [^]f32, loc := #caller_location)                                                                {        impl_TexParameterfv(target, pname, params);                                                  debug_helper(loc, 0, target, pname, params)                                                                  }
	TexParameteri          :: proc "c" (target, pname: u32, param: i32, loc := #caller_location)                                                                    {        impl_TexParameteri(target, pname, param);                                                    debug_helper(loc, 0, target, pname, param)                                                                   }
	TexParameteriv         :: proc "c" (target, pname: u32, params: [^]i32, loc := #caller_location)                                                                {        impl_TexParameteriv(target, pname, params);                                                  debug_helper(loc, 0, target, pname, params)                                                                  }
	TexImage1D             :: proc "c" (target: u32, level, internalformat, width, border: i32, format, type: u32, pixels: rawptr, loc := #caller_location)         {        impl_TexImage1D(target, level, internalformat, width, border, format, type, pixels);         debug_helper(loc, 0, target, level, internalformat, width, border, format, type, pixels)                     }
	TexImage2D             :: proc "c" (target: u32, level, internalformat, width, height, border: i32, format, type: u32, pixels: rawptr, loc := #caller_location) {        impl_TexImage2D(target, level, internalformat, width, height, border, format, type, pixels); debug_helper(loc, 0, target, level, internalformat, width, height, border, format, type, pixels)             }
	DrawBuffer             :: proc "c" (buf: u32, loc := #caller_location)                                                                                          {        impl_DrawBuffer(buf);                                                                        debug_helper(loc, 0, buf)                                                                                    }
	Clear                  :: proc "c" (mask: u32, loc := #caller_location)                                                                                         {        impl_Clear(mask);                                                                            debug_helper(loc, 0, mask)                                                                                   }
	ClearColor             :: proc "c" (red, green, blue, alpha: f32, loc := #caller_location)                                                                      {        impl_ClearColor(red, green, blue, alpha);                                                    debug_helper(loc, 0, red, green, blue, alpha)                                                                }
	ClearStencil           :: proc "c" (s: i32, loc := #caller_location)                                                                                            {        impl_ClearStencil(s);                                                                        debug_helper(loc, 0, s)                                                                                      }
	ClearDepth             :: proc "c" (depth: f64, loc := #caller_location)                                                                                        {        impl_ClearDepth(depth);                                                                      debug_helper(loc, 0, depth)                                                                                  }
	StencilMask            :: proc "c" (mask: u32, loc := #caller_location)                                                                                         {        impl_StencilMask(mask);                                                                      debug_helper(loc, 0, mask)                                                                                   }
	ColorMask              :: proc "c" (red, green, blue, alpha: bool, loc := #caller_location)                                                                     {        impl_ColorMask(red, green, blue, alpha);                                                     debug_helper(loc, 0, red, green, blue, alpha)                                                                }
	DepthMask              :: proc "c" (flag: bool, loc := #caller_location)                                                                                        {        impl_DepthMask(flag);                                                                        debug_helper(loc, 0, flag)                                                                                   }
	Disable                :: proc "c" (cap: u32, loc := #caller_location)                                                                                          {        impl_Disable(cap);                                                                           debug_helper(loc, 0, cap)                                                                                    }
	Enable                 :: proc "c" (cap: u32, loc := #caller_location)                                                                                          {        impl_Enable(cap);                                                                            debug_helper(loc, 0, cap)                                                                                    }
	Finish                 :: proc "c" (loc := #caller_location)                                                                                                    {        impl_Finish();                                                                               debug_helper(loc, 0)                                                                                         }
	Flush                  :: proc "c" (loc := #caller_location)                                                                                                    {        impl_Flush();                                                                                debug_helper(loc, 0)                                                                                         }
	BlendFunc              :: proc "c" (sfactor, dfactor: u32, loc := #caller_location)                                                                             {        impl_BlendFunc(sfactor, dfactor);                                                            debug_helper(loc, 0, sfactor, dfactor)                                                                       }
	LogicOp                :: proc "c" (opcode: u32, loc := #caller_location)                                                                                       {        impl_LogicOp(opcode);                                                                        debug_helper(loc, 0, opcode)                                                                                 }
	StencilFunc            :: proc "c" (func: u32, ref: i32, mask: u32, loc := #caller_location)                                                                    {        impl_StencilFunc(func, ref, mask);                                                           debug_helper(loc, 0, func, ref, mask)                                                                        }
	StencilOp              :: proc "c" (fail, zfail, zpass: u32, loc := #caller_location)                                                                           {        impl_StencilOp(fail, zfail, zpass);                                                          debug_helper(loc, 0, fail, zfail, zpass)                                                                     }
	DepthFunc              :: proc "c" (func: u32, loc := #caller_location)                                                                                         {        impl_DepthFunc(func);                                                                        debug_helper(loc, 0, func)                                                                                   }
	PixelStoref            :: proc "c" (pname: u32, param: f32, loc := #caller_location)                                                                            {        impl_PixelStoref(pname, param);                                                              debug_helper(loc, 0, pname, param)                                                                           }
	PixelStorei            :: proc "c" (pname: u32, param: i32, loc := #caller_location)                                                                            {        impl_PixelStorei(pname, param);                                                              debug_helper(loc, 0, pname, param)                                                                           }
	ReadBuffer             :: proc "c" (src: u32, loc := #caller_location)                                                                                          {        impl_ReadBuffer(src);                                                                        debug_helper(loc, 0, src)                                                                                    }
	ReadPixels             :: proc "c" (x, y, width, height: i32, format, type: u32, pixels: rawptr, loc := #caller_location)                                       {        impl_ReadPixels(x, y, width, height, format, type, pixels);                                  debug_helper(loc, 0, x, y, width, height, format, type, pixels)                                              }
	GetBooleanv            :: proc "c" (pname: u32, data: ^bool, loc := #caller_location)                                                                           {        impl_GetBooleanv(pname, data);                                                               debug_helper(loc, 0, pname, data)                                                                            }
	GetDoublev             :: proc "c" (pname: u32, data: ^f64, loc := #caller_location)                                                                            {        impl_GetDoublev(pname, data);                                                                debug_helper(loc, 0, pname, data)                                                                            }
	GetError               :: proc "c" (loc := #caller_location) -> u32                                                                                             { ret := impl_GetError();                                                                             debug_helper(loc, 1, ret);                                                                        return ret }
	GetFloatv              :: proc "c" (pname: u32, data: ^f32, loc := #caller_location)                                                                            {        impl_GetFloatv(pname, data);                                                                 debug_helper(loc, 0, pname, data)                                                                            }
	GetIntegerv            :: proc "c" (pname: u32, data: ^i32, loc := #caller_location)                                                                            {        impl_GetIntegerv(pname, data);                                                               debug_helper(loc, 0, pname, data)                                                                            }
	GetString              :: proc "c" (name: u32, loc := #caller_location) -> cstring                                                                              { ret := impl_GetString(name);                                                                        debug_helper(loc, 1, ret, name);                                                                  return ret }
	GetTexImage            :: proc "c" (target: u32,  level: i32, format, type: u32, pixels: rawptr, loc := #caller_location)                                       {        impl_GetTexImage(target,  level, format, type, pixels);                                      debug_helper(loc, 0, target,  level, format, type, pixels)                                                   }
	GetTexParameterfv      :: proc "c" (target, pname: u32, params: [^]f32, loc := #caller_location)                                                                {        impl_GetTexParameterfv(target, pname, params);                                               debug_helper(loc, 0, target, pname, params)                                                                  }
	GetTexParameteriv      :: proc "c" (target, pname: u32, params: [^]i32, loc := #caller_location)                                                                {        impl_GetTexParameteriv(target, pname, params);                                               debug_helper(loc, 0, target, pname, params)                                                                  }
	GetTexLevelParameterfv :: proc "c" (target: u32, level: i32, pname: u32, params: [^]f32, loc := #caller_location)                                               {        impl_GetTexLevelParameterfv(target, level, pname, params);                                   debug_helper(loc, 0, target, level, pname, params)                                                           }
	GetTexLevelParameteriv :: proc "c" (target: u32, level: i32, pname: u32, params: [^]i32, loc := #caller_location)                                               {        impl_GetTexLevelParameteriv(target, level, pname, params);                                   debug_helper(loc, 0, target, level, pname, params)                                                           }
	IsEnabled              :: proc "c" (cap: u32, loc := #caller_location) -> bool                                                                                  { ret := impl_IsEnabled(cap);                                                                         debug_helper(loc, 1, ret, cap);                                                                   return ret }
	DepthRange             :: proc "c" (near, far: f64, loc := #caller_location)                                                                                    {        impl_DepthRange(near, far);                                                                  debug_helper(loc, 0, near, far)                                                                              }
	Viewport               :: proc "c" (x, y, width, height: i32, loc := #caller_location)                                                                          {        impl_Viewport(x, y, width, height);                                                          debug_helper(loc, 0, x, y, width, height)                                                                    }

	// VERSION_1_1
	DrawArrays        :: proc "c" (mode: u32, first: i32, count: i32, loc := #caller_location)                                                                                    {        impl_DrawArrays(mode, first, count);                                                      debug_helper(loc, 0, mode, first, count)                                                               }
	DrawElements      :: proc "c" (mode: u32, count: i32, type: u32, indices: rawptr, loc := #caller_location)                                                                    {        impl_DrawElements(mode, count, type, indices);                                            debug_helper(loc, 0, mode, count, type, indices)                                                       }
	PolygonOffset     :: proc "c" (factor: f32, units: f32, loc := #caller_location)                                                                                              {        impl_PolygonOffset(factor, units);                                                        debug_helper(loc, 0, factor, units)                                                                    }
	CopyTexImage1D    :: proc "c" (target: u32, level: i32, internalformat: u32, x: i32, y: i32, width: i32, border: i32, loc := #caller_location)                                {        impl_CopyTexImage1D(target, level, internalformat, x, y, width, border);                  debug_helper(loc, 0, target, level, internalformat, x, y, width, border)                               }
	CopyTexImage2D    :: proc "c" (target: u32, level: i32, internalformat: u32, x: i32, y: i32, width: i32, height: i32, border: i32, loc := #caller_location)                   {        impl_CopyTexImage2D(target, level, internalformat, x, y, width, height, border);          debug_helper(loc, 0, target, level, internalformat, x, y, width, height, border)                       }
	CopyTexSubImage1D :: proc "c" (target: u32, level: i32, xoffset: i32, x: i32, y: i32, width: i32, loc := #caller_location)                                                    {        impl_CopyTexSubImage1D(target, level, xoffset, x, y, width);                              debug_helper(loc, 0, target, level, xoffset, x, y, width)                                              }
	CopyTexSubImage2D :: proc "c" (target: u32, level: i32, xoffset: i32, yoffset: i32, x: i32, y: i32, width: i32, height: i32, loc := #caller_location)                         {        impl_CopyTexSubImage2D(target, level, xoffset, yoffset, x, y, width, height);             debug_helper(loc, 0, target, level, xoffset, yoffset, x, y, width, height)                             }
	TexSubImage1D     :: proc "c" (target: u32, level: i32, xoffset: i32, width: i32, format: u32, type: u32, pixels: rawptr, loc := #caller_location)                            {        impl_TexSubImage1D(target, level, xoffset, width, format, type, pixels);                  debug_helper(loc, 0, target, level, xoffset, width, format, type, pixels)                              }
	TexSubImage2D     :: proc "c" (target: u32, level: i32, xoffset: i32, yoffset: i32, width: i32, height: i32, format: u32, type: u32, pixels: rawptr, loc := #caller_location) {        impl_TexSubImage2D(target, level, xoffset, yoffset, width, height, format, type, pixels); debug_helper(loc, 0, target, level, xoffset, yoffset, width, height, format, type, pixels)             }
	BindTexture       :: proc "c" (target: u32, texture: u32, loc := #caller_location)                                                                                            {        impl_BindTexture(target, texture);                                                        debug_helper(loc, 0, target, texture)                                                                  }
	DeleteTextures    :: proc "c" (n: i32, textures: [^]u32, loc := #caller_location)                                                                                             {        impl_DeleteTextures(n, textures);                                                         debug_helper(loc, 0, n, textures)                                                                      }
	GenTextures       :: proc "c" (n: i32, textures: [^]u32, loc := #caller_location)                                                                                             {        impl_GenTextures(n, textures);                                                            debug_helper(loc, 0, n, textures)                                                                      }
	IsTexture         :: proc "c" (texture: u32, loc := #caller_location) -> bool                                                                                                 { ret := impl_IsTexture(texture);                                                                  debug_helper(loc, 1, ret, texture);                                                         return ret }

	// VERSION_1_2
	DrawRangeElements :: proc "c" (mode, start, end: u32, count: i32, type: u32, indices: rawptr, loc := #caller_location)                                               { impl_DrawRangeElements(mode, start, end, count, type, indices);                                           debug_helper(loc, 0, mode, start, end, count, type, indices)                                               }
	TexImage3D        :: proc "c" (target: u32, level, internalformat, width, height, depth, border: i32, format, type: u32, pixels: rawptr, loc := #caller_location)    { impl_TexImage3D(target, level, internalformat, width, height, depth, border, format, type, pixels);       debug_helper(loc, 0, target, level, internalformat, width, height, depth, border, format, type, pixels)    }
	TexSubImage3D     :: proc "c" (target: u32, level, xoffset, yoffset, zoffset, width, height, depth: i32, format, type: u32, pixels: rawptr, loc := #caller_location) { impl_TexSubImage3D(target, level, xoffset, yoffset, zoffset, width, height, depth, format, type, pixels); debug_helper(loc, 0, target, level, xoffset, yoffset, zoffset, width, height, depth, format, type, pixels) }
	CopyTexSubImage3D :: proc "c" (target: u32, level, xoffset, yoffset, zoffset, x, y, width, height: i32, loc := #caller_location)                                     { impl_CopyTexSubImage3D(target, level, xoffset, yoffset, zoffset, x, y, width, height);                    debug_helper(loc, 0, target, level, xoffset, yoffset, zoffset, x, y, width, height)                        }

	// VERSION_1_3
	ActiveTexture           :: proc "c" (texture: u32, loc := #caller_location)                                                                                                                                      { impl_ActiveTexture(texture);                                                                                           debug_helper(loc, 0, texture)                                                                                 }
	SampleCoverage          :: proc "c" (value: f32, invert: bool, loc := #caller_location)                                                                                                                          { impl_SampleCoverage(value, invert);                                                                                    debug_helper(loc, 0, value, invert)                                                                           }
	CompressedTexImage3D    :: proc "c" (target: u32, level: i32, internalformat: u32, width: i32, height: i32, depth: i32, border: i32, imageSize: i32, data: rawptr, loc := #caller_location)                      { impl_CompressedTexImage3D(target, level, internalformat, width, height, depth, border, imageSize, data);               debug_helper(loc, 0, target, level, internalformat, width, height, depth, border, imageSize, data)            }
	CompressedTexImage2D    :: proc "c" (target: u32, level: i32, internalformat: u32, width: i32, height: i32, border: i32, imageSize: i32, data: rawptr, loc := #caller_location)                                  { impl_CompressedTexImage2D(target, level, internalformat, width, height, border, imageSize, data);                      debug_helper(loc, 0, target, level, internalformat, width, height, border, imageSize, data)                   }
	CompressedTexImage1D    :: proc "c" (target: u32, level: i32, internalformat: u32, width: i32, border: i32, imageSize: i32, data: rawptr, loc := #caller_location)                                               { impl_CompressedTexImage1D(target, level, internalformat, width, border, imageSize, data);                              debug_helper(loc, 0, target, level, internalformat, width, border, imageSize, data)                           }
	CompressedTexSubImage3D :: proc "c" (target: u32, level: i32, xoffset: i32, yoffset: i32, zoffset: i32, width: i32, height: i32, depth: i32, format: u32, imageSize: i32, data: rawptr, loc := #caller_location) { impl_CompressedTexSubImage3D(target, level, xoffset, yoffset, zoffset, width, height, depth, format, imageSize, data); debug_helper(loc, 0, target, level, xoffset, yoffset, zoffset, width, height, depth, format, imageSize, data) }
	CompressedTexSubImage2D :: proc "c" (target: u32, level: i32, xoffset: i32, yoffset: i32, width: i32, height: i32, format: u32, imageSize: i32, data: rawptr, loc := #caller_location)                           { impl_CompressedTexSubImage2D(target, level, xoffset, yoffset, width, height, format, imageSize, data);                 debug_helper(loc, 0, target, level, xoffset, yoffset, width, height, format, imageSize, data)                 }
	CompressedTexSubImage1D :: proc "c" (target: u32, level: i32, xoffset: i32, width: i32, format: u32, imageSize: i32, data: rawptr, loc := #caller_location)                                                      { impl_CompressedTexSubImage1D(target, level, xoffset, width, format, imageSize, data);                                  debug_helper(loc, 0, target, level, xoffset, width, format, imageSize, data)                                  }
	GetCompressedTexImage   :: proc "c" (target: u32, level: i32, img: rawptr, loc := #caller_location)                                                                                                              { impl_GetCompressedTexImage(target, level, img);                                                                        debug_helper(loc, 0, target, level, img)                                                                      }

	// VERSION_1_4
	BlendFuncSeparate :: proc "c" (sfactorRGB: u32, dfactorRGB: u32, sfactorAlpha: u32, dfactorAlpha: u32, loc := #caller_location)  { impl_BlendFuncSeparate(sfactorRGB, dfactorRGB, sfactorAlpha, dfactorAlpha); debug_helper(loc, 0, sfactorRGB, dfactorRGB, sfactorAlpha, dfactorAlpha) }
	MultiDrawArrays   :: proc "c" (mode: u32, first: [^]i32, count: [^]i32, drawcount: i32, loc := #caller_location)                 { impl_MultiDrawArrays(mode, first, count, drawcount);                        debug_helper(loc, 0, mode, first, count, drawcount)                      }
	MultiDrawElements :: proc "c" (mode: u32, count: [^]i32, type: u32, indices: [^]rawptr, drawcount: i32, loc := #caller_location) { impl_MultiDrawElements(mode, count, type, indices, drawcount);             debug_helper(loc, 0, mode, count, type, indices, drawcount)             }
	PointParameterf   :: proc "c" (pname: u32, param: f32, loc := #caller_location)                                                  { impl_PointParameterf(pname, param);                                         debug_helper(loc, 0, pname, param)                                       }
	PointParameterfv  :: proc "c" (pname: u32, params: [^]f32, loc := #caller_location)                                              { impl_PointParameterfv(pname, params);                                       debug_helper(loc, 0, pname, params)                                      }
	PointParameteri   :: proc "c" (pname: u32, param: i32, loc := #caller_location)                                                  { impl_PointParameteri(pname, param);                                         debug_helper(loc, 0, pname, param)                                       }
	PointParameteriv  :: proc "c" (pname: u32, params: [^]i32, loc := #caller_location)                                              { impl_PointParameteriv(pname, params);                                       debug_helper(loc, 0, pname, params)                                      }
	BlendColor        :: proc "c" (red: f32, green: f32, blue: f32, alpha: f32, loc := #caller_location)                             { impl_BlendColor(red, green, blue, alpha);                                   debug_helper(loc, 0, red, green, blue, alpha)                            }
	BlendEquation     :: proc "c" (mode: u32, loc := #caller_location)                                                               { impl_BlendEquation(mode);                                                   debug_helper(loc, 0, mode)                                               }

	// VERSION_1_5
	GenQueries           :: proc "c" (n: i32, ids: [^]u32, loc := #caller_location)                               {        impl_GenQueries(n, ids);                           debug_helper(loc, 0, n, ids)                                 }
	DeleteQueries        :: proc "c" (n: i32, ids: [^]u32, loc := #caller_location)                               {        impl_DeleteQueries(n, ids);                        debug_helper(loc, 0, n, ids)                                 }
	IsQuery              :: proc "c" (id: u32, loc := #caller_location) -> bool                                   { ret := impl_IsQuery(id);                                  debug_helper(loc, 1, ret, id);                    return ret }
	BeginQuery           :: proc "c" (target: u32, id: u32, loc := #caller_location)                              {        impl_BeginQuery(target, id);                       debug_helper(loc, 0, target, id)                             }
	EndQuery             :: proc "c" (target: u32, loc := #caller_location)                                       {        impl_EndQuery(target);                             debug_helper(loc, 0, target)                                 }
	GetQueryiv           :: proc "c" (target: u32, pname: u32, params: [^]i32, loc := #caller_location)           {        impl_GetQueryiv(target, pname, params);            debug_helper(loc, 0, target, pname, params)                  }
	GetQueryObjectiv     :: proc "c" (id: u32, pname: u32, params: [^]i32, loc := #caller_location)               {        impl_GetQueryObjectiv(id, pname, params);          debug_helper(loc, 0, id, pname, params)                      }
	GetQueryObjectuiv    :: proc "c" (id: u32, pname: u32, params: [^]u32, loc := #caller_location)               {        impl_GetQueryObjectuiv(id, pname, params);         debug_helper(loc, 0, id, pname, params)                      }
	BindBuffer           :: proc "c" (target: u32, buffer: u32, loc := #caller_location)                          {        impl_BindBuffer(target, buffer);                   debug_helper(loc, 0, target, buffer)                         }
	DeleteBuffers        :: proc "c" (n: i32, buffers: [^]u32, loc := #caller_location)                           {        impl_DeleteBuffers(n, buffers);                    debug_helper(loc, 0, n, buffers)                             }
	GenBuffers           :: proc "c" (n: i32, buffers: [^]u32, loc := #caller_location)                           {        impl_GenBuffers(n, buffers);                       debug_helper(loc, 0, n, buffers)                             }
	IsBuffer             :: proc "c" (buffer: u32, loc := #caller_location) -> bool                               { ret := impl_IsBuffer(buffer);                             debug_helper(loc, 1, ret, buffer);                return ret }
	BufferData           :: proc "c" (target: u32, size: int, data: rawptr, usage: u32, loc := #caller_location)  {        impl_BufferData(target, size, data, usage);        debug_helper(loc, 0, target, size, data, usage)              }
	BufferSubData        :: proc "c" (target: u32, offset: int, size: int, data: rawptr, loc := #caller_location) {        impl_BufferSubData(target, offset, size, data);    debug_helper(loc, 0, target, offset, size, data)             }
	GetBufferSubData     :: proc "c" (target: u32, offset: int, size: int, data: rawptr, loc := #caller_location) {        impl_GetBufferSubData(target, offset, size, data); debug_helper(loc, 0, target, offset, size, data)             }
	MapBuffer            :: proc "c" (target: u32, access: u32, loc := #caller_location) -> rawptr                { ret := impl_MapBuffer(target, access);                    debug_helper(loc, 1, ret, target, access);        return ret }
	UnmapBuffer          :: proc "c" (target: u32, loc := #caller_location) -> bool                               { ret := impl_UnmapBuffer(target);                          debug_helper(loc, 1, ret, target);                return ret }
	GetBufferParameteriv :: proc "c" (target: u32, pname: u32, params: [^]i32, loc := #caller_location)           {        impl_GetBufferParameteriv(target, pname, params);  debug_helper(loc, 0, target, pname, params)                  }
	GetBufferPointerv    :: proc "c" (target: u32, pname: u32, params: [^]rawptr, loc := #caller_location)        {        impl_GetBufferPointerv(target, pname, params);     debug_helper(loc, 0, target, pname, params)                  }

	// VERSION_2_0
	BlendEquationSeparate    :: proc "c" (modeRGB: u32, modeAlpha: u32, loc := #caller_location)                                                              {        impl_BlendEquationSeparate(modeRGB, modeAlpha);                            debug_helper(loc, 0, modeRGB, modeAlpha)                                             }
	DrawBuffers              :: proc "c" (n: i32, bufs: [^]u32, loc := #caller_location)                                                                      {        impl_DrawBuffers(n, bufs);                                                 debug_helper(loc, 0, n, bufs)                                                        }
	StencilOpSeparate        :: proc "c" (face: u32, sfail: u32, dpfail: u32, dppass: u32, loc := #caller_location)                                           {        impl_StencilOpSeparate(face, sfail, dpfail, dppass);                       debug_helper(loc, 0, face, sfail, dpfail, dppass)                                    }
	StencilFuncSeparate      :: proc "c" (face: u32, func: u32, ref: i32, mask: u32, loc := #caller_location)                                                 {        impl_StencilFuncSeparate(face, func, ref, mask);                           debug_helper(loc, 0, face, func, ref, mask)                                          }
	StencilMaskSeparate      :: proc "c" (face: u32, mask: u32, loc := #caller_location)                                                                      {        impl_StencilMaskSeparate(face, mask);                                      debug_helper(loc, 0, face, mask)                                                     }
	AttachShader             :: proc "c" (program: u32, shader: u32, loc := #caller_location)                                                                 {        impl_AttachShader(program, shader);                                        debug_helper(loc, 0, program, shader)                                                }
	BindAttribLocation       :: proc "c" (program: u32, index: u32, name: cstring, loc := #caller_location)                                                   {        impl_BindAttribLocation(program, index, name);                             debug_helper(loc, 0, program, index, name)                                           }
	CompileShader            :: proc "c" (shader: u32, loc := #caller_location)                                                                               {        impl_CompileShader(shader);                                                debug_helper(loc, 0, shader)                                                         }
	CreateProgram            :: proc "c" (loc := #caller_location) -> u32                                                                                     { ret := impl_CreateProgram();                                                      debug_helper(loc, 1, ret);                                                return ret }
	CreateShader             :: proc "c" (type: u32, loc := #caller_location) -> u32                                                                          { ret := impl_CreateShader(type);                                                  debug_helper(loc, 1, ret, type);                                         return ret }
	DeleteProgram            :: proc "c" (program: u32, loc := #caller_location)                                                                              {        impl_DeleteProgram(program);                                               debug_helper(loc, 0, program)                                                        }
	DeleteShader             :: proc "c" (shader: u32, loc := #caller_location)                                                                               {        impl_DeleteShader(shader);                                                 debug_helper(loc, 0, shader)                                                         }
	DetachShader             :: proc "c" (program: u32, shader: u32, loc := #caller_location)                                                                 {        impl_DetachShader(program, shader);                                        debug_helper(loc, 0, program, shader)                                                }
	DisableVertexAttribArray :: proc "c" (index: u32, loc := #caller_location)                                                                                {        impl_DisableVertexAttribArray(index);                                      debug_helper(loc, 0, index)                                                          }
	EnableVertexAttribArray  :: proc "c" (index: u32, loc := #caller_location)                                                                                {        impl_EnableVertexAttribArray(index);                                       debug_helper(loc, 0, index)                                                          }
	GetActiveAttrib          :: proc "c" (program: u32, index: u32, bufSize: i32, length: ^i32, size: ^i32, type: ^u32, name: [^]u8, loc := #caller_location) {        impl_GetActiveAttrib(program, index, bufSize, length, size, type, name);  debug_helper(loc, 0, program, index, bufSize, length, size, type, name)             }
	GetActiveUniform         :: proc "c" (program: u32, index: u32, bufSize: i32, length: ^i32, size: ^i32, type: ^u32, name: [^]u8, loc := #caller_location) {        impl_GetActiveUniform(program, index, bufSize, length, size, type, name); debug_helper(loc, 0, program, index, bufSize, length, size, type, name)             }
	GetAttachedShaders       :: proc "c" (program: u32, maxCount: i32, count: [^]i32, shaders: [^]u32, loc := #caller_location)                               {        impl_GetAttachedShaders(program, maxCount, count, shaders);                debug_helper(loc, 0, program, maxCount, count, shaders)                              }
	GetAttribLocation        :: proc "c" (program: u32, name: cstring, loc := #caller_location) -> i32                                                        { ret := impl_GetAttribLocation(program, name);                                     debug_helper(loc, 1, ret, program, name);                                 return ret }
	GetProgramiv             :: proc "c" (program: u32, pname: u32, params: [^]i32, loc := #caller_location)                                                  {        impl_GetProgramiv(program, pname, params);                                 debug_helper(loc, 0, program, pname, params)                                         }
	GetProgramInfoLog        :: proc "c" (program: u32, bufSize: i32, length: ^i32, infoLog: [^]u8, loc := #caller_location)                                  {        impl_GetProgramInfoLog(program, bufSize, length, infoLog);                 debug_helper(loc, 0, program, bufSize, length, infoLog)                              }
	GetShaderiv              :: proc "c" (shader: u32, pname: u32, params: [^]i32, loc := #caller_location)                                                   {        impl_GetShaderiv(shader, pname, params);                                   debug_helper(loc, 0, shader, pname, params)                                          }
	GetShaderInfoLog         :: proc "c" (shader: u32, bufSize: i32, length: ^i32, infoLog: [^]u8, loc := #caller_location)                                   {        impl_GetShaderInfoLog(shader, bufSize, length, infoLog);                   debug_helper(loc, 0, shader, bufSize, length, infoLog)                               }
	GetShaderSource          :: proc "c" (shader: u32, bufSize: i32, length: ^i32, source: [^]u8, loc := #caller_location)                                    {        impl_GetShaderSource(shader, bufSize, length, source);                     debug_helper(loc, 0, shader, bufSize, length, source)                                }
	GetUniformLocation       :: proc "c" (program: u32, name: cstring, loc := #caller_location) -> i32                                                        { ret := impl_GetUniformLocation(program, name);                                    debug_helper(loc, 1, ret, program, name);                                 return ret }
	GetUniformfv             :: proc "c" (program: u32, location: i32, params: [^]f32, loc := #caller_location)                                               {        impl_GetUniformfv(program, location, params);                              debug_helper(loc, 0, program, location, params)                                      }
	GetUniformiv             :: proc "c" (program: u32, location: i32, params: [^]i32, loc := #caller_location)                                               {        impl_GetUniformiv(program, location, params);                              debug_helper(loc, 0, program, location, params)                                      }
	GetVertexAttribdv        :: proc "c" (index: u32, pname: u32, params: [^]f64, loc := #caller_location)                                                    {        impl_GetVertexAttribdv(index, pname, params);                              debug_helper(loc, 0, index, pname, params)                                           }
	GetVertexAttribfv        :: proc "c" (index: u32, pname: u32, params: [^]f32, loc := #caller_location)                                                    {        impl_GetVertexAttribfv(index, pname, params);                              debug_helper(loc, 0, index, pname, params)                                           }
	GetVertexAttribiv        :: proc "c" (index: u32, pname: u32, params: [^]i32, loc := #caller_location)                                                    {        impl_GetVertexAttribiv(index, pname, params);                              debug_helper(loc, 0, index, pname, params)                                           }
	GetVertexAttribPointerv  :: proc "c" (index: u32, pname: u32, pointer: ^uintptr, loc := #caller_location)                                                  {        impl_GetVertexAttribPointerv(index, pname, pointer);                       debug_helper(loc, 0, index, pname, pointer)                                          }
	IsProgram                :: proc "c" (program: u32, loc := #caller_location) -> bool                                                                      { ret := impl_IsProgram(program);                                                   debug_helper(loc, 1, ret, program);                                       return ret }
	IsShader                 :: proc "c" (shader: u32, loc := #caller_location) -> bool                                                                       { ret := impl_IsShader(shader);                                                     debug_helper(loc, 1, ret, shader);                                        return ret }
	LinkProgram              :: proc "c" (program: u32, loc := #caller_location)                                                                              {        impl_LinkProgram(program);                                                 debug_helper(loc, 0, program)                                                        }
	ShaderSource             :: proc "c" (shader: u32, count: i32, string: [^]cstring, length: [^]i32, loc := #caller_location)                               {        impl_ShaderSource(shader, count, string, length);                          debug_helper(loc, 0, shader, count, string, length)                                  }
	UseProgram               :: proc "c" (program: u32, loc := #caller_location)                                                                              {        impl_UseProgram(program);                                                  debug_helper(loc, 0, program)                                                        }
	Uniform1f                :: proc "c" (location: i32, v0: f32, loc := #caller_location)                                                                    {        impl_Uniform1f(location, v0);                                              debug_helper(loc, 0, location, v0)                                                   }
	Uniform2f                :: proc "c" (location: i32, v0: f32, v1: f32, loc := #caller_location)                                                           {        impl_Uniform2f(location, v0, v1);                                          debug_helper(loc, 0, location, v0, v1)                                               }
	Uniform3f                :: proc "c" (location: i32, v0: f32, v1: f32, v2: f32, loc := #caller_location)                                                  {        impl_Uniform3f(location, v0, v1, v2);                                      debug_helper(loc, 0, location, v0, v1, v2)                                           }
	Uniform4f                :: proc "c" (location: i32, v0: f32, v1: f32, v2: f32, v3: f32, loc := #caller_location)                                         {        impl_Uniform4f(location, v0, v1, v2, v3);                                  debug_helper(loc, 0, location, v0, v1, v2, v3)                                       }
	Uniform1i                :: proc "c" (location: i32, v0: i32, loc := #caller_location)                                                                    {        impl_Uniform1i(location, v0);                                              debug_helper(loc, 0, location, v0)                                                   }
	Uniform2i                :: proc "c" (location: i32, v0: i32, v1: i32, loc := #caller_location)                                                           {        impl_Uniform2i(location, v0, v1);                                          debug_helper(loc, 0, location, v0, v1)                                               }
	Uniform3i                :: proc "c" (location: i32, v0: i32, v1: i32, v2: i32, loc := #caller_location)                                                  {        impl_Uniform3i(location, v0, v1, v2);                                      debug_helper(loc, 0, location, v0, v1, v2)                                           }
	Uniform4i                :: proc "c" (location: i32, v0: i32, v1: i32, v2: i32, v3: i32, loc := #caller_location)                                         {        impl_Uniform4i(location, v0, v1, v2, v3);                                  debug_helper(loc, 0, location, v0, v1, v2, v3)                                       }
	Uniform1fv               :: proc "c" (location: i32, count: i32, value: [^]f32, loc := #caller_location)                                                  {        impl_Uniform1fv(location, count, value);                                   debug_helper(loc, 0, location, count, value)                                         }
	Uniform2fv               :: proc "c" (location: i32, count: i32, value: [^]f32, loc := #caller_location)                                                  {        impl_Uniform2fv(location, count, value);                                   debug_helper(loc, 0, location, count, value)                                         }
	Uniform3fv               :: proc "c" (location: i32, count: i32, value: [^]f32, loc := #caller_location)                                                  {        impl_Uniform3fv(location, count, value);                                   debug_helper(loc, 0, location, count, value)                                         }
	Uniform4fv               :: proc "c" (location: i32, count: i32, value: [^]f32, loc := #caller_location)                                                  {        impl_Uniform4fv(location, count, value);                                   debug_helper(loc, 0, location, count, value)                                         }
	Uniform1iv               :: proc "c" (location: i32, count: i32, value: [^]i32, loc := #caller_location)                                                  {        impl_Uniform1iv(location, count, value);                                   debug_helper(loc, 0, location, count, value)                                         }
	Uniform2iv               :: proc "c" (location: i32, count: i32, value: [^]i32, loc := #caller_location)                                                  {        impl_Uniform2iv(location, count, value);                                   debug_helper(loc, 0, location, count, value)                                         }
	Uniform3iv               :: proc "c" (location: i32, count: i32, value: [^]i32, loc := #caller_location)                                                  {        impl_Uniform3iv(location, count, value);                                   debug_helper(loc, 0, location, count, value)                                         }
	Uniform4iv               :: proc "c" (location: i32, count: i32, value: [^]i32, loc := #caller_location)                                                  {        impl_Uniform4iv(location, count, value);                                   debug_helper(loc, 0, location, count, value)                                         }
	UniformMatrix2fv         :: proc "c" (location: i32, count: i32, transpose: bool, value: [^]f32, loc := #caller_location)                              {        impl_UniformMatrix2fv(location, count, transpose, value);                  debug_helper(loc, 0, location, count, transpose, value)                              }
	UniformMatrix3fv         :: proc "c" (location: i32, count: i32, transpose: bool, value: [^]f32, loc := #caller_location)                              {        impl_UniformMatrix3fv(location, count, transpose, value);                  debug_helper(loc, 0, location, count, transpose, value)                              }
	UniformMatrix4fv         :: proc "c" (location: i32, count: i32, transpose: bool, value: [^]f32, loc := #caller_location)                              {        impl_UniformMatrix4fv(location, count, transpose, value);                  debug_helper(loc, 0, location, count, transpose, value)                              }
	ValidateProgram          :: proc "c" (program: u32, loc := #caller_location)                                                                              {        impl_ValidateProgram(program);                                             debug_helper(loc, 0, program)                                                        }
	VertexAttrib1d           :: proc "c" (index: u32, x: f64, loc := #caller_location)                                                                        {        impl_VertexAttrib1d(index, x);                                             debug_helper(loc, 0, index, x)                                                       }
	VertexAttrib1dv          :: proc "c" (index: u32, v: ^f64, loc := #caller_location)                                                                       {        impl_VertexAttrib1dv(index, v);                                            debug_helper(loc, 0, index, v)                                                       }
	VertexAttrib1f           :: proc "c" (index: u32, x: f32, loc := #caller_location)                                                                        {        impl_VertexAttrib1f(index, x);                                             debug_helper(loc, 0, index, x)                                                       }
	VertexAttrib1fv          :: proc "c" (index: u32, v: ^f32, loc := #caller_location)                                                                       {        impl_VertexAttrib1fv(index, v);                                            debug_helper(loc, 0, index, v)                                                       }
	VertexAttrib1s           :: proc "c" (index: u32, x: i16, loc := #caller_location)                                                                        {        impl_VertexAttrib1s(index, x);                                             debug_helper(loc, 0, index, x)                                                       }
	VertexAttrib1sv          :: proc "c" (index: u32, v: ^i16, loc := #caller_location)                                                                       {        impl_VertexAttrib1sv(index, v);                                            debug_helper(loc, 0, index, v)                                                       }
	VertexAttrib2d           :: proc "c" (index: u32, x: f64, y: f64, loc := #caller_location)                                                                {        impl_VertexAttrib2d(index, x, y);                                          debug_helper(loc, 0, index, x, y)                                                    }
	VertexAttrib2dv          :: proc "c" (index: u32, v: ^[2]f64, loc := #caller_location)                                                                       {        impl_VertexAttrib2dv(index, v);                                            debug_helper(loc, 0, index, v)                                                       }
	VertexAttrib2f           :: proc "c" (index: u32, x: f32, y: f32, loc := #caller_location)                                                                {        impl_VertexAttrib2f(index, x, y);                                          debug_helper(loc, 0, index, x, y)                                                    }
	VertexAttrib2fv          :: proc "c" (index: u32, v: ^[2]f32, loc := #caller_location)                                                                       {        impl_VertexAttrib2fv(index, v);                                            debug_helper(loc, 0, index, v)                                                       }
	VertexAttrib2s           :: proc "c" (index: u32, x: i16, y: i16, loc := #caller_location)                                                                {        impl_VertexAttrib2s(index, x, y);                                          debug_helper(loc, 0, index, x, y)                                                    }
	VertexAttrib2sv          :: proc "c" (index: u32, v: ^[2]i16, loc := #caller_location)                                                                       {        impl_VertexAttrib2sv(index, v);                                            debug_helper(loc, 0, index, v)                                                       }
	VertexAttrib3d           :: proc "c" (index: u32, x: f64, y: f64, z: f64, loc := #caller_location)                                                        {        impl_VertexAttrib3d(index, x, y, z);                                       debug_helper(loc, 0, index, x, y, z)                                                 }
	VertexAttrib3dv          :: proc "c" (index: u32, v: ^[3]f64, loc := #caller_location)                                                                       {        impl_VertexAttrib3dv(index, v);                                            debug_helper(loc, 0, index, v)                                                       }
	VertexAttrib3f           :: proc "c" (index: u32, x: f32, y: f32, z: f32, loc := #caller_location)                                                        {        impl_VertexAttrib3f(index, x, y, z);                                       debug_helper(loc, 0, index, x, y, z)                                                 }
	VertexAttrib3fv          :: proc "c" (index: u32, v: ^[3]f32, loc := #caller_location)                                                                       {        impl_VertexAttrib3fv(index, v);                                            debug_helper(loc, 0, index, v)                                                       }
	VertexAttrib3s           :: proc "c" (index: u32, x: i16, y: i16, z: i16, loc := #caller_location)                                                        {        impl_VertexAttrib3s(index, x, y, z);                                       debug_helper(loc, 0, index, x, y, z)                                                 }
	VertexAttrib3sv          :: proc "c" (index: u32, v: ^[3]i16, loc := #caller_location)                                                                       {        impl_VertexAttrib3sv(index, v);                                            debug_helper(loc, 0, index, v)                                                       }
	VertexAttrib4Nbv         :: proc "c" (index: u32, v: ^[4]i8, loc := #caller_location)                                                                        {        impl_VertexAttrib4Nbv(index, v);                                           debug_helper(loc, 0, index, v)                                                       }
	VertexAttrib4Niv         :: proc "c" (index: u32, v: ^[4]i32, loc := #caller_location)                                                                       {        impl_VertexAttrib4Niv(index, v);                                           debug_helper(loc, 0, index, v)                                                       }
	VertexAttrib4Nsv         :: proc "c" (index: u32, v: ^[4]i16, loc := #caller_location)                                                                       {        impl_VertexAttrib4Nsv(index, v);                                           debug_helper(loc, 0, index, v)                                                       }
	VertexAttrib4Nub         :: proc "c" (index: u32, x: u8, y: u8, z: u8, w: u8, loc := #caller_location)                                                    {        impl_VertexAttrib4Nub(index, x, y, z, w);                                  debug_helper(loc, 0, index, x, y, z, w)                                              }
	VertexAttrib4Nubv        :: proc "c" (index: u32, v: ^[4]u8, loc := #caller_location)                                                                        {        impl_VertexAttrib4Nubv(index, v);                                          debug_helper(loc, 0, index, v)                                                       }
	VertexAttrib4Nuiv        :: proc "c" (index: u32, v: ^[4]u32, loc := #caller_location)                                                                       {        impl_VertexAttrib4Nuiv(index, v);                                          debug_helper(loc, 0, index, v)                                                       }
	VertexAttrib4Nusv        :: proc "c" (index: u32, v: ^[4]u16, loc := #caller_location)                                                                       {        impl_VertexAttrib4Nusv(index, v);                                          debug_helper(loc, 0, index, v)                                                       }
	VertexAttrib4bv          :: proc "c" (index: u32, v: ^[4]i8, loc := #caller_location)                                                                        {        impl_VertexAttrib4bv(index, v);                                            debug_helper(loc, 0, index, v)                                                       }
	VertexAttrib4d           :: proc "c" (index: u32, x: f64, y: f64, z: f64, w: f64, loc := #caller_location)                                                {        impl_VertexAttrib4d(index, x, y, z, w);                                    debug_helper(loc, 0, index, x, y, z, w)                                              }
	VertexAttrib4dv          :: proc "c" (index: u32, v: ^[4]f64, loc := #caller_location)                                                                       {        impl_VertexAttrib4dv(index, v);                                            debug_helper(loc, 0, index, v)                                                       }
	VertexAttrib4f           :: proc "c" (index: u32, x: f32, y: f32, z: f32, w: f32, loc := #caller_location)                                                {        impl_VertexAttrib4f(index, x, y, z, w);                                    debug_helper(loc, 0, index, x, y, z, w)                                              }
	VertexAttrib4fv          :: proc "c" (index: u32, v: ^[4]f32, loc := #caller_location)                                                                       {        impl_VertexAttrib4fv(index, v);                                            debug_helper(loc, 0, index, v)                                                       }
	VertexAttrib4iv          :: proc "c" (index: u32, v: ^[4]i32, loc := #caller_location)                                                                       {        impl_VertexAttrib4iv(index, v);                                            debug_helper(loc, 0, index, v)                                                       }
	VertexAttrib4s           :: proc "c" (index: u32, x: i16, y: i16, z: i16, w: i16, loc := #caller_location)                                                {        impl_VertexAttrib4s(index, x, y, z, w);                                    debug_helper(loc, 0, index, x, y, z, w)                                              }
	VertexAttrib4sv          :: proc "c" (index: u32, v: ^[4]i16, loc := #caller_location)                                                                       {        impl_VertexAttrib4sv(index, v);                                            debug_helper(loc, 0, index, v)                                                       }
	VertexAttrib4ubv         :: proc "c" (index: u32, v: ^[4]u8, loc := #caller_location)                                                                        {        impl_VertexAttrib4ubv(index, v);                                           debug_helper(loc, 0, index, v)                                                       }
	VertexAttrib4uiv         :: proc "c" (index: u32, v: ^[4]u32, loc := #caller_location)                                                                       {        impl_VertexAttrib4uiv(index, v);                                           debug_helper(loc, 0, index, v)                                                       }
	VertexAttrib4usv         :: proc "c" (index: u32, v: ^[4]u16, loc := #caller_location)                                                                       {        impl_VertexAttrib4usv(index, v);                                           debug_helper(loc, 0, index, v)                                                       }
	VertexAttribPointer      :: proc "c" (index: u32, size: i32, type: u32, normalized: bool, stride: i32, pointer: uintptr, loc := #caller_location)          {        impl_VertexAttribPointer(index, size, type, normalized, stride, pointer); debug_helper(loc, 0, index, size, type, normalized, stride, pointer)                }

	// VERSION_2_1
	UniformMatrix2x3fv :: proc "c" (location: i32, count: i32, transpose: bool, value: [^]f32, loc := #caller_location) { impl_UniformMatrix2x3fv(location, count, transpose, value); debug_helper(loc, 0, location, count, transpose, value) }
	UniformMatrix3x2fv :: proc "c" (location: i32, count: i32, transpose: bool, value: [^]f32, loc := #caller_location) { impl_UniformMatrix3x2fv(location, count, transpose, value); debug_helper(loc, 0, location, count, transpose, value) }
	UniformMatrix2x4fv :: proc "c" (location: i32, count: i32, transpose: bool, value: [^]f32, loc := #caller_location) { impl_UniformMatrix2x4fv(location, count, transpose, value); debug_helper(loc, 0, location, count, transpose, value) }
	UniformMatrix4x2fv :: proc "c" (location: i32, count: i32, transpose: bool, value: [^]f32, loc := #caller_location) { impl_UniformMatrix4x2fv(location, count, transpose, value); debug_helper(loc, 0, location, count, transpose, value) }
	UniformMatrix3x4fv :: proc "c" (location: i32, count: i32, transpose: bool, value: [^]f32, loc := #caller_location) { impl_UniformMatrix3x4fv(location, count, transpose, value); debug_helper(loc, 0, location, count, transpose, value) }
	UniformMatrix4x3fv :: proc "c" (location: i32, count: i32, transpose: bool, value: [^]f32, loc := #caller_location) { impl_UniformMatrix4x3fv(location, count, transpose, value); debug_helper(loc, 0, location, count, transpose, value) }

		// VERSION_3_0
	ColorMaski                          :: proc "c" (index: u32, r: bool, g: bool, b: bool, a: bool, loc := #caller_location)                                                                         {        impl_ColorMaski(index, r, g, b, a);                                                         debug_helper(loc, 0, index, r, g, b, a)                                                                }
	GetBooleani_v                       :: proc "c" (target: u32, index: u32, data: ^bool, loc := #caller_location)                                                                                   {        impl_GetBooleani_v(target, index, data);                                                    debug_helper(loc, 0, target, index, data)                                                              }
	GetIntegeri_v                       :: proc "c" (target: u32, index: u32, data: ^i32, loc := #caller_location)                                                                                    {        impl_GetIntegeri_v(target, index, data);                                                    debug_helper(loc, 0, target, index, data)                                                              }
	Enablei                             :: proc "c" (target: u32, index: u32, loc := #caller_location)                                                                                                {        impl_Enablei(target, index);                                                                debug_helper(loc, 0, target, index)                                                                    }
	Disablei                            :: proc "c" (target: u32, index: u32, loc := #caller_location)                                                                                                {        impl_Disablei(target, index);                                                               debug_helper(loc, 0, target, index)                                                                    }
	IsEnabledi                          :: proc "c" (target: u32, index: u32, loc := #caller_location) -> bool                                                                                        { ret := impl_IsEnabledi(target, index);                                                             debug_helper(loc, 1, ret, target, index);                                                   return ret }
	BeginTransformFeedback              :: proc "c" (primitiveMode: u32, loc := #caller_location)                                                                                                     {        impl_BeginTransformFeedback(primitiveMode);                                                 debug_helper(loc, 0, primitiveMode)                                                                    }
	EndTransformFeedback                :: proc "c" (loc := #caller_location)                                                                                                                         {        impl_EndTransformFeedback();                                                                debug_helper(loc, 0)                                                                                   }
	BindBufferRange                     :: proc "c" (target: u32, index: u32, buffer: u32, offset: int, size: int, loc := #caller_location)                                                           {        impl_BindBufferRange(target, index, buffer, offset, size);                                  debug_helper(loc, 0, target, index, buffer, offset, size)                                              }
	BindBufferBase                      :: proc "c" (target: u32, index: u32, buffer: u32, loc := #caller_location)                                                                                   {        impl_BindBufferBase(target, index, buffer);                                                 debug_helper(loc, 0, target, index, buffer)                                                            }
	TransformFeedbackVaryings           :: proc "c" (program: u32, count: i32, varyings: [^]cstring, bufferMode: u32, loc := #caller_location)                                                        {        impl_TransformFeedbackVaryings(program, count, varyings, bufferMode);                       debug_helper(loc, 0, program, count, varyings, bufferMode)                                             }
	GetTransformFeedbackVarying         :: proc "c" (program: u32, index: u32, bufSize: i32, length: ^i32, size: ^i32, type: ^u32, name: [^]u8, loc := #caller_location)                              {        impl_GetTransformFeedbackVarying(program, index, bufSize, length, size, type, name);       debug_helper(loc, 0, program, index, bufSize, length, size, type, name)                               }
	ClampColor                          :: proc "c" (target: u32, clamp: u32, loc := #caller_location)                                                                                                {        impl_ClampColor(target, clamp);                                                             debug_helper(loc, 0, target, clamp)                                                                    }
	BeginConditionalRender              :: proc "c" (id: u32, mode: u32, loc := #caller_location)                                                                                                     {        impl_BeginConditionalRender(id, mode);                                                      debug_helper(loc, 0, id, mode)                                                                         }
	EndConditionalRender                :: proc "c" (loc := #caller_location)                                                                                                                         {        impl_EndConditionalRender();                                                                debug_helper(loc, 0)                                                                                   }
	VertexAttribIPointer                :: proc "c" (index: u32, size: i32, type: u32, stride: i32, pointer: uintptr, loc := #caller_location)                                                         {        impl_VertexAttribIPointer(index, size, type, stride, pointer);                             debug_helper(loc, 0, index, size, type, stride, pointer)                                              }
	GetVertexAttribIiv                  :: proc "c" (index: u32, pname: u32, params: [^]i32, loc := #caller_location)                                                                                 {        impl_GetVertexAttribIiv(index, pname, params);                                              debug_helper(loc, 0, index, pname, params)                                                             }
	GetVertexAttribIuiv                 :: proc "c" (index: u32, pname: u32, params: [^]u32, loc := #caller_location)                                                                                 {        impl_GetVertexAttribIuiv(index, pname, params);                                             debug_helper(loc, 0, index, pname, params)                                                             }
	VertexAttribI1i                     :: proc "c" (index: u32, x: i32, loc := #caller_location)                                                                                                     {        impl_VertexAttribI1i(index, x);                                                             debug_helper(loc, 0, index, x)                                                                         }
	VertexAttribI2i                     :: proc "c" (index: u32, x: i32, y: i32, loc := #caller_location)                                                                                             {        impl_VertexAttribI2i(index, x, y);                                                          debug_helper(loc, 0, index, x, y)                                                                      }
	VertexAttribI3i                     :: proc "c" (index: u32, x: i32, y: i32, z: i32, loc := #caller_location)                                                                                     {        impl_VertexAttribI3i(index, x, y, z);                                                       debug_helper(loc, 0, index, x, y, z)                                                                   }
	VertexAttribI4i                     :: proc "c" (index: u32, x: i32, y: i32, z: i32, w: i32, loc := #caller_location)                                                                             {        impl_VertexAttribI4i(index, x, y, z, w);                                                    debug_helper(loc, 0, index, x, y, z, w)                                                                }
	VertexAttribI1ui                    :: proc "c" (index: u32, x: u32, loc := #caller_location)                                                                                                     {        impl_VertexAttribI1ui(index, x);                                                            debug_helper(loc, 0, index, x)                                                                         }
	VertexAttribI2ui                    :: proc "c" (index: u32, x: u32, y: u32, loc := #caller_location)                                                                                             {        impl_VertexAttribI2ui(index, x, y);                                                         debug_helper(loc, 0, index, x, y)                                                                      }
	VertexAttribI3ui                    :: proc "c" (index: u32, x: u32, y: u32, z: u32, loc := #caller_location)                                                                                     {        impl_VertexAttribI3ui(index, x, y, z);                                                      debug_helper(loc, 0, index, x, y, z)                                                                   }
	VertexAttribI4ui                    :: proc "c" (index: u32, x: u32, y: u32, z: u32, w: u32, loc := #caller_location)                                                                             {        impl_VertexAttribI4ui(index, x, y, z, w);                                                   debug_helper(loc, 0, index, x, y, z, w)                                                                }
	VertexAttribI1iv                    :: proc "c" (index: u32, v: [^]i32, loc := #caller_location)                                                                                                    {        impl_VertexAttribI1iv(index, v);                                                            debug_helper(loc, 0, index, v)                                                                         }
	VertexAttribI2iv                    :: proc "c" (index: u32, v: [^]i32, loc := #caller_location)                                                                                                    {        impl_VertexAttribI2iv(index, v);                                                            debug_helper(loc, 0, index, v)                                                                         }
	VertexAttribI3iv                    :: proc "c" (index: u32, v: [^]i32, loc := #caller_location)                                                                                                    {        impl_VertexAttribI3iv(index, v);                                                            debug_helper(loc, 0, index, v)                                                                         }
	VertexAttribI4iv                    :: proc "c" (index: u32, v: [^]i32, loc := #caller_location)                                                                                                    {        impl_VertexAttribI4iv(index, v);                                                            debug_helper(loc, 0, index, v)                                                                         }
	VertexAttribI1uiv                   :: proc "c" (index: u32, v: [^]u32, loc := #caller_location)                                                                                                    {        impl_VertexAttribI1uiv(index, v);                                                           debug_helper(loc, 0, index, v)                                                                         }
	VertexAttribI2uiv                   :: proc "c" (index: u32, v: [^]u32, loc := #caller_location)                                                                                                    {        impl_VertexAttribI2uiv(index, v);                                                           debug_helper(loc, 0, index, v)                                                                         }
	VertexAttribI3uiv                   :: proc "c" (index: u32, v: [^]u32, loc := #caller_location)                                                                                                    {        impl_VertexAttribI3uiv(index, v);                                                           debug_helper(loc, 0, index, v)                                                                         }
	VertexAttribI4uiv                   :: proc "c" (index: u32, v: [^]u32, loc := #caller_location)                                                                                                    {        impl_VertexAttribI4uiv(index, v);                                                           debug_helper(loc, 0, index, v)                                                                         }
	VertexAttribI4bv                    :: proc "c" (index: u32, v: [^]i8, loc := #caller_location)                                                                                                     {        impl_VertexAttribI4bv(index, v);                                                            debug_helper(loc, 0, index, v)                                                                         }
	VertexAttribI4sv                    :: proc "c" (index: u32, v: [^]i16, loc := #caller_location)                                                                                                    {        impl_VertexAttribI4sv(index, v);                                                            debug_helper(loc, 0, index, v)                                                                         }
	VertexAttribI4ubv                   :: proc "c" (index: u32, v: [^]u8, loc := #caller_location)                                                                                                     {        impl_VertexAttribI4ubv(index, v);                                                           debug_helper(loc, 0, index, v)                                                                         }
	VertexAttribI4usv                   :: proc "c" (index: u32, v: [^]u16, loc := #caller_location)                                                                                                    {        impl_VertexAttribI4usv(index, v);                                                           debug_helper(loc, 0, index, v)                                                                         }
	GetUniformuiv                       :: proc "c" (program: u32, location: i32, params: [^]u32, loc := #caller_location)                                                                            {        impl_GetUniformuiv(program, location, params);                                              debug_helper(loc, 0, program, location, params)                                                        }
	BindFragDataLocation                :: proc "c" (program: u32, color: u32, name: cstring, loc := #caller_location)                                                                                {        impl_BindFragDataLocation(program, color, name);                                            debug_helper(loc, 0, program, color, name)                                                             }
	GetFragDataLocation                 :: proc "c" (program: u32, name: cstring, loc := #caller_location) -> i32                                                                                     { ret := impl_GetFragDataLocation(program, name);                                                    debug_helper(loc, 1, ret, program, name);                                                   return ret }
	Uniform1ui                          :: proc "c" (location: i32, v0: u32, loc := #caller_location)                                                                                                 {        impl_Uniform1ui(location, v0);                                                              debug_helper(loc, 0, location, v0)                                                                     }
	Uniform2ui                          :: proc "c" (location: i32, v0: u32, v1: u32, loc := #caller_location)                                                                                        {        impl_Uniform2ui(location, v0, v1);                                                          debug_helper(loc, 0, location, v0, v1)                                                                 }
	Uniform3ui                          :: proc "c" (location: i32, v0: u32, v1: u32, v2: u32, loc := #caller_location)                                                                               {        impl_Uniform3ui(location, v0, v1, v2);                                                      debug_helper(loc, 0, location, v0, v1, v2)                                                             }
	Uniform4ui                          :: proc "c" (location: i32, v0: u32, v1: u32, v2: u32, v3: u32, loc := #caller_location)                                                                      {        impl_Uniform4ui(location, v0, v1, v2, v3);                                                  debug_helper(loc, 0, location, v0, v1, v2, v3)                                                         }
	Uniform1uiv                         :: proc "c" (location: i32, count: i32, value: [^]u32, loc := #caller_location)                                                                               {        impl_Uniform1uiv(location, count, value);                                                   debug_helper(loc, 0, location, count, value)                                                           }
	Uniform2uiv                         :: proc "c" (location: i32, count: i32, value: [^]u32, loc := #caller_location)                                                                               {        impl_Uniform2uiv(location, count, value);                                                   debug_helper(loc, 0, location, count, value)                                                           }
	Uniform3uiv                         :: proc "c" (location: i32, count: i32, value: [^]u32, loc := #caller_location)                                                                               {        impl_Uniform3uiv(location, count, value);                                                   debug_helper(loc, 0, location, count, value)                                                           }
	Uniform4uiv                         :: proc "c" (location: i32, count: i32, value: [^]u32, loc := #caller_location)                                                                               {        impl_Uniform4uiv(location, count, value);                                                   debug_helper(loc, 0, location, count, value)                                                           }
	TexParameterIiv                     :: proc "c" (target: u32, pname: u32, params: [^]i32, loc := #caller_location)                                                                                {        impl_TexParameterIiv(target, pname, params);                                                debug_helper(loc, 0, target, pname, params)                                                            }
	TexParameterIuiv                    :: proc "c" (target: u32, pname: u32, params: [^]u32, loc := #caller_location)                                                                                {        impl_TexParameterIuiv(target, pname, params);                                               debug_helper(loc, 0, target, pname, params)                                                            }
	GetTexParameterIiv                  :: proc "c" (target: u32, pname: u32, params: [^]i32, loc := #caller_location)                                                                                {        impl_GetTexParameterIiv(target, pname, params);                                             debug_helper(loc, 0, target, pname, params)                                                            }
	GetTexParameterIuiv                 :: proc "c" (target: u32, pname: u32, params: [^]u32, loc := #caller_location)                                                                                {        impl_GetTexParameterIuiv(target, pname, params);                                            debug_helper(loc, 0, target, pname, params)                                                            }
	ClearBufferiv                       :: proc "c" (buffer: u32, drawbuffer: i32, value: ^i32, loc := #caller_location)                                                                              {        impl_ClearBufferiv(buffer, drawbuffer, value);                                              debug_helper(loc, 0, buffer, drawbuffer, value)                                                        }
	ClearBufferuiv                      :: proc "c" (buffer: u32, drawbuffer: i32, value: ^u32, loc := #caller_location)                                                                              {        impl_ClearBufferuiv(buffer, drawbuffer, value);                                             debug_helper(loc, 0, buffer, drawbuffer, value)                                                        }
	ClearBufferfv                       :: proc "c" (buffer: u32, drawbuffer: i32, value: ^f32, loc := #caller_location)                                                                              {        impl_ClearBufferfv(buffer, drawbuffer, value);                                              debug_helper(loc, 0, buffer, drawbuffer, value)                                                        }
	ClearBufferfi                       :: proc "c" (buffer: u32, drawbuffer: i32, depth: f32, stencil: i32, loc := #caller_location) -> rawptr                                                       { ret := impl_ClearBufferfi(buffer, drawbuffer, depth, stencil);                                     debug_helper(loc, 1, ret, buffer, drawbuffer, depth, stencil);                              return ret }
	GetStringi                          :: proc "c" (name: u32, index: u32, loc := #caller_location) -> cstring                                                                                       { ret := impl_GetStringi(name, index);                                                               debug_helper(loc, 1, ret, name, index);                                                     return ret }
	IsRenderbuffer                      :: proc "c" (renderbuffer: u32, loc := #caller_location) -> bool                                                                                              { ret := impl_IsRenderbuffer(renderbuffer);                                                          debug_helper(loc, 1, ret, renderbuffer);                                                    return ret }
	BindRenderbuffer                    :: proc "c" (target: u32, renderbuffer: u32, loc := #caller_location)                                                                                         {        impl_BindRenderbuffer(target, renderbuffer);                                                debug_helper(loc, 0, target, renderbuffer)                                                             }
	DeleteRenderbuffers                 :: proc "c" (n: i32, renderbuffers: [^]u32, loc := #caller_location)                                                                                          {        impl_DeleteRenderbuffers(n, renderbuffers);                                                 debug_helper(loc, 0, n, renderbuffers)                                                                 }
	GenRenderbuffers                    :: proc "c" (n: i32, renderbuffers: [^]u32, loc := #caller_location)                                                                                          {        impl_GenRenderbuffers(n, renderbuffers);                                                    debug_helper(loc, 0, n, renderbuffers)                                                                 }
	RenderbufferStorage                 :: proc "c" (target: u32, internalformat: u32, width: i32, height: i32, loc := #caller_location)                                                              {        impl_RenderbufferStorage(target, internalformat, width, height);                            debug_helper(loc, 0, target, internalformat, width, height)                                            }
	GetRenderbufferParameteriv          :: proc "c" (target: u32, pname: u32, params: [^]i32, loc := #caller_location)                                                                                {        impl_GetRenderbufferParameteriv(target, pname, params);                                     debug_helper(loc, 0, target, pname, params)                                                            }
	IsFramebuffer                       :: proc "c" (framebuffer: u32, loc := #caller_location) -> bool                                                                                               { ret := impl_IsFramebuffer(framebuffer);                                                            debug_helper(loc, 1, ret, framebuffer);                                                     return ret }
	BindFramebuffer                     :: proc "c" (target: u32, framebuffer: u32, loc := #caller_location)                                                                                          {        impl_BindFramebuffer(target, framebuffer);                                                  debug_helper(loc, 0, target, framebuffer)                                                              }
	DeleteFramebuffers                  :: proc "c" (n: i32, framebuffers: [^]u32, loc := #caller_location)                                                                                           {        impl_DeleteFramebuffers(n, framebuffers);                                                   debug_helper(loc, 0, n, framebuffers)                                                                  }
	GenFramebuffers                     :: proc "c" (n: i32, framebuffers: [^]u32, loc := #caller_location)                                                                                           {        impl_GenFramebuffers(n, framebuffers);                                                      debug_helper(loc, 0, n, framebuffers)                                                                  }
	CheckFramebufferStatus              :: proc "c" (target: u32, loc := #caller_location) -> u32                                                                                                     { ret := impl_CheckFramebufferStatus(target);                                                        debug_helper(loc, 1, ret, target);                                                          return ret }
	FramebufferTexture1D                :: proc "c" (target: u32, attachment: u32, textarget: u32, texture: u32, level: i32, loc := #caller_location)                                                 {        impl_FramebufferTexture1D(target, attachment, textarget, texture, level);                   debug_helper(loc, 0, target, attachment, textarget, texture, level)                                    }
	FramebufferTexture2D                :: proc "c" (target: u32, attachment: u32, textarget: u32, texture: u32, level: i32, loc := #caller_location)                                                 {        impl_FramebufferTexture2D(target, attachment, textarget, texture, level);                   debug_helper(loc, 0, target, attachment, textarget, texture, level)                                    }
	FramebufferTexture3D                :: proc "c" (target: u32, attachment: u32, textarget: u32, texture: u32, level: i32, zoffset: i32, loc := #caller_location)                                   {        impl_FramebufferTexture3D(target, attachment, textarget, texture, level, zoffset);          debug_helper(loc, 0, target, attachment, textarget, texture, level, zoffset)                           }
	FramebufferRenderbuffer             :: proc "c" (target: u32, attachment: u32, renderbuffertarget: u32, renderbuffer: u32, loc := #caller_location)                                               {        impl_FramebufferRenderbuffer(target, attachment, renderbuffertarget, renderbuffer);         debug_helper(loc, 0, target, attachment, renderbuffertarget, renderbuffer)                             }
	GetFramebufferAttachmentParameteriv :: proc "c" (target: u32, attachment: u32, pname: u32, params: [^]i32, loc := #caller_location)                                                               {        impl_GetFramebufferAttachmentParameteriv(target, attachment, pname, params);                debug_helper(loc, 0, target, attachment, pname, params)                                                }
	GenerateMipmap                      :: proc "c" (target: u32, loc := #caller_location)                                                                                                            {        impl_GenerateMipmap(target);                                                                debug_helper(loc, 0, target)                                                                           }
	BlitFramebuffer                     :: proc "c" (srcX0: i32, srcY0: i32, srcX1: i32, srcY1: i32, dstX0: i32, dstY0: i32, dstX1: i32, dstY1: i32, mask: u32, filter: u32, loc := #caller_location) {        impl_BlitFramebuffer(srcX0, srcY0, srcX1, srcY1, dstX0, dstY0, dstX1, dstY1, mask, filter); debug_helper(loc, 0, srcX0, srcY0, srcX1, srcY1, dstX0, dstY0, dstX1, dstY1, mask, filter)             }
	RenderbufferStorageMultisample      :: proc "c" (target: u32, samples: i32, internalformat: u32, width: i32, height: i32, loc := #caller_location)                                                {        impl_RenderbufferStorageMultisample(target, samples, internalformat, width, height);        debug_helper(loc, 0, target, samples, internalformat, width, height)                                   }
	FramebufferTextureLayer             :: proc "c" (target: u32, attachment: u32, texture: u32, level: i32, layer: i32, loc := #caller_location)                                                     {        impl_FramebufferTextureLayer(target, attachment, texture, level, layer);                    debug_helper(loc, 0, target, attachment, texture, level, layer)                                        }
	MapBufferRange                      :: proc "c" (target: u32, offset: int, length: int, access: u32, loc := #caller_location) -> rawptr                                                           { ret := impl_MapBufferRange(target, offset, length, access);                                        debug_helper(loc, 1, ret, target, offset, length, access);                                  return ret }
	FlushMappedBufferRange              :: proc "c" (target: u32, offset: int, length: int, loc := #caller_location)                                                                                  {        impl_FlushMappedBufferRange(target, offset, length);                                        debug_helper(loc, 0, target, offset, length)                                                           }
	BindVertexArray                     :: proc "c" (array: u32, loc := #caller_location)                                                                                                             {        impl_BindVertexArray(array);                                                                debug_helper(loc, 0, array)                                                                            }
	DeleteVertexArrays                  :: proc "c" (n: i32, arrays: [^]u32, loc := #caller_location)                                                                                                 {        impl_DeleteVertexArrays(n, arrays);                                                         debug_helper(loc, 0, n, arrays)                                                                        }
	GenVertexArrays                     :: proc "c" (n: i32, arrays: [^]u32, loc := #caller_location)                                                                                                 {        impl_GenVertexArrays(n, arrays);                                                            debug_helper(loc, 0, n, arrays)                                                                        }
	IsVertexArray                       :: proc "c" (array: u32, loc := #caller_location) -> bool                                                                                                     { ret := impl_IsVertexArray(array);                                                                  debug_helper(loc, 1, ret, array);                                                           return ret }

	// VERSION_3_1
	DrawArraysInstanced       :: proc "c" (mode: u32, first: i32, count: i32, instancecount: i32, loc := #caller_location)                                     {        impl_DrawArraysInstanced(mode, first, count, instancecount);                                   debug_helper(loc, 0, mode, first, count, instancecount)            }
	DrawElementsInstanced     :: proc "c" (mode: u32, count: i32, type: u32, indices: rawptr, instancecount: i32, loc := #caller_location)                     {        impl_DrawElementsInstanced(mode, count, type, indices, instancecount);                        debug_helper(loc, 0, mode, count, type, indices, instancecount)            }
	TexBuffer                 :: proc "c" (target: u32, internalformat: u32, buffer: u32, loc := #caller_location)                                             {        impl_TexBuffer(target, internalformat, buffer);                                                debug_helper(loc, 0, target, internalformat, buffer)            }
	PrimitiveRestartIndex     :: proc "c" (index: u32, loc := #caller_location)                                                                                {        impl_PrimitiveRestartIndex(index);                                                             debug_helper(loc, 0, index)            }
	CopyBufferSubData         :: proc "c" (readTarget: u32, writeTarget: u32, readOffset: int, writeOffset: int, size: int, loc := #caller_location)           {        impl_CopyBufferSubData(readTarget, writeTarget, readOffset, writeOffset, size);                debug_helper(loc, 0, readTarget, writeTarget, readOffset, writeOffset, size)            }
	GetUniformIndices         :: proc "c" (program: u32, uniformCount: i32, uniformNames: [^]cstring, uniformIndices: [^]u32, loc := #caller_location)         {        impl_GetUniformIndices(program, uniformCount, uniformNames, uniformIndices);                   debug_helper(loc, 0, program, uniformCount, uniformNames, uniformIndices)            }
	GetActiveUniformsiv       :: proc "c" (program: u32, uniformCount: i32, uniformIndices: [^]u32, pname: u32, params: [^]i32, loc := #caller_location)       {        impl_GetActiveUniformsiv(program, uniformCount, uniformIndices, pname, params);                debug_helper(loc, 0, program, uniformCount, uniformIndices, pname, params)            }
	GetActiveUniformName      :: proc "c" (program: u32, uniformIndex: u32, bufSize: i32, length: ^i32, uniformName: [^]u8, loc := #caller_location)           {        impl_GetActiveUniformName(program, uniformIndex, bufSize, length, uniformName);                debug_helper(loc, 0, program, uniformIndex, bufSize, length, uniformName)            }
	GetUniformBlockIndex      :: proc "c" (program: u32, uniformBlockName: cstring, loc := #caller_location) -> u32                                            { ret := impl_GetUniformBlockIndex(program, uniformBlockName);                                          debug_helper(loc, 1, ret, program, uniformBlockName); return ret }
	GetActiveUniformBlockiv   :: proc "c" (program: u32, uniformBlockIndex: u32, pname: u32, params: [^]i32, loc := #caller_location)                          {        impl_GetActiveUniformBlockiv(program, uniformBlockIndex, pname, params);                       debug_helper(loc, 0, program, uniformBlockIndex, pname, params)            }
	GetActiveUniformBlockName :: proc "c" (program: u32, uniformBlockIndex: u32, bufSize: i32, length: ^i32, uniformBlockName: [^]u8, loc := #caller_location) {        impl_GetActiveUniformBlockName(program, uniformBlockIndex, bufSize, length, uniformBlockName); debug_helper(loc, 0, program, uniformBlockIndex, bufSize, length, uniformBlockName)            }
	UniformBlockBinding       :: proc "c" (program: u32, uniformBlockIndex: u32, uniformBlockBinding: u32, loc := #caller_location)                            {        impl_UniformBlockBinding(program, uniformBlockIndex, uniformBlockBinding);                     debug_helper(loc, 0, program, uniformBlockIndex, uniformBlockBinding)            }

	// VERSION_3_2
	DrawElementsBaseVertex          :: proc "c" (mode: u32, count: i32, type: u32, indices: rawptr, basevertex: i32, loc := #caller_location)                                            {        impl_DrawElementsBaseVertex(mode, count, type, indices, basevertex);                                    debug_helper(loc, 0, mode, count, type, indices, basevertex)                                                 }
	DrawRangeElementsBaseVertex     :: proc "c" (mode: u32, start: u32, end: u32, count: i32, type: u32, indices: rawptr, basevertex: i32, loc := #caller_location)                      {        impl_DrawRangeElementsBaseVertex(mode, start, end, count, type, indices, basevertex);                   debug_helper(loc, 0, mode, start, end, count, type, indices, basevertex)                                     }
	DrawElementsInstancedBaseVertex :: proc "c" (mode: u32, count: i32, type: u32, indices: rawptr, instancecount: i32, basevertex: i32, loc := #caller_location)                        {        impl_DrawElementsInstancedBaseVertex(mode, count, type, indices, instancecount, basevertex);            debug_helper(loc, 0, mode, count, type, indices, instancecount, basevertex)                                  }
	MultiDrawElementsBaseVertex     :: proc "c" (mode: u32, count: [^]i32, type: u32, indices: [^]rawptr, drawcount: i32, basevertex: [^]i32, loc := #caller_location)                   {        impl_MultiDrawElementsBaseVertex(mode, count, type, indices, drawcount, basevertex);                    debug_helper(loc, 0, mode, count, type, indices, drawcount, basevertex)                                      }
	ProvokingVertex                 :: proc "c" (mode: u32, loc := #caller_location)                                                                                                     {        impl_ProvokingVertex(mode);                                                                              debug_helper(loc, 0, mode)                                                                                    }
	FenceSync                       :: proc "c" (condition: u32, flags: u32, loc := #caller_location) -> sync_t                                                                          { ret := impl_FenceSync(condition, flags);                                                                        debug_helper(loc, 1, ret, condition, flags);                                                       return ret }
	IsSync                          :: proc "c" (sync: sync_t, loc := #caller_location) -> bool                                                                                          { ret := impl_IsSync(sync);                                                                                       debug_helper(loc, 1, ret, sync);                                                                   return ret }
	DeleteSync                      :: proc "c" (sync: sync_t, loc := #caller_location)                                                                                                  {        impl_DeleteSync(sync);                                                                                   debug_helper(loc, 0, sync)                                                                                    }
	ClientWaitSync                  :: proc "c" (sync: sync_t, flags: u32, timeout: u64, loc := #caller_location) -> u32                                                                 { ret := impl_ClientWaitSync(sync, flags, timeout);                                                               debug_helper(loc, 1, ret, sync, flags, timeout);                                                   return ret }
	WaitSync                        :: proc "c" (sync: sync_t, flags: u32, timeout: u64, loc := #caller_location)                                                                        {        impl_WaitSync(sync, flags, timeout);                                                                     debug_helper(loc, 0, sync, flags, timeout)                                                                    }
	GetInteger64v                   :: proc "c" (pname: u32, data: ^i64, loc := #caller_location)                                                                                        {        impl_GetInteger64v(pname, data);                                                                         debug_helper(loc, 0, pname, data)                                                                             }
	GetSynciv                       :: proc "c" (sync: sync_t, pname: u32, bufSize: i32, length: ^i32, values: [^]i32, loc := #caller_location)                                          {        impl_GetSynciv(sync, pname, bufSize, length, values);                                                    debug_helper(loc, 0, sync, pname, bufSize, length, values)                                                    }
	GetInteger64i_v                 :: proc "c" (target: u32, index: u32, data: ^i64, loc := #caller_location)                                                                           {        impl_GetInteger64i_v(target, index, data);                                                               debug_helper(loc, 0, target, index, data)                                                                     }
	GetBufferParameteri64v          :: proc "c" (target: u32, pname: u32, params: [^]i64, loc := #caller_location)                                                                       {        impl_GetBufferParameteri64v(target, pname, params);                                                      debug_helper(loc, 0, target, pname, params)                                                                   }
	FramebufferTexture              :: proc "c" (target: u32, attachment: u32, texture: u32, level: i32, loc := #caller_location)                                                        {        impl_FramebufferTexture(target, attachment, texture, level);                                             debug_helper(loc, 0, target, attachment, texture, level)                                                      }
	TexImage2DMultisample           :: proc "c" (target: u32, samples: i32, internalformat: u32, width: i32, height: i32, fixedsamplelocations: bool, loc := #caller_location)             {        impl_TexImage2DMultisample(target, samples, internalformat, width, height, fixedsamplelocations);        debug_helper(loc, 0, target, samples, internalformat, width, height, fixedsamplelocations)                    }
	TexImage3DMultisample           :: proc "c" (target: u32, samples: i32, internalformat: u32, width: i32, height: i32, depth: i32, fixedsamplelocations: bool, loc := #caller_location) {        impl_TexImage3DMultisample(target, samples, internalformat, width, height, depth, fixedsamplelocations); debug_helper(loc, 0, target, samples, internalformat, width, height, depth, fixedsamplelocations)             }
	GetMultisamplefv                :: proc "c" (pname: u32, index: u32, val: ^f32, loc := #caller_location)                                                                             {        impl_GetMultisamplefv(pname, index, val);                                                                debug_helper(loc, 0, pname, index, val)                                                                       }
	SampleMaski                     :: proc "c" (maskNumber: u32, mask: u32, loc := #caller_location)                                                                                    {        impl_SampleMaski(maskNumber, mask);                                                                      debug_helper(loc, 0, maskNumber, mask)                                                                        }

	// VERSION_3_3
	BindFragDataLocationIndexed :: proc "c" (program: u32, colorNumber: u32, index: u32, name: cstring, loc := #caller_location) {        impl_BindFragDataLocationIndexed(program, colorNumber, index, name); debug_helper(loc, 0, program, colorNumber, index, name)             }
	GetFragDataIndex            :: proc "c" (program: u32, name: cstring, loc := #caller_location) -> i32                        { ret := impl_GetFragDataIndex(program, name);                                debug_helper(loc, 1, ret, program, name);                return ret }
	GenSamplers                 :: proc "c" (count: i32, samplers: [^]u32, loc := #caller_location)                              {        impl_GenSamplers(count, samplers);                                   debug_helper(loc, 0, count, samplers)                               }
	DeleteSamplers              :: proc "c" (count: i32, samplers: [^]u32, loc := #caller_location)                              {        impl_DeleteSamplers(count, samplers);                                debug_helper(loc, 0, count, samplers)                               }
	IsSampler                   :: proc "c" (sampler: u32, loc := #caller_location) -> bool                                      { ret := impl_IsSampler(sampler);                                             debug_helper(loc, 1, ret, sampler);                      return ret }
	BindSampler                 :: proc "c" (unit: u32, sampler: u32, loc := #caller_location)                                   {        impl_BindSampler(unit, sampler);                                     debug_helper(loc, 0, unit, sampler)                                 }
	SamplerParameteri           :: proc "c" (sampler: u32, pname: u32, param: i32, loc := #caller_location)                      {        impl_SamplerParameteri(sampler, pname, param);                       debug_helper(loc, 0, sampler, pname, param)                         }
	SamplerParameteriv          :: proc "c" (sampler: u32, pname: u32, param: ^i32, loc := #caller_location)                     {        impl_SamplerParameteriv(sampler, pname, param);                      debug_helper(loc, 0, sampler, pname, param)                         }
	SamplerParameterf           :: proc "c" (sampler: u32, pname: u32, param: f32, loc := #caller_location)                      {        impl_SamplerParameterf(sampler, pname, param);                       debug_helper(loc, 0, sampler, pname, param)                         }
	SamplerParameterfv          :: proc "c" (sampler: u32, pname: u32, param: ^f32, loc := #caller_location)                     {        impl_SamplerParameterfv(sampler, pname, param);                      debug_helper(loc, 0, sampler, pname, param)                         }
	SamplerParameterIiv         :: proc "c" (sampler: u32, pname: u32, param: ^i32, loc := #caller_location)                     {        impl_SamplerParameterIiv(sampler, pname, param);                     debug_helper(loc, 0, sampler, pname, param)                         }
	SamplerParameterIuiv        :: proc "c" (sampler: u32, pname: u32, param: ^u32, loc := #caller_location)                     {        impl_SamplerParameterIuiv(sampler, pname, param);                    debug_helper(loc, 0, sampler, pname, param)                         }
	GetSamplerParameteriv       :: proc "c" (sampler: u32, pname: u32, params: [^]i32, loc := #caller_location)                  {        impl_GetSamplerParameteriv(sampler, pname, params);                  debug_helper(loc, 0, sampler, pname, params)                        }
	GetSamplerParameterIiv      :: proc "c" (sampler: u32, pname: u32, params: [^]i32, loc := #caller_location)                  {        impl_GetSamplerParameterIiv(sampler, pname, params);                 debug_helper(loc, 0, sampler, pname, params)                        }
	GetSamplerParameterfv       :: proc "c" (sampler: u32, pname: u32, params: [^]f32, loc := #caller_location)                  {        impl_GetSamplerParameterfv(sampler, pname, params);                  debug_helper(loc, 0, sampler, pname, params)                        }
	GetSamplerParameterIuiv     :: proc "c" (sampler: u32, pname: u32, params: [^]u32, loc := #caller_location)                  {        impl_GetSamplerParameterIuiv(sampler, pname, params);                debug_helper(loc, 0, sampler, pname, params)                        }
	QueryCounter                :: proc "c" (id: u32, target: u32, loc := #caller_location)                                      {        impl_QueryCounter(id, target);                                       debug_helper(loc, 0, id, target)                                    }
	GetQueryObjecti64v          :: proc "c" (id: u32, pname: u32, params: [^]i64, loc := #caller_location)                       {        impl_GetQueryObjecti64v(id, pname, params);                          debug_helper(loc, 0, id, pname, params)                             }
	GetQueryObjectui64v         :: proc "c" (id: u32, pname: u32, params: [^]u64, loc := #caller_location)                       {        impl_GetQueryObjectui64v(id, pname, params);                         debug_helper(loc, 0, id, pname, params)                             }
	VertexAttribDivisor         :: proc "c" (index: u32, divisor: u32, loc := #caller_location)                                  {        impl_VertexAttribDivisor(index, divisor);                            debug_helper(loc, 0, index, divisor)                                }
	VertexAttribP1ui            :: proc "c" (index: u32, type: u32, normalized: bool, value: u32, loc := #caller_location)       {        impl_VertexAttribP1ui(index, type, normalized, value);              debug_helper(loc, 0, index, type, normalized, value)               }
	VertexAttribP1uiv           :: proc "c" (index: u32, type: u32, normalized: bool, value: ^u32, loc := #caller_location)      {        impl_VertexAttribP1uiv(index, type, normalized, value);             debug_helper(loc, 0, index, type, normalized, value)               }
	VertexAttribP2ui            :: proc "c" (index: u32, type: u32, normalized: bool, value: u32, loc := #caller_location)       {        impl_VertexAttribP2ui(index, type, normalized, value);              debug_helper(loc, 0, index, type, normalized, value)               }
	VertexAttribP2uiv           :: proc "c" (index: u32, type: u32, normalized: bool, value: ^u32, loc := #caller_location)      {        impl_VertexAttribP2uiv(index, type, normalized, value);             debug_helper(loc, 0, index, type, normalized, value)               }
	VertexAttribP3ui            :: proc "c" (index: u32, type: u32, normalized: bool, value: u32, loc := #caller_location)       {        impl_VertexAttribP3ui(index, type, normalized, value);              debug_helper(loc, 0, index, type, normalized, value)               }
	VertexAttribP3uiv           :: proc "c" (index: u32, type: u32, normalized: bool, value: ^u32, loc := #caller_location)      {        impl_VertexAttribP3uiv(index, type, normalized, value);             debug_helper(loc, 0, index, type, normalized, value)               }
	VertexAttribP4ui            :: proc "c" (index: u32, type: u32, normalized: bool, value: u32, loc := #caller_location)       {        impl_VertexAttribP4ui(index, type, normalized, value);              debug_helper(loc, 0, index, type, normalized, value)               }
	VertexAttribP4uiv           :: proc "c" (index: u32, type: u32, normalized: bool, value: ^u32, loc := #caller_location)      {        impl_VertexAttribP4uiv(index, type, normalized, value);             debug_helper(loc, 0, index, type, normalized, value)               }
	VertexP2ui                  :: proc "c" (type: u32, value: u32, loc := #caller_location)                                     {        impl_VertexP2ui(type, value);                                       debug_helper(loc, 0, type, value)                                  }
	VertexP2uiv                 :: proc "c" (type: u32, value: ^u32, loc := #caller_location)                                    {        impl_VertexP2uiv(type, value);                                      debug_helper(loc, 0, type, value)                                  }
	VertexP3ui                  :: proc "c" (type: u32, value: u32, loc := #caller_location)                                     {        impl_VertexP3ui(type, value);                                       debug_helper(loc, 0, type, value)                                  }
	VertexP3uiv                 :: proc "c" (type: u32, value: ^u32, loc := #caller_location)                                    {        impl_VertexP3uiv(type, value);                                      debug_helper(loc, 0, type, value)                                  }
	VertexP4ui                  :: proc "c" (type: u32, value: u32, loc := #caller_location)                                     {        impl_VertexP4ui(type, value);                                       debug_helper(loc, 0, type, value)                                  }
	VertexP4uiv                 :: proc "c" (type: u32, value: ^u32, loc := #caller_location)                                    {        impl_VertexP4uiv(type, value);                                      debug_helper(loc, 0, type, value)                                  }
	TexCoordP1ui                :: proc "c" (type: u32, coords: u32, loc := #caller_location)                                    {        impl_TexCoordP1ui(type, coords);                                    debug_helper(loc, 0, type, coords)                                 }
	TexCoordP1uiv               :: proc "c" (type: u32, coords: [^]u32, loc := #caller_location)                                 {        impl_TexCoordP1uiv(type, coords);                                   debug_helper(loc, 0, type, coords)                                 }
	TexCoordP2ui                :: proc "c" (type: u32, coords: u32, loc := #caller_location)                                    {        impl_TexCoordP2ui(type, coords);                                    debug_helper(loc, 0, type, coords)                                 }
	TexCoordP2uiv               :: proc "c" (type: u32, coords: [^]u32, loc := #caller_location)                                 {        impl_TexCoordP2uiv(type, coords);                                   debug_helper(loc, 0, type, coords)                                 }
	TexCoordP3ui                :: proc "c" (type: u32, coords: u32, loc := #caller_location)                                    {        impl_TexCoordP3ui(type, coords);                                    debug_helper(loc, 0, type, coords)                                 }
	TexCoordP3uiv               :: proc "c" (type: u32, coords: [^]u32, loc := #caller_location)                                 {        impl_TexCoordP3uiv(type, coords);                                   debug_helper(loc, 0, type, coords)                                 }
	TexCoordP4ui                :: proc "c" (type: u32, coords: u32, loc := #caller_location)                                    {        impl_TexCoordP4ui(type, coords);                                    debug_helper(loc, 0, type, coords)                                 }
	TexCoordP4uiv               :: proc "c" (type: u32, coords: [^]u32, loc := #caller_location)                                 {        impl_TexCoordP4uiv(type, coords);                                   debug_helper(loc, 0, type, coords)                                 }
	MultiTexCoordP1ui           :: proc "c" (texture: u32, type: u32, coords: u32, loc := #caller_location)                      {        impl_MultiTexCoordP1ui(texture, type, coords);                      debug_helper(loc, 0, texture, type, coords)                        }
	MultiTexCoordP1uiv          :: proc "c" (texture: u32, type: u32, coords: [^]u32, loc := #caller_location)                   {        impl_MultiTexCoordP1uiv(texture, type, coords);                     debug_helper(loc, 0, texture, type, coords)                        }
	MultiTexCoordP2ui           :: proc "c" (texture: u32, type: u32, coords: u32, loc := #caller_location)                      {        impl_MultiTexCoordP2ui(texture, type, coords);                      debug_helper(loc, 0, texture, type, coords)                        }
	MultiTexCoordP2uiv          :: proc "c" (texture: u32, type: u32, coords: [^]u32, loc := #caller_location)                   {        impl_MultiTexCoordP2uiv(texture, type, coords);                     debug_helper(loc, 0, texture, type, coords)                        }
	MultiTexCoordP3ui           :: proc "c" (texture: u32, type: u32, coords: u32, loc := #caller_location)                      {        impl_MultiTexCoordP3ui(texture, type, coords);                      debug_helper(loc, 0, texture, type, coords)                        }
	MultiTexCoordP3uiv          :: proc "c" (texture: u32, type: u32, coords: [^]u32, loc := #caller_location)                   {        impl_MultiTexCoordP3uiv(texture, type, coords);                     debug_helper(loc, 0, texture, type, coords)                        }
	MultiTexCoordP4ui           :: proc "c" (texture: u32, type: u32, coords: u32, loc := #caller_location)                      {        impl_MultiTexCoordP4ui(texture, type, coords);                      debug_helper(loc, 0, texture, type, coords)                        }
	MultiTexCoordP4uiv          :: proc "c" (texture: u32, type: u32, coords: [^]u32, loc := #caller_location)                   {        impl_MultiTexCoordP4uiv(texture, type, coords);                     debug_helper(loc, 0, texture, type, coords)                        }
	NormalP3ui                  :: proc "c" (type: u32, coords: u32, loc := #caller_location)                                    {        impl_NormalP3ui(type, coords);                                      debug_helper(loc, 0, type, coords)                                 }
	NormalP3uiv                 :: proc "c" (type: u32, coords: [^]u32, loc := #caller_location)                                 {        impl_NormalP3uiv(type, coords);                                     debug_helper(loc, 0, type, coords)                                 }
	ColorP3ui                   :: proc "c" (type: u32, color: u32, loc := #caller_location)                                     {        impl_ColorP3ui(type, color);                                        debug_helper(loc, 0, type, color)                                  }
	ColorP3uiv                  :: proc "c" (type: u32, color: ^u32, loc := #caller_location)                                    {        impl_ColorP3uiv(type, color);                                       debug_helper(loc, 0, type, color)                                  }
	ColorP4ui                   :: proc "c" (type: u32, color: u32, loc := #caller_location)                                     {        impl_ColorP4ui(type, color);                                        debug_helper(loc, 0, type, color)                                  }
	ColorP4uiv                  :: proc "c" (type: u32, color: ^u32, loc := #caller_location)                                    {        impl_ColorP4uiv(type, color);                                       debug_helper(loc, 0, type, color)                                  }
	SecondaryColorP3ui          :: proc "c" (type: u32, color: u32, loc := #caller_location)                                     {        impl_SecondaryColorP3ui(type, color);                               debug_helper(loc, 0, type, color)                                  }
	SecondaryColorP3uiv         :: proc "c" (type: u32, color: ^u32, loc := #caller_location)                                    {        impl_SecondaryColorP3uiv(type, color);                              debug_helper(loc, 0, type, color)                                  }

	// VERSION_4_0
	MinSampleShading               :: proc "c" (value: f32, loc := #caller_location)                                                                         {        impl_MinSampleShading(value);                                                            debug_helper(loc, 0, value)                                                          }
	BlendEquationi                 :: proc "c" (buf: u32, mode: u32, loc := #caller_location)                                                                {        impl_BlendEquationi(buf, mode);                                                          debug_helper(loc, 0, buf, mode)                                                      }
	BlendEquationSeparatei         :: proc "c" (buf: u32, modeRGB: u32, modeAlpha: u32, loc := #caller_location)                                             {        impl_BlendEquationSeparatei(buf, modeRGB, modeAlpha);                                    debug_helper(loc, 0, buf, modeRGB, modeAlpha)                                        }
	BlendFunci                     :: proc "c" (buf: u32, src: u32, dst: u32, loc := #caller_location)                                                       {        impl_BlendFunci(buf, src, dst);                                                          debug_helper(loc, 0, buf, src, dst)                                                  }
	BlendFuncSeparatei             :: proc "c" (buf: u32, srcRGB: u32, dstRGB: u32, srcAlpha: u32, dstAlpha: u32, loc := #caller_location)                   {        impl_BlendFuncSeparatei(buf, srcRGB, dstRGB, srcAlpha, dstAlpha);                        debug_helper(loc, 0, buf, srcRGB, dstRGB, srcAlpha, dstAlpha)                        }
	DrawArraysIndirect             :: proc "c" (mode: u32, indirect: ^DrawArraysIndirectCommand, loc := #caller_location)                                    {        impl_DrawArraysIndirect(mode, indirect);                                                 debug_helper(loc, 0, mode, indirect)                                                 }
	DrawElementsIndirect           :: proc "c" (mode: u32, type: u32, indirect: ^DrawElementsIndirectCommand, loc := #caller_location)                       {        impl_DrawElementsIndirect(mode, type, indirect);                                        debug_helper(loc, 0, mode, type, indirect)                                          }
	Uniform1d                      :: proc "c" (location: i32, x: f64, loc := #caller_location)                                                              {        impl_Uniform1d(location, x);                                                             debug_helper(loc, 0, location, x)                                                    }
	Uniform2d                      :: proc "c" (location: i32, x: f64, y: f64, loc := #caller_location)                                                      {        impl_Uniform2d(location, x, y);                                                          debug_helper(loc, 0, location, x, y)                                                 }
	Uniform3d                      :: proc "c" (location: i32, x: f64, y: f64, z: f64, loc := #caller_location)                                              {        impl_Uniform3d(location, x, y, z);                                                       debug_helper(loc, 0, location, x, y, z)                                              }
	Uniform4d                      :: proc "c" (location: i32, x: f64, y: f64, z: f64, w: f64, loc := #caller_location)                                      {        impl_Uniform4d(location, x, y, z, w);                                                    debug_helper(loc, 0, location, x, y, z, w)                                           }
	Uniform1dv                     :: proc "c" (location: i32, count: i32, value: [^]f64, loc := #caller_location)                                           {        impl_Uniform1dv(location, count, value);                                                 debug_helper(loc, 0, location, count, value)                                         }
	Uniform2dv                     :: proc "c" (location: i32, count: i32, value: [^]f64, loc := #caller_location)                                           {        impl_Uniform2dv(location, count, value);                                                 debug_helper(loc, 0, location, count, value)                                         }
	Uniform3dv                     :: proc "c" (location: i32, count: i32, value: [^]f64, loc := #caller_location)                                           {        impl_Uniform3dv(location, count, value);                                                 debug_helper(loc, 0, location, count, value)                                         }
	Uniform4dv                     :: proc "c" (location: i32, count: i32, value: [^]f64, loc := #caller_location)                                           {        impl_Uniform4dv(location, count, value);                                                 debug_helper(loc, 0, location, count, value)                                         }
	UniformMatrix2dv               :: proc "c" (location: i32, count: i32, transpose: bool, value: [^]f64, loc := #caller_location)                          {        impl_UniformMatrix2dv(location, count, transpose, value);                                debug_helper(loc, 0, location, count, transpose, value)                              }
	UniformMatrix3dv               :: proc "c" (location: i32, count: i32, transpose: bool, value: [^]f64, loc := #caller_location)                          {        impl_UniformMatrix3dv(location, count, transpose, value);                                debug_helper(loc, 0, location, count, transpose, value)                              }
	UniformMatrix4dv               :: proc "c" (location: i32, count: i32, transpose: bool, value: [^]f64, loc := #caller_location)                          {        impl_UniformMatrix4dv(location, count, transpose, value);                                debug_helper(loc, 0, location, count, transpose, value)                              }
	UniformMatrix2x3dv             :: proc "c" (location: i32, count: i32, transpose: bool, value: [^]f64, loc := #caller_location)                          {        impl_UniformMatrix2x3dv(location, count, transpose, value);                              debug_helper(loc, 0, location, count, transpose, value)                              }
	UniformMatrix2x4dv             :: proc "c" (location: i32, count: i32, transpose: bool, value: [^]f64, loc := #caller_location)                          {        impl_UniformMatrix2x4dv(location, count, transpose, value);                              debug_helper(loc, 0, location, count, transpose, value)                              }
	UniformMatrix3x2dv             :: proc "c" (location: i32, count: i32, transpose: bool, value: [^]f64, loc := #caller_location)                          {        impl_UniformMatrix3x2dv(location, count, transpose, value);                              debug_helper(loc, 0, location, count, transpose, value)                              }
	UniformMatrix3x4dv             :: proc "c" (location: i32, count: i32, transpose: bool, value: [^]f64, loc := #caller_location)                          {        impl_UniformMatrix3x4dv(location, count, transpose, value);                              debug_helper(loc, 0, location, count, transpose, value)                              }
	UniformMatrix4x2dv             :: proc "c" (location: i32, count: i32, transpose: bool, value: [^]f64, loc := #caller_location)                          {        impl_UniformMatrix4x2dv(location, count, transpose, value);                              debug_helper(loc, 0, location, count, transpose, value)                              }
	UniformMatrix4x3dv             :: proc "c" (location: i32, count: i32, transpose: bool, value: [^]f64, loc := #caller_location)                          {        impl_UniformMatrix4x3dv(location, count, transpose, value);                              debug_helper(loc, 0, location, count, transpose, value)                              }
	GetUniformdv                   :: proc "c" (program: u32, location: i32, params: [^]f64, loc := #caller_location)                                        {        impl_GetUniformdv(program, location, params);                                            debug_helper(loc, 0, program, location, params)                                      }
	GetSubroutineUniformLocation   :: proc "c" (program: u32, shadertype: u32, name: cstring, loc := #caller_location) -> i32                                { ret := impl_GetSubroutineUniformLocation(program, shadertype, name);                           debug_helper(loc, 1, ret, program, shadertype, name);                    return ret }
	GetSubroutineIndex             :: proc "c" (program: u32, shadertype: u32, name: cstring, loc := #caller_location) -> u32                                { ret := impl_GetSubroutineIndex(program, shadertype, name);                                     debug_helper(loc, 1, ret, program, shadertype, name);                    return ret }
	GetActiveSubroutineUniformiv   :: proc "c" (program: u32, shadertype: u32, index: u32, pname: u32, values: [^]i32, loc := #caller_location)              {        impl_GetActiveSubroutineUniformiv(program, shadertype, index, pname, values);           debug_helper(loc, 0, program, shadertype, index, pname, values)                     }
	GetActiveSubroutineUniformName :: proc "c" (program: u32, shadertype: u32, index: u32, bufsize: i32, length: ^i32, name: [^]u8, loc := #caller_location) {        impl_GetActiveSubroutineUniformName(program, shadertype, index, bufsize, length, name); debug_helper(loc, 0, program, shadertype, index, bufsize, length, name)             }
	GetActiveSubroutineName        :: proc "c" (program: u32, shadertype: u32, index: u32, bufsize: i32, length: ^i32, name: [^]u8, loc := #caller_location) {        impl_GetActiveSubroutineName(program, shadertype, index, bufsize, length, name);        debug_helper(loc, 0, program, shadertype, index, bufsize, length, name)             }
	UniformSubroutinesuiv          :: proc "c" (shadertype: u32, count: i32, indices: [^]u32, loc := #caller_location)                                         {        impl_UniformSubroutinesuiv(shadertype, count, indices);                                 debug_helper(loc, 0, shadertype, count, indices)                                    }
	GetUniformSubroutineuiv        :: proc "c" (shadertype: u32, location: i32, params: [^]u32, loc := #caller_location)                                     {        impl_GetUniformSubroutineuiv(shadertype, location, params);                             debug_helper(loc, 0, shadertype, location, params)                                  }
	GetProgramStageiv              :: proc "c" (program: u32, shadertype: u32, pname: u32, values: [^]i32, loc := #caller_location)                          {        impl_GetProgramStageiv(program, shadertype, pname, values);                             debug_helper(loc, 0, program, shadertype, pname, values)                            }
	PatchParameteri                :: proc "c" (pname: u32, value: i32, loc := #caller_location)                                                             {        impl_PatchParameteri(pname, value);                                                      debug_helper(loc, 0, pname, value)                                                   }
	PatchParameterfv               :: proc "c" (pname: u32, values: [^]f32, loc := #caller_location)                                                         {        impl_PatchParameterfv(pname, values);                                                    debug_helper(loc, 0, pname, values)                                                  }
	BindTransformFeedback          :: proc "c" (target: u32, id: u32, loc := #caller_location)                                                               {        impl_BindTransformFeedback(target, id);                                                  debug_helper(loc, 0, target, id)                                                     }
	DeleteTransformFeedbacks       :: proc "c" (n: i32, ids: [^]u32, loc := #caller_location)                                                                {        impl_DeleteTransformFeedbacks(n, ids);                                                   debug_helper(loc, 0, n, ids)                                                         }
	GenTransformFeedbacks          :: proc "c" (n: i32, ids: [^]u32, loc := #caller_location)                                                                {        impl_GenTransformFeedbacks(n, ids);                                                      debug_helper(loc, 0, n, ids)                                                         }
	IsTransformFeedback            :: proc "c" (id: u32, loc := #caller_location) -> bool                                                                    { ret := impl_IsTransformFeedback(id);                                                            debug_helper(loc, 1, ret, id);                                            return ret }
	PauseTransformFeedback         :: proc "c" (loc := #caller_location)                                                                                     {        impl_PauseTransformFeedback();                                                           debug_helper(loc, 0)                                                                 }
	ResumeTransformFeedback        :: proc "c" (loc := #caller_location)                                                                                     {        impl_ResumeTransformFeedback();                                                          debug_helper(loc, 0)                                                                 }
	DrawTransformFeedback          :: proc "c" (mode: u32, id: u32, loc := #caller_location)                                                                 {        impl_DrawTransformFeedback(mode, id);                                                    debug_helper(loc, 0, mode, id)                                                       }
	DrawTransformFeedbackStream    :: proc "c" (mode: u32, id: u32, stream: u32, loc := #caller_location)                                                    {        impl_DrawTransformFeedbackStream(mode, id, stream);                                      debug_helper(loc, 0, mode, id, stream)                                               }
	BeginQueryIndexed              :: proc "c" (target: u32, index: u32, id: u32, loc := #caller_location)                                                   {        impl_BeginQueryIndexed(target, index, id);                                               debug_helper(loc, 0, target, index, id)                                              }
	EndQueryIndexed                :: proc "c" (target: u32, index: u32, loc := #caller_location)                                                            {        impl_EndQueryIndexed(target, index);                                                     debug_helper(loc, 0, target, index)                                                  }
	GetQueryIndexediv              :: proc "c" (target: u32, index: u32, pname: u32, params: [^]i32, loc := #caller_location)                                {        impl_GetQueryIndexediv(target, index, pname, params);                                    debug_helper(loc, 0, target, index, pname, params)                                   }
	GetTextureHandleARB              :: proc "c" (target: u32, loc := #caller_location) -> u64
	{ ret := impl_GetTextureHandleARB(target);   debug_helper(loc, 0, target); return ret }
	GetTextureSamplerHandleARB     :: proc "c" (texture, sampler: u32, loc := #caller_location) -> u64
	{        ret := impl_GetTextureSamplerHandleARB(texture, sampler);   debug_helper(loc, 0, texture, sampler); return ret                                                }
	GetImageHandleARB              :: proc "c" (texture: u32, level: i32, layered: bool, layer: i32, format: u32, loc := #caller_location) -> u64
	{        ret := impl_GetImageHandleARB(texture, level, layered, layer, format);   debug_helper(loc, 0, texture, level, layered, layer, format); return ret                                                }
	MakeTextureHandleResidentARB   :: proc "c" (handle: u64, loc := #caller_location)
	{        impl_MakeTextureHandleResidentARB(handle);   debug_helper(loc, 0, handle)                                                }
	MakeImageHandleResidentARB     :: proc "c" (handle: u64, access: u32, loc := #caller_location)
	{        impl_MakeImageHandleResidentARB(handle, access);   debug_helper(loc, 0, handle, access)                                                }
	MakeTextureHandleNonResidentARB:: proc "c" (handle: u64, loc := #caller_location)
	{        impl_MakeTextureHandleNonResidentARB(handle);   debug_helper(loc, 0, handle)                                                }
	MakeImageHandleNonResidentARB  :: proc "c" (handle: u64, loc := #caller_location)
	{        impl_MakeImageHandleNonResidentARB(handle);   debug_helper(loc, 0, handle)                                                }



	// VERSION_4_1
	ReleaseShaderCompiler     :: proc "c" (loc := #caller_location)                                                                               {        impl_ReleaseShaderCompiler();                                                 debug_helper(loc, 0)                                                             }
	ShaderBinary              :: proc "c" (count: i32, shaders: ^u32, binaryformat: u32, binary: rawptr, length: i32, loc := #caller_location)    {        impl_ShaderBinary(count, shaders, binaryformat, binary, length);              debug_helper(loc, 0, count, shaders, binaryformat, binary, length)               }
	GetShaderPrecisionFormat  :: proc "c" (shadertype: u32, precisiontype: u32, range: ^i32, precision: ^i32, loc := #caller_location)            {        impl_GetShaderPrecisionFormat(shadertype, precisiontype, range, precision); debug_helper(loc, 0, shadertype, precisiontype, range, precision)              }
	DepthRangef               :: proc "c" (n: f32, f: f32, loc := #caller_location)                                                               {        impl_DepthRangef(n, f);                                                       debug_helper(loc, 0, n, f)                                                       }
	ClearDepthf               :: proc "c" (d: f32, loc := #caller_location)                                                                       {        impl_ClearDepthf(d);                                                          debug_helper(loc, 0, d)                                                          }
	GetProgramBinary          :: proc "c" (program: u32, bufSize: i32, length: ^i32, binaryFormat: ^u32, binary: rawptr, loc := #caller_location) {        impl_GetProgramBinary(program, bufSize, length, binaryFormat, binary);        debug_helper(loc, 0, program, bufSize, length, binaryFormat, binary)             }
	ProgramBinary             :: proc "c" (program: u32, binaryFormat: u32, binary: rawptr, length: i32, loc := #caller_location)                 {        impl_ProgramBinary(program, binaryFormat, binary, length);                    debug_helper(loc, 0, program, binaryFormat, binary, length)                      }
	ProgramParameteri         :: proc "c" (program: u32, pname: u32, value: i32, loc := #caller_location)                                         {        impl_ProgramParameteri(program, pname, value);                                debug_helper(loc, 0, program, pname, value)                                      }
	UseProgramStages          :: proc "c" (pipeline: u32, stages: u32, program: u32, loc := #caller_location)                                     {        impl_UseProgramStages(pipeline, stages, program);                             debug_helper(loc, 0, pipeline, stages, program)                                  }
	ActiveShaderProgram       :: proc "c" (pipeline: u32, program: u32, loc := #caller_location)                                                  {        impl_ActiveShaderProgram(pipeline, program);                                  debug_helper(loc, 0, pipeline, program)                                          }
	CreateShaderProgramv      :: proc "c" (type: u32, count: i32, strings: [^]cstring, loc := #caller_location) -> u32                            { ret := impl_CreateShaderProgramv(type, count, strings);                             debug_helper(loc, 1, ret, type, count, strings);                    return ret }
	BindProgramPipeline       :: proc "c" (pipeline: u32, loc := #caller_location)                                                                {        impl_BindProgramPipeline(pipeline);                                           debug_helper(loc, 0, pipeline)                                                   }
	DeleteProgramPipelines    :: proc "c" (n: i32, pipelines: [^]u32, loc := #caller_location)                                                    {        impl_DeleteProgramPipelines(n, pipelines);                                    debug_helper(loc, 0, n, pipelines)                                               }
	GenProgramPipelines       :: proc "c" (n: i32, pipelines: [^]u32, loc := #caller_location)                                                    {        impl_GenProgramPipelines(n, pipelines);                                       debug_helper(loc, 0, n, pipelines)                                               }
	IsProgramPipeline         :: proc "c" (pipeline: u32, loc := #caller_location) -> bool                                                        { ret := impl_IsProgramPipeline(pipeline);                                             debug_helper(loc, 1, ret, pipeline);                                 return ret }
	GetProgramPipelineiv      :: proc "c" (pipeline: u32, pname: u32, params: [^]i32, loc := #caller_location)                                    {        impl_GetProgramPipelineiv(pipeline, pname, params);                           debug_helper(loc, 0, pipeline, pname, params)                                    }
	ProgramUniform1i          :: proc "c" (program: u32, location: i32, v0: i32, loc := #caller_location)                                         {        impl_ProgramUniform1i(program, location, v0);                                 debug_helper(loc, 0, program, location, v0)                                      }
	ProgramUniform1iv         :: proc "c" (program: u32, location: i32, count: i32, value: [^]i32, loc := #caller_location)                       {        impl_ProgramUniform1iv(program, location, count, value);                      debug_helper(loc, 0, program, location, count, value)                            }
	ProgramUniform1f          :: proc "c" (program: u32, location: i32, v0: f32, loc := #caller_location)                                         {        impl_ProgramUniform1f(program, location, v0);                                 debug_helper(loc, 0, program, location, v0)                                      }
	ProgramUniform1fv         :: proc "c" (program: u32, location: i32, count: i32, value: [^]f32, loc := #caller_location)                       {        impl_ProgramUniform1fv(program, location, count, value);                      debug_helper(loc, 0, program, location, count, value)                            }
	ProgramUniform1d          :: proc "c" (program: u32, location: i32, v0: f64, loc := #caller_location)                                         {        impl_ProgramUniform1d(program, location, v0);                                 debug_helper(loc, 0, program, location, v0)                                      }
	ProgramUniform1dv         :: proc "c" (program: u32, location: i32, count: i32, value: [^]f64, loc := #caller_location)                       {        impl_ProgramUniform1dv(program, location, count, value);                      debug_helper(loc, 0, program, location, count, value)                            }
	ProgramUniform1ui         :: proc "c" (program: u32, location: i32, v0: u32, loc := #caller_location)                                         {        impl_ProgramUniform1ui(program, location, v0);                                debug_helper(loc, 0, program, location, v0)                                      }
	ProgramUniform1uiv        :: proc "c" (program: u32, location: i32, count: i32, value: [^]u32, loc := #caller_location)                       {        impl_ProgramUniform1uiv(program, location, count, value);                     debug_helper(loc, 0, program, location, count, value)                            }
	ProgramUniform2i          :: proc "c" (program: u32, location: i32, v0: i32, v1: i32, loc := #caller_location)                                {        impl_ProgramUniform2i(program, location, v0, v1);                             debug_helper(loc, 0, program, location, v0, v1)                                  }
	ProgramUniform2iv         :: proc "c" (program: u32, location: i32, count: i32, value: [^]i32, loc := #caller_location)                       {        impl_ProgramUniform2iv(program, location, count, value);                      debug_helper(loc, 0, program, location, count, value)                            }
	ProgramUniform2f          :: proc "c" (program: u32, location: i32, v0: f32, v1: f32, loc := #caller_location)                                {        impl_ProgramUniform2f(program, location, v0, v1);                             debug_helper(loc, 0, program, location, v0, v1)                                  }
	ProgramUniform2fv         :: proc "c" (program: u32, location: i32, count: i32, value: [^]f32, loc := #caller_location)                       {        impl_ProgramUniform2fv(program, location, count, value);                      debug_helper(loc, 0, program, location, count, value)                            }
	ProgramUniform2d          :: proc "c" (program: u32, location: i32, v0: f64, v1: f64, loc := #caller_location)                                {        impl_ProgramUniform2d(program, location, v0, v1);                             debug_helper(loc, 0, program, location, v0, v1)                                  }
	ProgramUniform2dv         :: proc "c" (program: u32, location: i32, count: i32, value: [^]f64, loc := #caller_location)                       {        impl_ProgramUniform2dv(program, location, count, value);                      debug_helper(loc, 0, program, location, count, value)                            }
	ProgramUniform2ui         :: proc "c" (program: u32, location: i32, v0: u32, v1: u32, loc := #caller_location)                                {        impl_ProgramUniform2ui(program, location, v0, v1);                            debug_helper(loc, 0, program, location, v0, v1)                                  }
	ProgramUniform2uiv        :: proc "c" (program: u32, location: i32, count: i32, value: [^]u32, loc := #caller_location)                       {        impl_ProgramUniform2uiv(program, location, count, value);                     debug_helper(loc, 0, program, location, count, value)                            }
	ProgramUniform3i          :: proc "c" (program: u32, location: i32, v0: i32, v1: i32, v2: i32, loc := #caller_location)                       {        impl_ProgramUniform3i(program, location, v0, v1, v2);                         debug_helper(loc, 0, program, location, v0, v1, v2)                              }
	ProgramUniform3iv         :: proc "c" (program: u32, location: i32, count: i32, value: [^]i32, loc := #caller_location)                       {        impl_ProgramUniform3iv(program, location, count, value);                      debug_helper(loc, 0, program, location, count, value)                            }
	ProgramUniform3f          :: proc "c" (program: u32, location: i32, v0: f32, v1: f32, v2: f32, loc := #caller_location)                       {        impl_ProgramUniform3f(program, location, v0, v1, v2);                         debug_helper(loc, 0, program, location, v0, v1, v2)                              }
	ProgramUniform3fv         :: proc "c" (program: u32, location: i32, count: i32, value: [^]f32, loc := #caller_location)                       {        impl_ProgramUniform3fv(program, location, count, value);                      debug_helper(loc, 0, program, location, count, value)                            }
	ProgramUniform3d          :: proc "c" (program: u32, location: i32, v0: f64, v1: f64, v2: f64, loc := #caller_location)                       {        impl_ProgramUniform3d(program, location, v0, v1, v2);                         debug_helper(loc, 0, program, location, v0, v1, v2)                              }
	ProgramUniform3dv         :: proc "c" (program: u32, location: i32, count: i32, value: [^]f64, loc := #caller_location)                       {        impl_ProgramUniform3dv(program, location, count, value);                      debug_helper(loc, 0, program, location, count, value)                            }
	ProgramUniform3ui         :: proc "c" (program: u32, location: i32, v0: u32, v1: u32, v2: u32, loc := #caller_location)                       {        impl_ProgramUniform3ui(program, location, v0, v1, v2);                        debug_helper(loc, 0, program, location, v0, v1, v2)                              }
	ProgramUniform3uiv        :: proc "c" (program: u32, location: i32, count: i32, value: [^]u32, loc := #caller_location)                       {        impl_ProgramUniform3uiv(program, location, count, value);                     debug_helper(loc, 0, program, location, count, value)                            }
	ProgramUniform4i          :: proc "c" (program: u32, location: i32, v0: i32, v1: i32, v2: i32, v3: i32, loc := #caller_location)              {        impl_ProgramUniform4i(program, location, v0, v1, v2, v3);                     debug_helper(loc, 0, program, location, v0, v1, v2, v3)                          }
	ProgramUniform4iv         :: proc "c" (program: u32, location: i32, count: i32, value: [^]i32, loc := #caller_location)                       {        impl_ProgramUniform4iv(program, location, count, value);                      debug_helper(loc, 0, program, location, count, value)                            }
	ProgramUniform4f          :: proc "c" (program: u32, location: i32, v0: f32, v1: f32, v2: f32, v3: f32, loc := #caller_location)              {        impl_ProgramUniform4f(program, location, v0, v1, v2, v3);                     debug_helper(loc, 0, program, location, v0, v1, v2, v3)                          }
	ProgramUniform4fv         :: proc "c" (program: u32, location: i32, count: i32, value: [^]f32, loc := #caller_location)                       {        impl_ProgramUniform4fv(program, location, count, value);                      debug_helper(loc, 0, program, location, count, value)                            }
	ProgramUniform4d          :: proc "c" (program: u32, location: i32, v0: f64, v1: f64, v2: f64, v3: f64, loc := #caller_location)              {        impl_ProgramUniform4d(program, location, v0, v1, v2, v3);                     debug_helper(loc, 0, program, location, v0, v1, v2, v3)                          }
	ProgramUniform4dv         :: proc "c" (program: u32, location: i32, count: i32, value: [^]f64, loc := #caller_location)                       {        impl_ProgramUniform4dv(program, location, count, value);                      debug_helper(loc, 0, program, location, count, value)                            }
	ProgramUniform4ui         :: proc "c" (program: u32, location: i32, v0: u32, v1: u32, v2: u32, v3: u32, loc := #caller_location)              {        impl_ProgramUniform4ui(program, location, v0, v1, v2, v3);                    debug_helper(loc, 0, program, location, v0, v1, v2, v3)                          }
	ProgramUniform4uiv        :: proc "c" (program: u32, location: i32, count: i32, value: [^]u32, loc := #caller_location)                       {        impl_ProgramUniform4uiv(program, location, count, value);                     debug_helper(loc, 0, program, location, count, value)                            }
	ProgramUniformMatrix2fv   :: proc "c" (program: u32, location: i32, count: i32, transpose: bool, value: [^]f32, loc := #caller_location)      {        impl_ProgramUniformMatrix2fv(program, location, count, transpose, value);     debug_helper(loc, 0, program, location, count, transpose, value)                 }
	ProgramUniformMatrix3fv   :: proc "c" (program: u32, location: i32, count: i32, transpose: bool, value: [^]f32, loc := #caller_location)      {        impl_ProgramUniformMatrix3fv(program, location, count, transpose, value);     debug_helper(loc, 0, program, location, count, transpose, value)                 }
	ProgramUniformMatrix4fv   :: proc "c" (program: u32, location: i32, count: i32, transpose: bool, value: [^]f32, loc := #caller_location)      {        impl_ProgramUniformMatrix4fv(program, location, count, transpose, value);     debug_helper(loc, 0, program, location, count, transpose, value)                 }
	ProgramUniformMatrix2dv   :: proc "c" (program: u32, location: i32, count: i32, transpose: bool, value: [^]f64, loc := #caller_location)      {        impl_ProgramUniformMatrix2dv(program, location, count, transpose, value);     debug_helper(loc, 0, program, location, count, transpose, value)                 }
	ProgramUniformMatrix3dv   :: proc "c" (program: u32, location: i32, count: i32, transpose: bool, value: [^]f64, loc := #caller_location)      {        impl_ProgramUniformMatrix3dv(program, location, count, transpose, value);     debug_helper(loc, 0, program, location, count, transpose, value)                 }
	ProgramUniformMatrix4dv   :: proc "c" (program: u32, location: i32, count: i32, transpose: bool, value: [^]f64, loc := #caller_location)      {        impl_ProgramUniformMatrix4dv(program, location, count, transpose, value);     debug_helper(loc, 0, program, location, count, transpose, value)                 }
	ProgramUniformMatrix2x3fv :: proc "c" (program: u32, location: i32, count: i32, transpose: bool, value: [^]f32, loc := #caller_location)      {        impl_ProgramUniformMatrix2x3fv(program, location, count, transpose, value);   debug_helper(loc, 0, program, location, count, transpose, value)                 }
	ProgramUniformMatrix3x2fv :: proc "c" (program: u32, location: i32, count: i32, transpose: bool, value: [^]f32, loc := #caller_location)      {        impl_ProgramUniformMatrix3x2fv(program, location, count, transpose, value);   debug_helper(loc, 0, program, location, count, transpose, value)                 }
	ProgramUniformMatrix2x4fv :: proc "c" (program: u32, location: i32, count: i32, transpose: bool, value: [^]f32, loc := #caller_location)      {        impl_ProgramUniformMatrix2x4fv(program, location, count, transpose, value);   debug_helper(loc, 0, program, location, count, transpose, value)                 }
	ProgramUniformMatrix4x2fv :: proc "c" (program: u32, location: i32, count: i32, transpose: bool, value: [^]f32, loc := #caller_location)      {        impl_ProgramUniformMatrix4x2fv(program, location, count, transpose, value);   debug_helper(loc, 0, program, location, count, transpose, value)                 }
	ProgramUniformMatrix3x4fv :: proc "c" (program: u32, location: i32, count: i32, transpose: bool, value: [^]f32, loc := #caller_location)      {        impl_ProgramUniformMatrix3x4fv(program, location, count, transpose, value);   debug_helper(loc, 0, program, location, count, transpose, value)                 }
	ProgramUniformMatrix4x3fv :: proc "c" (program: u32, location: i32, count: i32, transpose: bool, value: [^]f32, loc := #caller_location)      {        impl_ProgramUniformMatrix4x3fv(program, location, count, transpose, value);   debug_helper(loc, 0, program, location, count, transpose, value)                 }
	ProgramUniformMatrix2x3dv :: proc "c" (program: u32, location: i32, count: i32, transpose: bool, value: [^]f64, loc := #caller_location)      {        impl_ProgramUniformMatrix2x3dv(program, location, count, transpose, value);   debug_helper(loc, 0, program, location, count, transpose, value)                 }
	ProgramUniformMatrix3x2dv :: proc "c" (program: u32, location: i32, count: i32, transpose: bool, value: [^]f64, loc := #caller_location)      {        impl_ProgramUniformMatrix3x2dv(program, location, count, transpose, value);   debug_helper(loc, 0, program, location, count, transpose, value)                 }
	ProgramUniformMatrix2x4dv :: proc "c" (program: u32, location: i32, count: i32, transpose: bool, value: [^]f64, loc := #caller_location)      {        impl_ProgramUniformMatrix2x4dv(program, location, count, transpose, value);   debug_helper(loc, 0, program, location, count, transpose, value)                 }
	ProgramUniformMatrix4x2dv :: proc "c" (program: u32, location: i32, count: i32, transpose: bool, value: [^]f64, loc := #caller_location)      {        impl_ProgramUniformMatrix4x2dv(program, location, count, transpose, value);   debug_helper(loc, 0, program, location, count, transpose, value)                 }
	ProgramUniformMatrix3x4dv :: proc "c" (program: u32, location: i32, count: i32, transpose: bool, value: [^]f64, loc := #caller_location)      {        impl_ProgramUniformMatrix3x4dv(program, location, count, transpose, value);   debug_helper(loc, 0, program, location, count, transpose, value)                 }
	ProgramUniformMatrix4x3dv :: proc "c" (program: u32, location: i32, count: i32, transpose: bool, value: [^]f64, loc := #caller_location)      {        impl_ProgramUniformMatrix4x3dv(program, location, count, transpose, value);   debug_helper(loc, 0, program, location, count, transpose, value)                 }
	ValidateProgramPipeline   :: proc "c" (pipeline: u32, loc := #caller_location)                                                                {        impl_ValidateProgramPipeline(pipeline);                                       debug_helper(loc, 0, pipeline)                                                   }
	GetProgramPipelineInfoLog :: proc "c" (pipeline: u32, bufSize: i32, length: ^i32, infoLog: [^]u8, loc := #caller_location)                    {        impl_GetProgramPipelineInfoLog(pipeline, bufSize, length, infoLog);           debug_helper(loc, 0, pipeline, bufSize, length, infoLog)                         }
	VertexAttribL1d           :: proc "c" (index: u32, x: f64, loc := #caller_location)                                                           {        impl_VertexAttribL1d(index, x);                                               debug_helper(loc, 0, index, x)                                                   }
	VertexAttribL2d           :: proc "c" (index: u32, x: f64, y: f64, loc := #caller_location)                                                   {        impl_VertexAttribL2d(index, x, y);                                            debug_helper(loc, 0, index, x, y)                                                }
	VertexAttribL3d           :: proc "c" (index: u32, x: f64, y: f64, z: f64, loc := #caller_location)                                           {        impl_VertexAttribL3d(index, x, y, z);                                         debug_helper(loc, 0, index, x, y, z)                                             }
	VertexAttribL4d           :: proc "c" (index: u32, x: f64, y: f64, z: f64, w: f64, loc := #caller_location)                                   {        impl_VertexAttribL4d(index, x, y, z, w);                                      debug_helper(loc, 0, index, x, y, z, w)                                          }
	VertexAttribL1dv          :: proc "c" (index: u32, v: ^f64, loc := #caller_location)                                                          {        impl_VertexAttribL1dv(index, v);                                              debug_helper(loc, 0, index, v)                                                   }
	VertexAttribL2dv          :: proc "c" (index: u32, v: ^[2]f64, loc := #caller_location)                                                          {        impl_VertexAttribL2dv(index, v);                                              debug_helper(loc, 0, index, v)                                                   }
	VertexAttribL3dv          :: proc "c" (index: u32, v: ^[3]f64, loc := #caller_location)                                                          {        impl_VertexAttribL3dv(index, v);                                              debug_helper(loc, 0, index, v)                                                   }
	VertexAttribL4dv          :: proc "c" (index: u32, v: ^[4]f64, loc := #caller_location)                                                          {        impl_VertexAttribL4dv(index, v);                                              debug_helper(loc, 0, index, v)                                                   }
	VertexAttribLPointer      :: proc "c" (index: u32, size: i32, type: u32, stride: i32, pointer: uintptr, loc := #caller_location)               {        impl_VertexAttribLPointer(index, size, type, stride, pointer);               debug_helper(loc, 0, index, size, type, stride, pointer)                        }
	GetVertexAttribLdv        :: proc "c" (index: u32, pname: u32, params: [^]f64, loc := #caller_location)                                       {        impl_GetVertexAttribLdv(index, pname, params);                                debug_helper(loc, 0, index, pname, params)                                       }
	ViewportArrayv            :: proc "c" (first: u32, count: i32, v: [^]f32, loc := #caller_location)                                            {        impl_ViewportArrayv(first, count, v);                                         debug_helper(loc, 0, first, count, v)                                            }
	ViewportIndexedf          :: proc "c" (index: u32, x: f32, y: f32, w: f32, h: f32, loc := #caller_location)                                   {        impl_ViewportIndexedf(index, x, y, w, h);                                     debug_helper(loc, 0, index, x, y, w, h)                                          }
	ViewportIndexedfv         :: proc "c" (index: u32, v: ^[4]f32, loc := #caller_location)                                                          {        impl_ViewportIndexedfv(index, v);                                             debug_helper(loc, 0, index, v)                                                   }
	ScissorArrayv             :: proc "c" (first: u32, count: i32, v: [^]i32, loc := #caller_location)                                            {        impl_ScissorArrayv(first, count, v);                                          debug_helper(loc, 0, first, count, v)                                            }
	ScissorIndexed            :: proc "c" (index: u32, left: i32, bottom: i32, width: i32, height: i32, loc := #caller_location)                  {        impl_ScissorIndexed(index, left, bottom, width, height);                      debug_helper(loc, 0, index, left, bottom, width, height)                         }
	ScissorIndexedv           :: proc "c" (index: u32, v: ^[4]i32, loc := #caller_location)                                                          {        impl_ScissorIndexedv(index, v);                                               debug_helper(loc, 0, index, v)                                                   }
	DepthRangeArrayv          :: proc "c" (first: u32, count: i32, v: [^]f64, loc := #caller_location)                                            {        impl_DepthRangeArrayv(first, count, v);                                       debug_helper(loc, 0, first, count, v)                                            }
	DepthRangeIndexed         :: proc "c" (index: u32, n: f64, f: f64, loc := #caller_location)                                                   {        impl_DepthRangeIndexed(index, n, f);                                          debug_helper(loc, 0, index, n, f)                                                }
	GetFloati_v               :: proc "c" (target: u32, index: u32, data: ^f32, loc := #caller_location)                                          {        impl_GetFloati_v(target, index, data);                                        debug_helper(loc, 0, target, index, data)                                        }
	GetDoublei_v              :: proc "c" (target: u32, index: u32, data: ^f64, loc := #caller_location)                                          {        impl_GetDoublei_v(target, index, data);                                       debug_helper(loc, 0, target, index, data)                                        }

	// VERSION_4_2
	DrawArraysInstancedBaseInstance             :: proc "c" (mode: u32, first: i32, count: i32, instancecount: i32, baseinstance: u32, loc := #caller_location)                                  { impl_DrawArraysInstancedBaseInstance(mode, first, count, instancecount, baseinstance);                                  debug_helper(loc, 0, mode, first, count, instancecount, baseinstance)                      }
	DrawElementsInstancedBaseInstance           :: proc "c" (mode: u32, count: i32, type: u32, indices: rawptr, instancecount: i32, baseinstance: u32, loc := #caller_location)                  { impl_DrawElementsInstancedBaseInstance(mode, count, type, indices, instancecount, baseinstance);                       debug_helper(loc, 0, mode, count, type, indices, instancecount, baseinstance)             }
	DrawElementsInstancedBaseVertexBaseInstance :: proc "c" (mode: u32, count: i32, type: u32, indices: rawptr, instancecount: i32, basevertex: i32, baseinstance: u32, loc := #caller_location) { impl_DrawElementsInstancedBaseVertexBaseInstance(mode, count, type, indices, instancecount, basevertex, baseinstance); debug_helper(loc, 0, mode, count, type, indices, instancecount, basevertex, baseinstance) }
	GetInternalformativ                         :: proc "c" (target: u32, internalformat: u32, pname: u32, bufSize: i32, params: [^]i32, loc := #caller_location)                                { impl_GetInternalformativ(target, internalformat, pname, bufSize, params);                                               debug_helper(loc, 0, target, internalformat, pname, bufSize, params)                       }
	GetActiveAtomicCounterBufferiv              :: proc "c" (program: u32, bufferIndex: u32, pname: u32, params: [^]i32, loc := #caller_location)                                                { impl_GetActiveAtomicCounterBufferiv(program, bufferIndex, pname, params);                                               debug_helper(loc, 0, program, bufferIndex, pname, params)                                  }
	BindImageTexture                            :: proc "c" (unit: u32, texture: u32, level: i32, layered: bool, layer: i32, access: u32, format: u32, loc := #caller_location)                  { impl_BindImageTexture(unit, texture, level, layered, layer, access, format);                                            debug_helper(loc, 0, unit, texture, level, layered, layer, access, format)                 }
	MemoryBarrier                               :: proc "c" (barriers: u32, loc := #caller_location)                                                                                             { impl_MemoryBarrier(barriers);                                                                                           debug_helper(loc, 0, barriers)                                                             }
	TexStorage1D                                :: proc "c" (target: u32, levels: i32, internalformat: u32, width: i32, loc := #caller_location)                                                 { impl_TexStorage1D(target, levels, internalformat, width);                                                               debug_helper(loc, 0, target, levels, internalformat, width)                                }
	TexStorage2D                                :: proc "c" (target: u32, levels: i32, internalformat: u32, width: i32, height: i32, loc := #caller_location)                                    { impl_TexStorage2D(target, levels, internalformat, width, height);                                                       debug_helper(loc, 0, target, levels, internalformat, width, height)                        }
	TexStorage3D                                :: proc "c" (target: u32, levels: i32, internalformat: u32, width: i32, height: i32, depth: i32, loc := #caller_location)                        { impl_TexStorage3D(target, levels, internalformat, width, height, depth);                                                debug_helper(loc, 0, target, levels, internalformat, width, height, depth)                 }
	DrawTransformFeedbackInstanced              :: proc "c" (mode: u32, id: u32, instancecount: i32, loc := #caller_location)                                                                    { impl_DrawTransformFeedbackInstanced(mode, id, instancecount);                                                           debug_helper(loc, 0, mode, id, instancecount)                                              }
	DrawTransformFeedbackStreamInstanced        :: proc "c" (mode: u32, id: u32, stream: u32, instancecount: i32, loc := #caller_location)                                                       { impl_DrawTransformFeedbackStreamInstanced(mode, id, stream, instancecount);                                             debug_helper(loc, 0, mode, id, stream, instancecount)                                      }

	// VERSION_4_3
	ClearBufferData                 :: proc "c" (target: u32, internalformat: u32, format: u32, type: u32, data: rawptr, loc := #caller_location)                                                                                                                                   {        impl_ClearBufferData(target, internalformat, format, type, data);                                                                                    debug_helper(loc, 0, target, internalformat, format, type, data)                                                                                               }
	ClearBufferSubData              :: proc "c" (target: u32, internalformat: u32, offset: int, size: int, format: u32, type: u32, data: rawptr, loc := #caller_location)                                                                                                           {        impl_ClearBufferSubData(target, internalformat, offset, size, format, type, data);                                                                   debug_helper(loc, 0, target, internalformat, offset, size, format, type, data)                                                                                 }
	DispatchCompute                 :: proc "c" (num_groups_x: u32, num_groups_y: u32, num_groups_z: u32, loc := #caller_location)                                                                                                                                                  {        impl_DispatchCompute(num_groups_x, num_groups_y, num_groups_z);                                                                                       debug_helper(loc, 0, num_groups_x, num_groups_y, num_groups_z)                                                                                                  }
	DispatchComputeIndirect         :: proc "c" (indirect: ^DispatchIndirectCommand, loc := #caller_location)                                                                                                                                                                       {        impl_DispatchComputeIndirect(indirect);                                                                                                               debug_helper(loc, 0, indirect)                                                                                                                                  }
	CopyImageSubData                :: proc "c" (srcName: u32, srcTarget: u32, srcLevel: i32, srcX: i32, srcY: i32, srcZ: i32, dstName: u32, dstTarget: u32, dstLevel: i32, dstX: i32, dstY: i32, dstZ: i32, srcWidth: i32, srcHeight: i32, srcDepth: i32, loc := #caller_location) {        impl_CopyImageSubData(srcName, srcTarget, srcLevel, srcX, srcY, srcZ, dstName, dstTarget, dstLevel, dstX, dstY, dstZ, srcWidth, srcHeight, srcDepth); debug_helper(loc, 0, srcName, srcTarget, srcLevel, srcX, srcY, srcZ, dstName, dstTarget, dstLevel, dstX, dstY, dstZ, srcWidth, srcHeight, srcDepth)             }
	FramebufferParameteri           :: proc "c" (target: u32, pname: u32, param: i32, loc := #caller_location)                                                                                                                                                                      {        impl_FramebufferParameteri(target, pname, param);                                                                                                     debug_helper(loc, 0, target, pname, param)                                                                                                                      }
	GetFramebufferParameteriv       :: proc "c" (target: u32, pname: u32, params: [^]i32, loc := #caller_location)                                                                                                                                                                  {        impl_GetFramebufferParameteriv(target, pname, params);                                                                                                debug_helper(loc, 0, target, pname, params)                                                                                                                     }
	GetInternalformati64v           :: proc "c" (target: u32, internalformat: u32, pname: u32, bufSize: i32, params: [^]i64, loc := #caller_location)                                                                                                                               {        impl_GetInternalformati64v(target, internalformat, pname, bufSize, params);                                                                           debug_helper(loc, 0, target, internalformat, pname, bufSize, params)                                                                                            }
	InvalidateTexSubImage           :: proc "c" (texture: u32, level: i32, xoffset: i32, yoffset: i32, zoffset: i32, width: i32, height: i32, depth: i32, loc := #caller_location)                                                                                                  {        impl_InvalidateTexSubImage(texture, level, xoffset, yoffset, zoffset, width, height, depth);                                                          debug_helper(loc, 0, texture, level, xoffset, yoffset, zoffset, width, height, depth)                                                                           }
	InvalidateTexImage              :: proc "c" (texture: u32, level: i32, loc := #caller_location)                                                                                                                                                                                 {        impl_InvalidateTexImage(texture, level);                                                                                                              debug_helper(loc, 0, texture, level)                                                                                                                            }
	InvalidateBufferSubData         :: proc "c" (buffer: u32, offset: int, length: int, loc := #caller_location)                                                                                                                                                                    {        impl_InvalidateBufferSubData(buffer, offset, length);                                                                                                 debug_helper(loc, 0, buffer, offset, length)                                                                                                                    }
	InvalidateBufferData            :: proc "c" (buffer: u32, loc := #caller_location)                                                                                                                                                                                              {        impl_InvalidateBufferData(buffer);                                                                                                                    debug_helper(loc, 0, buffer)                                                                                                                                    }
	InvalidateFramebuffer           :: proc "c" (target: u32, numAttachments: i32, attachments: [^]u32, loc := #caller_location)                                                                                                                                                    {        impl_InvalidateFramebuffer(target, numAttachments, attachments);                                                                                      debug_helper(loc, 0, target, numAttachments, attachments)                                                                                                       }
	InvalidateSubFramebuffer        :: proc "c" (target: u32, numAttachments: i32, attachments: [^]u32, x: i32, y: i32, width: i32, height: i32, loc := #caller_location)                                                                                                           {        impl_InvalidateSubFramebuffer(target, numAttachments, attachments, x, y, width, height);                                                              debug_helper(loc, 0, target, numAttachments, attachments, x, y, width, height)                                                                                  }
	MultiDrawArraysIndirect         :: proc "c" (mode: u32, indirect: [^]DrawArraysIndirectCommand, drawcount: i32, stride: i32, loc := #caller_location)                                                                                                                           {        impl_MultiDrawArraysIndirect(mode, indirect, drawcount, stride);                                                                                      debug_helper(loc, 0, mode, indirect, drawcount, stride)                                                                                                         }
	MultiDrawElementsIndirect       :: proc "c" (mode: u32, type: u32, indirect: [^]DrawElementsIndirectCommand, drawcount: i32, stride: i32, loc := #caller_location)                                                                                                              {        impl_MultiDrawElementsIndirect(mode, type, indirect, drawcount, stride);                                                                             debug_helper(loc, 0, mode, type, indirect, drawcount, stride)                                                                                                  }
	GetProgramInterfaceiv           :: proc "c" (program: u32, programInterface: u32, pname: u32, params: [^]i32, loc := #caller_location)                                                                                                                                          {        impl_GetProgramInterfaceiv(program, programInterface, pname, params);                                                                                 debug_helper(loc, 0, program, programInterface, pname, params)                                                                                                  }
	GetProgramResourceIndex         :: proc "c" (program: u32, programInterface: u32, name: cstring, loc := #caller_location) -> u32                                                                                                                                                { ret := impl_GetProgramResourceIndex(program, programInterface, name);                                                                                        debug_helper(loc, 1, ret, program, programInterface, name);                                                                                          return ret }
	GetProgramResourceName          :: proc "c" (program: u32, programInterface: u32, index: u32, bufSize: i32, length: ^i32, name: [^]u8, loc := #caller_location)                                                                                                                 {        impl_GetProgramResourceName(program, programInterface, index, bufSize, length, name);                                                                 debug_helper(loc, 0, program, programInterface, index, bufSize, length, name)                                                                                   }
	GetProgramResourceiv            :: proc "c" (program: u32, programInterface: u32, index: u32, propCount: i32, props: [^]u32, bufSize: i32, length: ^i32, params: [^]i32, loc := #caller_location)                                                                               {        impl_GetProgramResourceiv(program, programInterface, index, propCount, props, bufSize, length, params);                                               debug_helper(loc, 0, program, programInterface, index, propCount, props, bufSize, length, params)                                                               }
	GetProgramResourceLocation      :: proc "c" (program: u32, programInterface: u32, name: cstring, loc := #caller_location) -> i32                                                                                                                                                { ret := impl_GetProgramResourceLocation(program, programInterface, name);                                                                                     debug_helper(loc, 1, ret, program, programInterface, name);                                                                                          return ret }
	GetProgramResourceLocationIndex :: proc "c" (program: u32, programInterface: u32, name: cstring, loc := #caller_location) -> i32                                                                                                                                                { ret := impl_GetProgramResourceLocationIndex(program, programInterface, name);                                                                                debug_helper(loc, 1, ret, program, programInterface, name);                                                                                          return ret }
	ShaderStorageBlockBinding       :: proc "c" (program: u32, storageBlockIndex: u32, storageBlockBinding: u32, loc := #caller_location)                                                                                                                                           {        impl_ShaderStorageBlockBinding(program, storageBlockIndex, storageBlockBinding);                                                                      debug_helper(loc, 0, program, storageBlockIndex, storageBlockBinding)                                                                                           }
	TexBufferRange                  :: proc "c" (target: u32, internalformat: u32, buffer: u32, offset: int, size: int, loc := #caller_location)                                                                                                                                    {        impl_TexBufferRange(target, internalformat, buffer, offset, size);                                                                                    debug_helper(loc, 0, target, internalformat, buffer, offset, size)                                                                                              }
	TexStorage2DMultisample         :: proc "c" (target: u32, samples: i32, internalformat: u32, width: i32, height: i32, fixedsamplelocations: bool, loc := #caller_location)                                                                                                        {        impl_TexStorage2DMultisample(target, samples, internalformat, width, height, fixedsamplelocations);                                                   debug_helper(loc, 0, target, samples, internalformat, width, height, fixedsamplelocations)                                                                      }
	TexStorage3DMultisample         :: proc "c" (target: u32, samples: i32, internalformat: u32, width: i32, height: i32, depth: i32, fixedsamplelocations: bool, loc := #caller_location)                                                                                            {        impl_TexStorage3DMultisample(target, samples, internalformat, width, height, depth, fixedsamplelocations);                                            debug_helper(loc, 0, target, samples, internalformat, width, height, depth, fixedsamplelocations)                                                               }
	TextureView                     :: proc "c" (texture: u32, target: u32, origtexture: u32, internalformat: u32, minlevel: u32, numlevels: u32, minlayer: u32, numlayers: u32, loc := #caller_location)                                                                           {        impl_TextureView(texture, target, origtexture, internalformat, minlevel, numlevels, minlayer, numlayers);                                             debug_helper(loc, 0, texture, target, origtexture, internalformat, minlevel, numlevels, minlayer, numlayers)                                                    }
	BindVertexBuffer                :: proc "c" (bindingindex: u32, buffer: u32, offset: int, stride: i32, loc := #caller_location)                                                                                                                                                 {        impl_BindVertexBuffer(bindingindex, buffer, offset, stride);                                                                                          debug_helper(loc, 0, bindingindex, buffer, offset, stride)                                                                                                      }
	VertexAttribFormat              :: proc "c" (attribindex: u32, size: i32, type: u32, normalized: bool, relativeoffset: u32, loc := #caller_location)                                                                                                                            {        impl_VertexAttribFormat(attribindex, size, type, normalized, relativeoffset);                                                                        debug_helper(loc, 0, attribindex, size, type, normalized, relativeoffset)                                                                                      }
	VertexAttribIFormat             :: proc "c" (attribindex: u32, size: i32, type: u32, relativeoffset: u32, loc := #caller_location)                                                                                                                                              {        impl_VertexAttribIFormat(attribindex, size, type, relativeoffset);                                                                                   debug_helper(loc, 0, attribindex, size, type, relativeoffset)                                                                                                  }
	VertexAttribLFormat             :: proc "c" (attribindex: u32, size: i32, type: u32, relativeoffset: u32, loc := #caller_location)                                                                                                                                              {        impl_VertexAttribLFormat(attribindex, size, type, relativeoffset);                                                                                   debug_helper(loc, 0, attribindex, size, type, relativeoffset)                                                                                                  }
	VertexAttribBinding             :: proc "c" (attribindex: u32, bindingindex: u32, loc := #caller_location)                                                                                                                                                                      {        impl_VertexAttribBinding(attribindex, bindingindex);                                                                                                  debug_helper(loc, 0, attribindex, bindingindex)                                                                                                                 }
	VertexBindingDivisor            :: proc "c" (bindingindex: u32, divisor: u32, loc := #caller_location)                                                                                                                                                                          {        impl_VertexBindingDivisor(bindingindex, divisor);                                                                                                     debug_helper(loc, 0, bindingindex, divisor)                                                                                                                     }
	DebugMessageControl             :: proc "c" (source: u32, type: u32, severity: u32, count: i32, ids: [^]u32, enabled: bool, loc := #caller_location)                                                                                                                              {        impl_DebugMessageControl(source, type, severity, count, ids, enabled);                                                                               debug_helper(loc, 0, source, type, severity, count, ids, enabled)                                                                                              }
	DebugMessageInsert              :: proc "c" (source: u32, type: u32, id: u32, severity: u32, length: i32, message: cstring, loc := #caller_location)                                                                                                                                    {        impl_DebugMessageInsert(source, type, id, severity, length, message);                                                                                    debug_helper(loc, 0, source, type, id, severity, length, message)                                                                                                  }
	DebugMessageCallback            :: proc "c" (callback: debug_proc_t, userParam: rawptr, loc := #caller_location)                                                                                                                                                                {        impl_DebugMessageCallback(callback, userParam);                                                                                                       debug_helper(loc, 0, callback, userParam)                                                                                                                       }
	GetDebugMessageLog              :: proc "c" (count: u32, bufSize: i32, sources: [^]u32, types: [^]u32, ids: [^]u32, severities: [^]u32, lengths: [^]i32, messageLog: [^]u8, loc := #caller_location) -> u32                                                                     { ret := impl_GetDebugMessageLog(count, bufSize, sources, types, ids, severities, lengths, messageLog);                                                        debug_helper(loc, 1, ret, count, bufSize, sources, types, ids, severities, lengths, messageLog);                                                     return ret }
	PushDebugGroup                  :: proc "c" (source: u32, id: u32, length: i32, message: cstring, loc := #caller_location)                                                                                                                                                      {        impl_PushDebugGroup(source, id, length, message);                                                                                                     debug_helper(loc, 0, source, id, length, message)                                                                                                               }
	PopDebugGroup                   :: proc "c" (loc := #caller_location)                                                                                                                                                                                                           {        impl_PopDebugGroup();                                                                                                                                 debug_helper(loc, 0)                                                                                                                                            }
	ObjectLabel                     :: proc "c" (identifier: u32, name: u32, length: i32, label: cstring, loc := #caller_location)                                                                                                                                                    {        impl_ObjectLabel(identifier, name, length, label);                                                                                                    debug_helper(loc, 0, identifier, name, length, label)                                                                                                           }
	GetObjectLabel                  :: proc "c" (identifier: u32, name: u32, bufSize: i32, length: ^i32, label: [^]u8, loc := #caller_location)                                                                                                                                     {        impl_GetObjectLabel(identifier, name, bufSize, length, label);                                                                                        debug_helper(loc, 0, identifier, name, bufSize, length, label)                                                                                                  }
	ObjectPtrLabel                  :: proc "c" (ptr: rawptr, length: i32, label: cstring, loc := #caller_location)                                                                                                                                                                   {        impl_ObjectPtrLabel(ptr, length, label);                                                                                                              debug_helper(loc, 0, ptr, length, label)                                                                                                                        }
	GetObjectPtrLabel               :: proc "c" (ptr: rawptr, bufSize: i32, length: ^i32, label: [^]u8, loc := #caller_location)                                                                                                                                                    {        impl_GetObjectPtrLabel(ptr, bufSize, length, label);                                                                                                  debug_helper(loc, 0, ptr, bufSize, length, label)                                                                                                               }

	// VERSION_4_4
	BufferStorage     :: proc "c" (target: u32, size: int, data: rawptr, flags: u32, loc := #caller_location)                                                                                              { impl_BufferStorage(target, size, data, flags);                                                               debug_helper(loc, 0, target, size, data, flags)                                                            }
	ClearTexImage     :: proc "c" (texture: u32, level: i32, format: u32, type: u32, data: rawptr, loc := #caller_location)                                                                                { impl_ClearTexImage(texture, level, format, type, data);                                                     debug_helper(loc, 0, texture, level, format, type, data)                                                  }
	ClearTexSubImage  :: proc "c" (texture: u32, level: i32, xoffset: i32, yoffset: i32, zoffset: i32, width: i32, height: i32, depth: i32, format: u32, type: u32, data: rawptr, loc := #caller_location) { impl_ClearTexSubImage(texture, level, xoffset, yoffset, zoffset, width, height, depth, format, type, data); debug_helper(loc, 0, texture, level, xoffset, yoffset, zoffset, width, height, depth, format, type, data) }
	BindBuffersBase   :: proc "c" (target: u32, first: u32, count: i32, buffers: [^]u32, loc := #caller_location)                                                                                          { impl_BindBuffersBase(target, first, count, buffers);                                                         debug_helper(loc, 0, target, first, count, buffers)                                                        }
	BindBuffersRange  :: proc "c" (target: u32, first: u32, count: i32, buffers: [^]u32, offsets: [^]uintptr, sizes: [^]int, loc := #caller_location)                                                      { impl_BindBuffersRange(target, first, count, buffers, offsets, sizes);                                        debug_helper(loc, 0, target, first, count, buffers, offsets, sizes)                                        }
	BindTextures      :: proc "c" (first: u32, count: i32, textures: [^]u32, loc := #caller_location)                                                                                                      { impl_BindTextures(first, count, textures);                                                                   debug_helper(loc, 0, first, count, textures)                                                               }
	BindSamplers      :: proc "c" (first: u32, count: i32, samplers: [^]u32, loc := #caller_location)                                                                                                      { impl_BindSamplers(first, count, samplers);                                                                   debug_helper(loc, 0, first, count, samplers)                                                               }
	BindImageTextures :: proc "c" (first: u32, count: i32, textures: [^]u32, loc := #caller_location)                                                                                                      { impl_BindImageTextures(first, count, textures);                                                              debug_helper(loc, 0, first, count, textures)                                                               }
	BindVertexBuffers :: proc "c" (first: u32, count: i32, buffers: [^]u32, offsets: [^]uintptr, strides: [^]i32, loc := #caller_location)                                                                 { impl_BindVertexBuffers(first, count, buffers, offsets, strides);                                             debug_helper(loc, 0, first, count, buffers, offsets, strides)                                              }

	// VERSION_4_5
	ClipControl                              :: proc "c" (origin: u32, depth: u32, loc := #caller_location)                                                                                                                                            {        impl_ClipControl(origin, depth);                                                                                                   debug_helper(loc, 0, origin, depth)                                                                                                      }
	CreateTransformFeedbacks                 :: proc "c" (n: i32, ids: [^]u32, loc := #caller_location)                                                                                                                                                {        impl_CreateTransformFeedbacks(n, ids);                                                                                             debug_helper(loc, 0, n, ids)                                                                                                             }
	TransformFeedbackBufferBase              :: proc "c" (xfb: u32, index: u32, buffer: u32, loc := #caller_location)                                                                                                                                  {        impl_TransformFeedbackBufferBase(xfb, index, buffer);                                                                              debug_helper(loc, 0, xfb, index, buffer)                                                                                                 }
	TransformFeedbackBufferRange             :: proc "c" (xfb: u32, index: u32, buffer: u32, offset: int, size: int, loc := #caller_location)                                                                                                          {        impl_TransformFeedbackBufferRange(xfb, index, buffer, offset, size);                                                               debug_helper(loc, 0, xfb, index, buffer, offset, size)                                                                                   }
	GetTransformFeedbackiv                   :: proc "c" (xfb: u32, pname: u32, param: ^i32, loc := #caller_location)                                                                                                                                  {        impl_GetTransformFeedbackiv(xfb, pname, param);                                                                                    debug_helper(loc, 0, xfb, pname, param)                                                                                                  }
	GetTransformFeedbacki_v                  :: proc "c" (xfb: u32, pname: u32, index: u32, param: ^i32, loc := #caller_location)                                                                                                                      {        impl_GetTransformFeedbacki_v(xfb, pname, index, param);                                                                            debug_helper(loc, 0, xfb, pname, index, param)                                                                                           }
	GetTransformFeedbacki64_v                :: proc "c" (xfb: u32, pname: u32, index: u32, param: ^i64, loc := #caller_location)                                                                                                                      {        impl_GetTransformFeedbacki64_v(xfb, pname, index, param);                                                                          debug_helper(loc, 0, xfb, pname, index, param)                                                                                           }
	CreateBuffers                            :: proc "c" (n: i32, buffers: [^]u32, loc := #caller_location)                                                                                                                                            {        impl_CreateBuffers(n, buffers);                                                                                                    debug_helper(loc, 0, n, buffers)                                                                                                         }
	NamedBufferStorage                       :: proc "c" (buffer: u32, size: int, data: rawptr, flags: u32, loc := #caller_location)                                                                                                                   {        impl_NamedBufferStorage(buffer, size, data, flags);                                                                                debug_helper(loc, 0, buffer, size, data, flags)                                                                                          }
	NamedBufferData                          :: proc "c" (buffer: u32, size: int, data: rawptr, usage: u32, loc := #caller_location)                                                                                                                   {        impl_NamedBufferData(buffer, size, data, usage);                                                                                   debug_helper(loc, 0, buffer, size, data, usage)                                                                                          }
	NamedBufferSubData                       :: proc "c" (buffer: u32, offset: int, size: int, data: rawptr, loc := #caller_location)                                                                                                                  {        impl_NamedBufferSubData(buffer, offset, size, data);                                                                               debug_helper(loc, 0, buffer, offset, size, data)                                                                                         }
	CopyNamedBufferSubData                   :: proc "c" (readBuffer: u32, writeBuffer: u32, readOffset: int, writeOffset: int, size: int, loc := #caller_location)                                                                                    {        impl_CopyNamedBufferSubData(readBuffer, writeBuffer, readOffset, writeOffset, size);                                               debug_helper(loc, 0, readBuffer, writeBuffer, readOffset, writeOffset, size)                                                             }
	ClearNamedBufferData                     :: proc "c" (buffer: u32, internalformat: u32, format: u32, type: u32, data: rawptr, loc := #caller_location)                                                                                             {        impl_ClearNamedBufferData(buffer, internalformat, format, type, data);                                                            debug_helper(loc, 0, buffer, internalformat, format, type, data)                                                                        }
	ClearNamedBufferSubData                  :: proc "c" (buffer: u32, internalformat: u32, offset: int, size: int, format: u32, type: u32, data: rawptr, loc := #caller_location)                                                                     {        impl_ClearNamedBufferSubData(buffer, internalformat, offset, size, format, type, data);                                           debug_helper(loc, 0, buffer, internalformat, offset, size, format, type, data)                                                          }
	MapNamedBuffer                           :: proc "c" (buffer: u32, access: u32, loc := #caller_location) -> rawptr                                                                                                                                 { ret := impl_MapNamedBuffer(buffer, access);                                                                                               debug_helper(loc, 1, ret, buffer, access);                                                                                    return ret }
	MapNamedBufferRange                      :: proc "c" (buffer: u32, offset: int, length: int, access: u32, loc := #caller_location) -> rawptr                                                                                                       { ret := impl_MapNamedBufferRange(buffer, offset, length, access);                                                                          debug_helper(loc, 1, ret, buffer, offset, length, access);                                                                    return ret }
	UnmapNamedBuffer                         :: proc "c" (buffer: u32, loc := #caller_location) -> bool                                                                                                                                                { ret := impl_UnmapNamedBuffer(buffer);                                                                                                     debug_helper(loc, 1, ret, buffer);                                                                                            return ret }
	FlushMappedNamedBufferRange              :: proc "c" (buffer: u32, offset: int, length: int, loc := #caller_location)                                                                                                                              {        impl_FlushMappedNamedBufferRange(buffer, offset, length);                                                                          debug_helper(loc, 0, buffer, offset, length)                                                                                             }
	GetNamedBufferParameteriv                :: proc "c" (buffer: u32, pname: u32, params: [^]i32, loc := #caller_location)                                                                                                                            {        impl_GetNamedBufferParameteriv(buffer, pname, params);                                                                             debug_helper(loc, 0, buffer, pname, params)                                                                                              }
	GetNamedBufferParameteri64v              :: proc "c" (buffer: u32, pname: u32, params: [^]i64, loc := #caller_location)                                                                                                                            {        impl_GetNamedBufferParameteri64v(buffer, pname, params);                                                                           debug_helper(loc, 0, buffer, pname, params)                                                                                              }
	GetNamedBufferPointerv                   :: proc "c" (buffer: u32, pname: u32, params: [^]rawptr, loc := #caller_location)                                                                                                                         {        impl_GetNamedBufferPointerv(buffer, pname, params);                                                                                debug_helper(loc, 0, buffer, pname, params)                                                                                              }
	GetNamedBufferSubData                    :: proc "c" (buffer: u32, offset: int, size: int, data: rawptr, loc := #caller_location)                                                                                                                  {        impl_GetNamedBufferSubData(buffer, offset, size, data);                                                                            debug_helper(loc, 0, buffer, offset, size, data)                                                                                         }
	CreateFramebuffers                       :: proc "c" (n: i32, framebuffers: [^]u32, loc := #caller_location)                                                                                                                                       {        impl_CreateFramebuffers(n, framebuffers);                                                                                          debug_helper(loc, 0, n, framebuffers)                                                                                                    }
	NamedFramebufferRenderbuffer             :: proc "c" (framebuffer: u32, attachment: u32, renderbuffertarget: u32, renderbuffer: u32, loc := #caller_location)                                                                                      {        impl_NamedFramebufferRenderbuffer(framebuffer, attachment, renderbuffertarget, renderbuffer);                                      debug_helper(loc, 0, framebuffer, attachment, renderbuffertarget, renderbuffer)                                                          }
	NamedFramebufferParameteri               :: proc "c" (framebuffer: u32, pname: u32, param: i32, loc := #caller_location)                                                                                                                           {        impl_NamedFramebufferParameteri(framebuffer, pname, param);                                                                        debug_helper(loc, 0, framebuffer, pname, param)                                                                                          }
	NamedFramebufferTexture                  :: proc "c" (framebuffer: u32, attachment: u32, texture: u32, level: i32, loc := #caller_location)                                                                                                        {        impl_NamedFramebufferTexture(framebuffer, attachment, texture, level);                                                             debug_helper(loc, 0, framebuffer, attachment, texture, level)                                                                            }
	NamedFramebufferTextureLayer             :: proc "c" (framebuffer: u32, attachment: u32, texture: u32, level: i32, layer: i32, loc := #caller_location)                                                                                            {        impl_NamedFramebufferTextureLayer(framebuffer, attachment, texture, level, layer);                                                 debug_helper(loc, 0, framebuffer, attachment, texture, level, layer)                                                                     }
	NamedFramebufferDrawBuffer               :: proc "c" (framebuffer: u32, buf: u32, loc := #caller_location)                                                                                                                                         {        impl_NamedFramebufferDrawBuffer(framebuffer, buf);                                                                                 debug_helper(loc, 0, framebuffer, buf)                                                                                                   }
	NamedFramebufferDrawBuffers              :: proc "c" (framebuffer: u32, n: i32, bufs: [^]u32, loc := #caller_location)                                                                                                                             {        impl_NamedFramebufferDrawBuffers(framebuffer, n, bufs);                                                                            debug_helper(loc, 0, framebuffer, n, bufs)                                                                                               }
	NamedFramebufferReadBuffer               :: proc "c" (framebuffer: u32, src: u32, loc := #caller_location)                                                                                                                                         {        impl_NamedFramebufferReadBuffer(framebuffer, src);                                                                                 debug_helper(loc, 0, framebuffer, src)                                                                                                   }
	InvalidateNamedFramebufferData           :: proc "c" (framebuffer: u32, numAttachments: i32, attachments: [^]u32, loc := #caller_location)                                                                                                           {        impl_InvalidateNamedFramebufferData(framebuffer, numAttachments, attachments);                                                     debug_helper(loc, 0, framebuffer, numAttachments, attachments)                                                                           }
	InvalidateNamedFramebufferSubData        :: proc "c" (framebuffer: u32, numAttachments: i32, attachments: [^]u32, x: i32, y: i32, width: i32, height: i32, loc := #caller_location)                                                                  {        impl_InvalidateNamedFramebufferSubData(framebuffer, numAttachments, attachments, x, y, width, height);                             debug_helper(loc, 0, framebuffer, numAttachments, attachments, x, y, width, height)                                                      }
	ClearNamedFramebufferiv                  :: proc "c" (framebuffer: u32, buffer: u32, drawbuffer: i32, value: ^i32, loc := #caller_location)                                                                                                        {        impl_ClearNamedFramebufferiv(framebuffer, buffer, drawbuffer, value);                                                              debug_helper(loc, 0, framebuffer, buffer, drawbuffer, value)                                                                             }
	ClearNamedFramebufferuiv                 :: proc "c" (framebuffer: u32, buffer: u32, drawbuffer: i32, value: ^u32, loc := #caller_location)                                                                                                        {        impl_ClearNamedFramebufferuiv(framebuffer, buffer, drawbuffer, value);                                                             debug_helper(loc, 0, framebuffer, buffer, drawbuffer, value)                                                                             }
	ClearNamedFramebufferfv                  :: proc "c" (framebuffer: u32, buffer: u32, drawbuffer: i32, value: ^f32, loc := #caller_location)                                                                                                        {        impl_ClearNamedFramebufferfv(framebuffer, buffer, drawbuffer, value);                                                              debug_helper(loc, 0, framebuffer, buffer, drawbuffer, value)                                                                             }
	ClearNamedFramebufferfi                  :: proc "c" (framebuffer: u32, buffer: u32, drawbuffer: i32, depth: f32, stencil: i32, loc := #caller_location)                                                                                           {        impl_ClearNamedFramebufferfi(framebuffer, buffer, drawbuffer, depth, stencil);                                                     debug_helper(loc, 0, framebuffer, buffer, drawbuffer, depth, stencil)                                                                    }
	BlitNamedFramebuffer                     :: proc "c" (readFramebuffer: u32, drawFramebuffer: u32, srcX0: i32, srcY0: i32, srcX1: i32, srcY1: i32, dstX0: i32, dstY0: i32, dstX1: i32, dstY1: i32, mask: u32, filter: u32, loc := #caller_location) {        impl_BlitNamedFramebuffer(readFramebuffer, drawFramebuffer, srcX0, srcY0, srcX1, srcY1, dstX0, dstY0, dstX1, dstY1, mask, filter); debug_helper(loc, 0, readFramebuffer, drawFramebuffer, srcX0, srcY0, srcX1, srcY1, dstX0, dstY0, dstX1, dstY1, mask, filter)             }
	CheckNamedFramebufferStatus              :: proc "c" (framebuffer: u32, target: u32, loc := #caller_location) -> u32                                                                                                                               { ret := impl_CheckNamedFramebufferStatus(framebuffer, target);                                                                             debug_helper(loc, 1, ret, framebuffer, target); return ret                                                                               }
	GetNamedFramebufferParameteriv           :: proc "c" (framebuffer: u32, pname: u32, param: ^i32, loc := #caller_location)                                                                                                                          {        impl_GetNamedFramebufferParameteriv(framebuffer, pname, param);                                                                    debug_helper(loc, 0, framebuffer, pname, param)                                                                                          }
	GetNamedFramebufferAttachmentParameteriv :: proc "c" (framebuffer: u32, attachment: u32, pname: u32, params: [^]i32, loc := #caller_location)                                                                                                      {        impl_GetNamedFramebufferAttachmentParameteriv(framebuffer, attachment, pname, params);                                             debug_helper(loc, 0, framebuffer, attachment, pname, params)                                                                             }
	CreateRenderbuffers                      :: proc "c" (n: i32, renderbuffers: [^]u32, loc := #caller_location)                                                                                                                                      {        impl_CreateRenderbuffers(n, renderbuffers);                                                                                        debug_helper(loc, 0, n, renderbuffers)                                                                                                   }
	NamedRenderbufferStorage                 :: proc "c" (renderbuffer: u32, internalformat: u32, width: i32, height: i32, loc := #caller_location)                                                                                                    {        impl_NamedRenderbufferStorage(renderbuffer, internalformat, width, height);                                                        debug_helper(loc, 0, renderbuffer, internalformat, width, height)                                                                        }
	NamedRenderbufferStorageMultisample      :: proc "c" (renderbuffer: u32, samples: i32, internalformat: u32, width: i32, height: i32, loc := #caller_location)                                                                                      {        impl_NamedRenderbufferStorageMultisample(renderbuffer, samples, internalformat, width, height);                                    debug_helper(loc, 0, renderbuffer, samples, internalformat, width, height)                                                               }
	GetNamedRenderbufferParameteriv          :: proc "c" (renderbuffer: u32, pname: u32, params: [^]i32, loc := #caller_location)                                                                                                                      {        impl_GetNamedRenderbufferParameteriv(renderbuffer, pname, params);                                                                 debug_helper(loc, 0, renderbuffer, pname, params)                                                                                        }
	CreateTextures                           :: proc "c" (target: u32, n: i32, textures: [^]u32, loc := #caller_location)                                                                                                                              {        impl_CreateTextures(target, n, textures);                                                                                          debug_helper(loc, 0, target, n, textures)                                                                                                }
	TextureBuffer                            :: proc "c" (texture: u32, internalformat: u32, buffer: u32, loc := #caller_location)                                                                                                                     {        impl_TextureBuffer(texture, internalformat, buffer);                                                                               debug_helper(loc, 0, texture, internalformat, buffer)                                                                                    }
	TextureBufferRange                       :: proc "c" (texture: u32, internalformat: u32, buffer: u32, offset: int, size: int, loc := #caller_location)                                                                                             {        impl_TextureBufferRange(texture, internalformat, buffer, offset, size);                                                            debug_helper(loc, 0, texture, internalformat, buffer, offset, size)                                                                      }
	TextureStorage1D                         :: proc "c" (texture: u32, levels: i32, internalformat: u32, width: i32, loc := #caller_location)                                                                                                         {        impl_TextureStorage1D(texture, levels, internalformat, width);                                                                     debug_helper(loc, 0, texture, levels, internalformat, width)                                                                             }
	TextureStorage2D                         :: proc "c" (texture: u32, levels: i32, internalformat: u32, width: i32, height: i32, loc := #caller_location)                                                                                            {        impl_TextureStorage2D(texture, levels, internalformat, width, height);                                                             debug_helper(loc, 0, texture, levels, internalformat, width, height)                                                                     }
	TextureStorage3D                         :: proc "c" (texture: u32, levels: i32, internalformat: u32, width: i32, height: i32, depth: i32, loc := #caller_location)                                                                                {        impl_TextureStorage3D(texture, levels, internalformat, width, height, depth);                                                      debug_helper(loc, 0, texture, levels, internalformat, width, height, depth)                                                              }
	TextureStorage2DMultisample              :: proc "c" (texture: u32, samples: i32, internalformat: u32, width: i32, height: i32, fixedsamplelocations: bool, loc := #caller_location)                                                                 {        impl_TextureStorage2DMultisample(texture, samples, internalformat, width, height, fixedsamplelocations);                           debug_helper(loc, 0, texture, samples, internalformat, width, height, fixedsamplelocations)                                              }
	TextureStorage3DMultisample              :: proc "c" (texture: u32, samples: i32, internalformat: u32, width: i32, height: i32, depth: i32, fixedsamplelocations: bool, loc := #caller_location)                                                     {        impl_TextureStorage3DMultisample(texture, samples, internalformat, width, height, depth, fixedsamplelocations);                    debug_helper(loc, 0, texture, samples, internalformat, width, height, depth, fixedsamplelocations)                                       }
	TextureSubImage1D                        :: proc "c" (texture: u32, level: i32, xoffset: i32, width: i32, format: u32, type: u32, pixels: rawptr, loc := #caller_location)                                                                         {        impl_TextureSubImage1D(texture, level, xoffset, width, format, type, pixels);                                                     debug_helper(loc, 0, texture, level, xoffset, width, format, type, pixels)                                                              }
	TextureSubImage2D                        :: proc "c" (texture: u32, level: i32, xoffset: i32, yoffset: i32, width: i32, height: i32, format: u32, type: u32, pixels: rawptr, loc := #caller_location)                                              {        impl_TextureSubImage2D(texture, level, xoffset, yoffset, width, height, format, type, pixels);                                    debug_helper(loc, 0, texture, level, xoffset, yoffset, width, height, format, type, pixels)                                             }
	TextureSubImage3D                        :: proc "c" (texture: u32, level: i32, xoffset: i32, yoffset: i32, zoffset: i32, width: i32, height: i32, depth: i32, format: u32, type: u32, pixels: rawptr, loc := #caller_location)                    {        impl_TextureSubImage3D(texture, level, xoffset, yoffset, zoffset, width, height, depth, format, type, pixels);                    debug_helper(loc, 0, texture, level, xoffset, yoffset, zoffset, width, height, depth, format, type, pixels)                             }
	CompressedTextureSubImage1D              :: proc "c" (texture: u32, level: i32, xoffset: i32, width: i32, format: u32, imageSize: i32, data: rawptr, loc := #caller_location)                                                                      {        impl_CompressedTextureSubImage1D(texture, level, xoffset, width, format, imageSize, data);                                         debug_helper(loc, 0, texture, level, xoffset, width, format, imageSize, data)                                                            }
	CompressedTextureSubImage2D              :: proc "c" (texture: u32, level: i32, xoffset: i32, yoffset: i32, width: i32, height: i32, format: u32, imageSize: i32, data: rawptr, loc := #caller_location)                                           {        impl_CompressedTextureSubImage2D(texture, level, xoffset, yoffset, width, height, format, imageSize, data);                        debug_helper(loc, 0, texture, level, xoffset, yoffset, width, height, format, imageSize, data)                                           }
	CompressedTextureSubImage3D              :: proc "c" (texture: u32, level: i32, xoffset: i32, yoffset: i32, zoffset: i32, width: i32, height: i32, depth: i32, format: u32, imageSize: i32, data: rawptr, loc := #caller_location)                 {        impl_CompressedTextureSubImage3D(texture, level, xoffset, yoffset, zoffset, width, height, depth, format, imageSize, data);        debug_helper(loc, 0, texture, level, xoffset, yoffset, zoffset, width, height, depth, format, imageSize, data)                           }
	CopyTextureSubImage1D                    :: proc "c" (texture: u32, level: i32, xoffset: i32, x: i32, y: i32, width: i32, loc := #caller_location)                                                                                                 {        impl_CopyTextureSubImage1D(texture, level, xoffset, x, y, width);                                                                  debug_helper(loc, 0, texture, level, xoffset, x, y, width)                                                                               }
	CopyTextureSubImage2D                    :: proc "c" (texture: u32, level: i32, xoffset: i32, yoffset: i32, x: i32, y: i32, width: i32, height: i32, loc := #caller_location)                                                                      {        impl_CopyTextureSubImage2D(texture, level, xoffset, yoffset, x, y, width, height);                                                 debug_helper(loc, 0, texture, level, xoffset, yoffset, x, y, width, height)                                                              }
	CopyTextureSubImage3D                    :: proc "c" (texture: u32, level: i32, xoffset: i32, yoffset: i32, zoffset: i32, x: i32, y: i32, width: i32, height: i32, loc := #caller_location)                                                        {        impl_CopyTextureSubImage3D(texture, level, xoffset, yoffset, zoffset, x, y, width, height);                                        debug_helper(loc, 0, texture, level, xoffset, yoffset, zoffset, x, y, width, height)                                                     }
	TextureParameterf                        :: proc "c" (texture: u32, pname: u32, param: f32, loc := #caller_location)                                                                                                                               {        impl_TextureParameterf(texture, pname, param);                                                                                     debug_helper(loc, 0, texture, pname, param)                                                                                              }
	TextureParameterfv                       :: proc "c" (texture: u32, pname: u32, param: ^f32, loc := #caller_location)                                                                                                                              {        impl_TextureParameterfv(texture, pname, param);                                                                                    debug_helper(loc, 0, texture, pname, param)                                                                                              }
	TextureParameteri                        :: proc "c" (texture: u32, pname: u32, param: i32, loc := #caller_location)                                                                                                                               {        impl_TextureParameteri(texture, pname, param);                                                                                     debug_helper(loc, 0, texture, pname, param)                                                                                              }
	TextureParameterIiv                      :: proc "c" (texture: u32, pname: u32, params: [^]i32, loc := #caller_location)                                                                                                                           {        impl_TextureParameterIiv(texture, pname, params);                                                                                  debug_helper(loc, 0, texture, pname, params)                                                                                             }
	TextureParameterIuiv                     :: proc "c" (texture: u32, pname: u32, params: [^]u32, loc := #caller_location)                                                                                                                           {        impl_TextureParameterIuiv(texture, pname, params);                                                                                 debug_helper(loc, 0, texture, pname, params)                                                                                             }
	TextureParameteriv                       :: proc "c" (texture: u32, pname: u32, param: ^i32, loc := #caller_location)                                                                                                                              {        impl_TextureParameteriv(texture, pname, param);                                                                                    debug_helper(loc, 0, texture, pname, param)                                                                                              }
	GenerateTextureMipmap                    :: proc "c" (texture: u32, loc := #caller_location)                                                                                                                                                       {        impl_GenerateTextureMipmap(texture);                                                                                               debug_helper(loc, 0, texture)                                                                                                            }
	BindTextureUnit                          :: proc "c" (unit: u32, texture: u32, loc := #caller_location)                                                                                                                                            {        impl_BindTextureUnit(unit, texture);                                                                                               debug_helper(loc, 0, unit, texture)                                                                                                      }
	GetTextureImage                          :: proc "c" (texture: u32, level: i32, format: u32, type: u32, bufSize: i32, pixels: rawptr, loc := #caller_location)                                                                                     {        impl_GetTextureImage(texture, level, format, type, bufSize, pixels);                                                              debug_helper(loc, 0, texture, level, format, type, bufSize, pixels)                                                                     }
	GetCompressedTextureImage                :: proc "c" (texture: u32, level: i32, bufSize: i32, pixels: rawptr, loc := #caller_location)                                                                                                             {        impl_GetCompressedTextureImage(texture, level, bufSize, pixels);                                                                   debug_helper(loc, 0, texture, level, bufSize, pixels)                                                                                    }
	GetTextureLevelParameterfv               :: proc "c" (texture: u32, level: i32, pname: u32, params: [^]f32, loc := #caller_location)                                                                                                               {        impl_GetTextureLevelParameterfv(texture, level, pname, params);                                                                    debug_helper(loc, 0, texture, level, pname, params)                                                                                      }
	GetTextureLevelParameteriv               :: proc "c" (texture: u32, level: i32, pname: u32, params: [^]i32, loc := #caller_location)                                                                                                               {        impl_GetTextureLevelParameteriv(texture, level, pname, params);                                                                    debug_helper(loc, 0, texture, level, pname, params)                                                                                      }
	GetTextureParameterfv                    :: proc "c" (texture: u32, pname: u32, params: [^]f32, loc := #caller_location)                                                                                                                           {        impl_GetTextureParameterfv(texture, pname, params);                                                                                debug_helper(loc, 0, texture, pname, params)                                                                                             }
	GetTextureParameterIiv                   :: proc "c" (texture: u32, pname: u32, params: [^]i32, loc := #caller_location)                                                                                                                           {        impl_GetTextureParameterIiv(texture, pname, params);                                                                               debug_helper(loc, 0, texture, pname, params)                                                                                             }
	GetTextureParameterIuiv                  :: proc "c" (texture: u32, pname: u32, params: [^]u32, loc := #caller_location)                                                                                                                           {        impl_GetTextureParameterIuiv(texture, pname, params);                                                                              debug_helper(loc, 0, texture, pname, params)                                                                                             }
	GetTextureParameteriv                    :: proc "c" (texture: u32, pname: u32, params: [^]i32, loc := #caller_location)                                                                                                                           {        impl_GetTextureParameteriv(texture, pname, params);                                                                                debug_helper(loc, 0, texture, pname, params)                                                                                             }
	CreateVertexArrays                       :: proc "c" (n: i32, arrays: [^]u32, loc := #caller_location)                                                                                                                                             {        impl_CreateVertexArrays(n, arrays);                                                                                                debug_helper(loc, 0, n, arrays)                                                                                                          }
	DisableVertexArrayAttrib                 :: proc "c" (vaobj: u32, index: u32, loc := #caller_location)                                                                                                                                             {        impl_DisableVertexArrayAttrib(vaobj, index);                                                                                       debug_helper(loc, 0, vaobj, index)                                                                                                       }
	EnableVertexArrayAttrib                  :: proc "c" (vaobj: u32, index: u32, loc := #caller_location)                                                                                                                                             {        impl_EnableVertexArrayAttrib(vaobj, index);                                                                                        debug_helper(loc, 0, vaobj, index)                                                                                                       }
	VertexArrayElementBuffer                 :: proc "c" (vaobj: u32, buffer: u32, loc := #caller_location)                                                                                                                                            {        impl_VertexArrayElementBuffer(vaobj, buffer);                                                                                      debug_helper(loc, 0, vaobj, buffer)                                                                                                      }
	VertexArrayVertexBuffer                  :: proc "c" (vaobj: u32, bindingindex: u32, buffer: u32, offset: int, stride: i32, loc := #caller_location)                                                                                               {        impl_VertexArrayVertexBuffer(vaobj, bindingindex, buffer, offset, stride);                                                         debug_helper(loc, 0, vaobj, bindingindex, buffer, offset, stride)                                                                        }
	VertexArrayVertexBuffers                 :: proc "c" (vaobj: u32, first: u32, count: i32, buffers: [^]u32, offsets: [^]uintptr, strides: [^]i32, loc := #caller_location)                                                                          {        impl_VertexArrayVertexBuffers(vaobj, first, count, buffers, offsets, strides);                                                     debug_helper(loc, 0, vaobj, first, count, buffers, offsets, strides)                                                                     }
	VertexArrayAttribBinding                 :: proc "c" (vaobj: u32, attribindex: u32, bindingindex: u32, loc := #caller_location)                                                                                                                    {        impl_VertexArrayAttribBinding(vaobj, attribindex, bindingindex);                                                                   debug_helper(loc, 0, vaobj, attribindex, bindingindex)                                                                                   }
	VertexArrayAttribFormat                  :: proc "c" (vaobj: u32, attribindex: u32, size: i32, type: u32, normalized: bool, relativeoffset: u32, loc := #caller_location)                                                                          {        impl_VertexArrayAttribFormat(vaobj, attribindex, size, type, normalized, relativeoffset);                                         debug_helper(loc, 0, vaobj, attribindex, size, type, normalized, relativeoffset)                                                        }
	VertexArrayAttribIFormat                 :: proc "c" (vaobj: u32, attribindex: u32, size: i32, type: u32, relativeoffset: u32, loc := #caller_location)                                                                                            {        impl_VertexArrayAttribIFormat(vaobj, attribindex, size, type, relativeoffset);                                                    debug_helper(loc, 0, vaobj, attribindex, size, type, relativeoffset)                                                                    }
	VertexArrayAttribLFormat                 :: proc "c" (vaobj: u32, attribindex: u32, size: i32, type: u32, relativeoffset: u32, loc := #caller_location)                                                                                            {        impl_VertexArrayAttribLFormat(vaobj, attribindex, size, type, relativeoffset);                                                    debug_helper(loc, 0, vaobj, attribindex, size, type, relativeoffset)                                                                    }
	VertexArrayBindingDivisor                :: proc "c" (vaobj: u32, bindingindex: u32, divisor: u32, loc := #caller_location)                                                                                                                        {        impl_VertexArrayBindingDivisor(vaobj, bindingindex, divisor);                                                                      debug_helper(loc, 0, vaobj, bindingindex, divisor)                                                                                       }
	GetVertexArrayiv                         :: proc "c" (vaobj: u32, pname: u32, param: ^i32, loc := #caller_location)                                                                                                                                {        impl_GetVertexArrayiv(vaobj, pname, param);                                                                                        debug_helper(loc, 0, vaobj, pname, param)                                                                                                }
	GetVertexArrayIndexediv                  :: proc "c" (vaobj: u32, index: u32, pname: u32, param: ^i32, loc := #caller_location)                                                                                                                    {        impl_GetVertexArrayIndexediv(vaobj, index, pname, param);                                                                          debug_helper(loc, 0, vaobj, index, pname, param)                                                                                         }
	GetVertexArrayIndexed64iv                :: proc "c" (vaobj: u32, index: u32, pname: u32, param: ^i64, loc := #caller_location)                                                                                                                    {        impl_GetVertexArrayIndexed64iv(vaobj, index, pname, param);                                                                        debug_helper(loc, 0, vaobj, index, pname, param)                                                                                         }
	CreateSamplers                           :: proc "c" (n: i32, samplers: [^]u32, loc := #caller_location)                                                                                                                                           {        impl_CreateSamplers(n, samplers);                                                                                                  debug_helper(loc, 0, n, samplers)                                                                                                        }
	CreateProgramPipelines                   :: proc "c" (n: i32, pipelines: [^]u32, loc := #caller_location)                                                                                                                                          {        impl_CreateProgramPipelines(n, pipelines);                                                                                         debug_helper(loc, 0, n, pipelines)                                                                                                       }
	CreateQueries                            :: proc "c" (target: u32, n: i32, ids: [^]u32, loc := #caller_location)                                                                                                                                   {        impl_CreateQueries(target, n, ids);                                                                                                debug_helper(loc, 0, target, n, ids)                                                                                                     }
	GetQueryBufferObjecti64v                 :: proc "c" (id: u32, buffer: u32, pname: u32, offset: int, loc := #caller_location)                                                                                                                      {        impl_GetQueryBufferObjecti64v(id, buffer, pname, offset);                                                                          debug_helper(loc, 0, id, buffer, pname, offset)                                                                                          }
	GetQueryBufferObjectiv                   :: proc "c" (id: u32, buffer: u32, pname: u32, offset: int, loc := #caller_location)                                                                                                                      {        impl_GetQueryBufferObjectiv(id, buffer, pname, offset);                                                                            debug_helper(loc, 0, id, buffer, pname, offset)                                                                                          }
	GetQueryBufferObjectui64v                :: proc "c" (id: u32, buffer: u32, pname: u32, offset: int, loc := #caller_location)                                                                                                                      {        impl_GetQueryBufferObjectui64v(id, buffer, pname, offset);                                                                         debug_helper(loc, 0, id, buffer, pname, offset)                                                                                          }
	GetQueryBufferObjectuiv                  :: proc "c" (id: u32, buffer: u32, pname: u32, offset: int, loc := #caller_location)                                                                                                                      {        impl_GetQueryBufferObjectuiv(id, buffer, pname, offset);                                                                           debug_helper(loc, 0, id, buffer, pname, offset)                                                                                          }
	MemoryBarrierByRegion                    :: proc "c" (barriers: u32, loc := #caller_location)                                                                                                                                                      {        impl_MemoryBarrierByRegion(barriers);                                                                                              debug_helper(loc, 0, barriers)                                                                                                           }
	GetTextureSubImage                       :: proc "c" (texture: u32, level: i32, xoffset: i32, yoffset: i32, zoffset: i32, width: i32, height: i32, depth: i32, format: u32, type: u32, bufSize: i32, pixels: rawptr, loc := #caller_location)      {        impl_GetTextureSubImage(texture, level, xoffset, yoffset, zoffset, width, height, depth, format, type, bufSize, pixels);          debug_helper(loc, 0, texture, level, xoffset, yoffset, zoffset, width, height, depth, format, type, bufSize, pixels)                    }
	GetCompressedTextureSubImage             :: proc "c" (texture: u32, level: i32, xoffset: i32, yoffset: i32, zoffset: i32, width: i32, height: i32, depth: i32, bufSize: i32, pixels: rawptr, loc := #caller_location)                              {        impl_GetCompressedTextureSubImage(texture, level, xoffset, yoffset, zoffset, width, height, depth, bufSize, pixels);               debug_helper(loc, 0, texture, level, xoffset, yoffset, zoffset, width, height, depth, bufSize, pixels)                                   }
	GetGraphicsResetStatus                   :: proc "c" (loc := #caller_location) -> u32                                                                                                                                                              { ret := impl_GetGraphicsResetStatus();                                                                                                     debug_helper(loc, 1, ret);                                                                                                    return ret }
	GetnCompressedTexImage                   :: proc "c" (target: u32, lod: i32, bufSize: i32, pixels: rawptr, loc := #caller_location)                                                                                                                {        impl_GetnCompressedTexImage(target, lod, bufSize, pixels);                                                                         debug_helper(loc, 0, target, lod, bufSize, pixels)                                                                                       }
	GetnTexImage                             :: proc "c" (target: u32, level: i32, format: u32, type: u32, bufSize: i32, pixels: rawptr, loc := #caller_location)                                                                                      {        impl_GetnTexImage(target, level, format, type, bufSize, pixels);                                                                  debug_helper(loc, 0, target, level, format, type, bufSize, pixels)                                                                      }
	GetnUniformdv                            :: proc "c" (program: u32, location: i32, bufSize: i32, params: [^]f64, loc := #caller_location)                                                                                                          {        impl_GetnUniformdv(program, location, bufSize, params);                                                                            debug_helper(loc, 0, program, location, bufSize, params)                                                                                 }
	GetnUniformfv                            :: proc "c" (program: u32, location: i32, bufSize: i32, params: [^]f32, loc := #caller_location)                                                                                                          {        impl_GetnUniformfv(program, location, bufSize, params);                                                                            debug_helper(loc, 0, program, location, bufSize, params)                                                                                 }
	GetnUniformiv                            :: proc "c" (program: u32, location: i32, bufSize: i32, params: [^]i32, loc := #caller_location)                                                                                                          {        impl_GetnUniformiv(program, location, bufSize, params);                                                                            debug_helper(loc, 0, program, location, bufSize, params)                                                                                 }
	GetnUniformuiv                           :: proc "c" (program: u32, location: i32, bufSize: i32, params: [^]u32, loc := #caller_location)                                                                                                          {        impl_GetnUniformuiv(program, location, bufSize, params);                                                                           debug_helper(loc, 0, program, location, bufSize, params)                                                                                 }
	ReadnPixels                              :: proc "c" (x: i32, y: i32, width: i32, height: i32, format: u32, type: u32, bufSize: i32, data: rawptr, loc := #caller_location)                                                                        {        impl_ReadnPixels(x, y, width, height, format, type, bufSize, data);                                                               debug_helper(loc, 0, x, y, width, height, format, type, bufSize, data)                                                                  }
	GetnMapdv                                :: proc "c" (target: u32, query: u32, bufSize: i32, v: [^]f64, loc := #caller_location)                                                                                                                     {        impl_GetnMapdv(target, query, bufSize, v);                                                                                         debug_helper(loc, 0, target, query, bufSize, v)                                                                                          }
	GetnMapfv                                :: proc "c" (target: u32, query: u32, bufSize: i32, v: [^]f32, loc := #caller_location)                                                                                                                     {        impl_GetnMapfv(target, query, bufSize, v);                                                                                         debug_helper(loc, 0, target, query, bufSize, v)                                                                                          }
	GetnMapiv                                :: proc "c" (target: u32, query: u32, bufSize: i32, v: [^]i32, loc := #caller_location)                                                                                                                     {        impl_GetnMapiv(target, query, bufSize, v);                                                                                         debug_helper(loc, 0, target, query, bufSize, v)                                                                                          }
	GetnPixelMapusv                          :: proc "c" (map_: u32, bufSize: i32, values: [^]u16, loc := #caller_location)                                                                                                                            {        impl_GetnPixelMapusv(map_, bufSize, values);                                                                                       debug_helper(loc, 0, map_, bufSize, values)                                                                                              }
	GetnPixelMapfv                           :: proc "c" (map_: u32, bufSize: i32, values: [^]f32, loc := #caller_location)                                                                                                                            {        impl_GetnPixelMapfv(map_, bufSize, values);                                                                                        debug_helper(loc, 0, map_, bufSize, values)                                                                                              }
	GetnPixelMapuiv                          :: proc "c" (map_: u32, bufSize: i32, values: [^]u32, loc := #caller_location)                                                                                                                            {        impl_GetnPixelMapuiv(map_, bufSize, values);                                                                                       debug_helper(loc, 0, map_, bufSize, values)                                                                                              }
	GetnPolygonStipple                       :: proc "c" (bufSize: i32, pattern: [^]u8, loc := #caller_location)                                                                                                                                         {        impl_GetnPolygonStipple(bufSize, pattern);                                                                                         debug_helper(loc, 0, bufSize, pattern)                                                                                                   }
	GetnColorTable                           :: proc "c" (target: u32, format: u32, type: u32, bufSize: i32, table: rawptr, loc := #caller_location)                                                                                                   {        impl_GetnColorTable(target, format, type, bufSize, table);                                                                        debug_helper(loc, 0, target, format, type, bufSize, table)                                                                                }
	GetnConvolutionFilter                    :: proc "c" (target: u32, format: u32, type: u32, bufSize: i32, image: rawptr, loc := #caller_location)                                                                                                   {        impl_GetnConvolutionFilter(target, format, type, bufSize, image);                                                                 debug_helper(loc, 0, target, format, type, bufSize, image)                                                                                }
	GetnSeparableFilter                      :: proc "c" (target: u32, format: u32, type: u32, rowBufSize: i32, row: rawptr, columnBufSize: i32, column: rawptr, span: rawptr, loc := #caller_location)                                                {        impl_GetnSeparableFilter(target, format, type, rowBufSize, row, columnBufSize, column, span);                                     debug_helper(loc, 0, target, format, type, rowBufSize, row, columnBufSize, column, span)                                                  }
	GetnHistogram                            :: proc "c" (target: u32, reset: bool, format: u32, type: u32, bufSize: i32, values: rawptr, loc := #caller_location)                                                                                     {        impl_GetnHistogram(target, reset, format, type, bufSize, values);                                                                 debug_helper(loc, 0, target, reset, format, type, bufSize, values)                                                                        }
	GetnMinmax                               :: proc "c" (target: u32, reset: bool, format: u32, type: u32, bufSize: i32, values: rawptr, loc := #caller_location)                                                                                     {        impl_GetnMinmax(target, reset, format, type, bufSize, values);                                                                    debug_helper(loc, 0, target, reset, format, type, bufSize, values)                                                                        }
	TextureBarrier                           :: proc "c" (loc := #caller_location)                                                                                                                                                                     {        impl_TextureBarrier();                                                                                                             debug_helper(loc, 0)                                                                                                                     }
	GetUnsignedBytevEXT                      :: proc "c" (pname: u32, data: ^byte, loc := #caller_location)                                                                                                                                            {        impl_GetUnsignedBytevEXT(pname, data);                                                                                             debug_helper(loc, 0, pname, data)                                                                                                        }
	TexPageCommitmentARB                     :: proc "c"(target: u32, level: i32, xoffset: i32, yoffset: i32, zoffset: i32, width: i32, height: i32, depth: i32, commit: bool, loc := #caller_location) { impl_TexPageCommitmentARB(target, level, xoffset, yoffset, zoffset, width, height, depth, commit); debug_helper(loc, 0, target, level, xoffset, yoffset, zoffset, width, height, depth, commit) }
	
	// VERSION_4_6
	SpecializeShader               :: proc "c" (shader: u32, pEntryPoint: cstring, numSpecializationConstants: u32, pConstantIndex: ^u32, pConstantValue: ^u32, loc := #caller_location) { impl_SpecializeShader(shader, pEntryPoint, numSpecializationConstants, pConstantIndex, pConstantValue); debug_helper(loc, 0, shader, pEntryPoint, numSpecializationConstants, pConstantIndex, pConstantValue) }
	MultiDrawArraysIndirectCount   :: proc "c" (mode: i32, indirect: [^]DrawArraysIndirectCommand, drawcount: i32, maxdrawcount, stride: i32, loc := #caller_location)                   { impl_MultiDrawArraysIndirectCount(mode, indirect, drawcount, maxdrawcount, stride);                     debug_helper(loc, 0, mode, indirect, drawcount, maxdrawcount, stride)                                 }
	MultiDrawElementsIndirectCount :: proc "c" (mode: i32, type: i32, indirect: [^]DrawElementsIndirectCommand, drawcount: i32, maxdrawcount, stride: i32, loc := #caller_location)      { impl_MultiDrawElementsIndirectCount(mode, type, indirect, drawcount, maxdrawcount, stride);             debug_helper(loc, 0, mode, type, indirect, drawcount, maxdrawcount, stride)                           }
	PolygonOffsetClamp             :: proc "c" (factor, units, clamp: f32, loc := #caller_location)                                                                                      { impl_PolygonOffsetClamp(factor, units, clamp);                                                          debug_helper(loc, 0, factor, units, clamp)                                                            }
}
