bindings to GLEW library (with manual alterations)

glew_bindings.scala

package glew

import _root_.scala.scalanative.unsafe.*
import _root_.scala.scalanative.unsigned.*
import _root_.scala.scalanative.libc.*
import _root_.scala.scalanative.*

object aliases:
  import _root_.glew.aliases.*
  import _root_.glew.structs.*
  opaque type GLDEBUGPROC = CFuncPtr7[GLenum, GLenum, GLuint, GLenum, GLsizei, Ptr[GLchar], Ptr[Byte], Unit]
  object GLDEBUGPROC:
    given _tag: Tag[GLDEBUGPROC] = Tag.materializeCFuncPtr7[GLenum, GLenum, GLuint, GLenum, GLsizei, Ptr[GLchar], Ptr[Byte], Unit]
    inline def fromPtr(ptr: Ptr[Byte] | Ptr[?]): GLDEBUGPROC = CFuncPtr.fromPtr(ptr.asInstanceOf[Ptr[Byte]])
    inline def apply(inline o: CFuncPtr7[GLenum, GLenum, GLuint, GLenum, GLsizei, Ptr[GLchar], Ptr[Byte], Unit]): GLDEBUGPROC = o
    extension (v: GLDEBUGPROC)
      inline def value: CFuncPtr7[GLenum, GLenum, GLuint, GLenum, GLsizei, Ptr[GLchar], Ptr[Byte], Unit] = v
      inline def toPtr: Ptr[?] = CFuncPtr.toPtr(v)

  opaque type GLDEBUGPROCAMD = CFuncPtr6[GLuint, GLenum, GLenum, GLsizei, Ptr[GLchar], Ptr[Byte], Unit]
  object GLDEBUGPROCAMD:
    given _tag: Tag[GLDEBUGPROCAMD] = Tag.materializeCFuncPtr6[GLuint, GLenum, GLenum, GLsizei, Ptr[GLchar], Ptr[Byte], Unit]
    inline def fromPtr(ptr: Ptr[Byte] | Ptr[?]): GLDEBUGPROCAMD = CFuncPtr.fromPtr(ptr.asInstanceOf[Ptr[Byte]])
    inline def apply(inline o: CFuncPtr6[GLuint, GLenum, GLenum, GLsizei, Ptr[GLchar], Ptr[Byte], Unit]): GLDEBUGPROCAMD = o
    extension (v: GLDEBUGPROCAMD)
      inline def value: CFuncPtr6[GLuint, GLenum, GLenum, GLsizei, Ptr[GLchar], Ptr[Byte], Unit] = v
      inline def toPtr: Ptr[?] = CFuncPtr.toPtr(v)

  opaque type GLDEBUGPROCARB = CFuncPtr7[GLenum, GLenum, GLuint, GLenum, GLsizei, Ptr[GLchar], Ptr[Byte], Unit]
  object GLDEBUGPROCARB:
    given _tag: Tag[GLDEBUGPROCARB] = Tag.materializeCFuncPtr7[GLenum, GLenum, GLuint, GLenum, GLsizei, Ptr[GLchar], Ptr[Byte], Unit]
    inline def fromPtr(ptr: Ptr[Byte] | Ptr[?]): GLDEBUGPROCARB = CFuncPtr.fromPtr(ptr.asInstanceOf[Ptr[Byte]])
    inline def apply(inline o: CFuncPtr7[GLenum, GLenum, GLuint, GLenum, GLsizei, Ptr[GLchar], Ptr[Byte], Unit]): GLDEBUGPROCARB = o
    extension (v: GLDEBUGPROCARB)
      inline def value: CFuncPtr7[GLenum, GLenum, GLuint, GLenum, GLsizei, Ptr[GLchar], Ptr[Byte], Unit] = v
      inline def toPtr: Ptr[?] = CFuncPtr.toPtr(v)

  opaque type GLLOGPROCREGAL = CFuncPtr4[GLenum, GLsizei, Ptr[GLchar], Ptr[Byte], Unit]
  object GLLOGPROCREGAL:
    given _tag: Tag[GLLOGPROCREGAL] = Tag.materializeCFuncPtr4[GLenum, GLsizei, Ptr[GLchar], Ptr[Byte], Unit]
    inline def fromPtr(ptr: Ptr[Byte] | Ptr[?]): GLLOGPROCREGAL = CFuncPtr.fromPtr(ptr.asInstanceOf[Ptr[Byte]])
    inline def apply(inline o: CFuncPtr4[GLenum, GLsizei, Ptr[GLchar], Ptr[Byte], Unit]): GLLOGPROCREGAL = o
    extension (v: GLLOGPROCREGAL)
      inline def value: CFuncPtr4[GLenum, GLsizei, Ptr[GLchar], Ptr[Byte], Unit] = v
      inline def toPtr: Ptr[?] = CFuncPtr.toPtr(v)

  opaque type GLVULKANPROCNV = CFuncPtr0[Unit]
  object GLVULKANPROCNV:
    given _tag: Tag[GLVULKANPROCNV] = Tag.materializeCFuncPtr0[Unit]
    inline def fromPtr(ptr: Ptr[Byte] | Ptr[?]): GLVULKANPROCNV = CFuncPtr.fromPtr(ptr.asInstanceOf[Ptr[Byte]])
    inline def apply(inline o: CFuncPtr0[Unit]): GLVULKANPROCNV = o
    extension (v: GLVULKANPROCNV)
      inline def value: CFuncPtr0[Unit] = v
      inline def toPtr: Ptr[?] = CFuncPtr.toPtr(v)

  opaque type GLbitfield = CUnsignedInt
  object GLbitfield:
    given _tag: Tag[GLbitfield] = Tag.UInt
    inline def apply(inline o: CUnsignedInt): GLbitfield = o
    extension (v: GLbitfield)
      inline def value: CUnsignedInt = v

  opaque type GLboolean = CUnsignedChar
  object GLboolean:
    given _tag: Tag[GLboolean] = Tag.UByte
    inline def apply(inline o: CUnsignedChar): GLboolean = o
    extension (v: GLboolean)
      inline def value: CUnsignedChar = v

  opaque type GLbyte = CChar
  object GLbyte:
    given _tag: Tag[GLbyte] = Tag.Byte
    inline def apply(inline o: CChar): GLbyte = o
    extension (v: GLbyte)
      inline def value: CChar = v

  opaque type GLchar = CChar
  object GLchar:
    given _tag: Tag[GLchar] = Tag.Byte
    inline def apply(inline o: CChar): GLchar = o
    extension (v: GLchar)
      inline def value: CChar = v

  opaque type GLcharARB = CChar
  object GLcharARB:
    given _tag: Tag[GLcharARB] = Tag.Byte
    inline def apply(inline o: CChar): GLcharARB = o
    extension (v: GLcharARB)
      inline def value: CChar = v

  opaque type GLclampd = Double
  object GLclampd:
    given _tag: Tag[GLclampd] = Tag.Double
    inline def apply(inline o: Double): GLclampd = o
    extension (v: GLclampd)
      inline def value: Double = v

  opaque type GLclampf = Float
  object GLclampf:
    given _tag: Tag[GLclampf] = Tag.Float
    inline def apply(inline o: Float): GLclampf = o
    extension (v: GLclampf)
      inline def value: Float = v

  opaque type GLclampx = CInt
  object GLclampx:
    given _tag: Tag[GLclampx] = Tag.Int
    inline def apply(inline o: CInt): GLclampx = o
    extension (v: GLclampx)
      inline def value: CInt = v

  opaque type GLdouble = Double
  object GLdouble:
    given _tag: Tag[GLdouble] = Tag.Double
    inline def apply(inline o: Double): GLdouble = o
    extension (v: GLdouble)
      inline def value: Double = v

  opaque type GLeglClientBufferEXT = Ptr[Byte]
  object GLeglClientBufferEXT:
    given _tag: Tag[GLeglClientBufferEXT] = Tag.Ptr(Tag.Byte)
    inline def apply(inline o: Ptr[Byte]): GLeglClientBufferEXT = o
    extension (v: GLeglClientBufferEXT)
      inline def value: Ptr[Byte] = v

  opaque type GLeglImageOES = Ptr[Byte]
  object GLeglImageOES:
    given _tag: Tag[GLeglImageOES] = Tag.Ptr(Tag.Byte)
    inline def apply(inline o: Ptr[Byte]): GLeglImageOES = o
    extension (v: GLeglImageOES)
      inline def value: Ptr[Byte] = v

  opaque type GLenum = CUnsignedInt
  object GLenum:
    given _tag: Tag[GLenum] = Tag.UInt
    inline def apply(inline o: CUnsignedInt): GLenum = o
    extension (v: GLenum)
      inline def value: CUnsignedInt = v

  opaque type GLfixed = CInt
  object GLfixed:
    given _tag: Tag[GLfixed] = Tag.Int
    inline def apply(inline o: CInt): GLfixed = o
    extension (v: GLfixed)
      inline def value: CInt = v

  opaque type GLfloat = Float
  object GLfloat:
    given _tag: Tag[GLfloat] = Tag.Float
    inline def apply(inline o: Float): GLfloat = o
    extension (v: GLfloat)
      inline def value: Float = v

  opaque type GLhalf = CUnsignedShort
  object GLhalf:
    given _tag: Tag[GLhalf] = Tag.UShort
    inline def apply(inline o: CUnsignedShort): GLhalf = o
    extension (v: GLhalf)
      inline def value: CUnsignedShort = v

  opaque type GLhandleARB = CUnsignedInt
  object GLhandleARB:
    given _tag: Tag[GLhandleARB] = Tag.UInt
    inline def apply(inline o: CUnsignedInt): GLhandleARB = o
    extension (v: GLhandleARB)
      inline def value: CUnsignedInt = v

  opaque type GLint = CInt
  object GLint:
    given _tag: Tag[GLint] = Tag.Int
    inline def apply(inline o: CInt): GLint = o
    extension (v: GLint)
      inline def value: CInt = v

  type GLint64 = GLint64EXT
  object GLint64:
    given _tag: Tag[GLint64] = GLint64EXT._tag
    inline def apply(inline o: GLint64EXT): GLint64 = o
    extension (v: GLint64)
      inline def value: GLint64EXT = v

  type GLint64EXT = int64_t
  object GLint64EXT:
    given _tag: Tag[GLint64EXT] = int64_t._tag
    inline def apply(inline o: int64_t): GLint64EXT = o
    extension (v: GLint64EXT)
      inline def value: int64_t = v

  type GLintptr = ptrdiff_t
  object GLintptr:
    given _tag: Tag[GLintptr] = ptrdiff_t._tag
    inline def apply(inline o: ptrdiff_t): GLintptr = o
    extension (v: GLintptr)
      inline def value: ptrdiff_t = v

  type GLintptrARB = ptrdiff_t
  object GLintptrARB:
    given _tag: Tag[GLintptrARB] = ptrdiff_t._tag
    inline def apply(inline o: ptrdiff_t): GLintptrARB = o
    extension (v: GLintptrARB)
      inline def value: ptrdiff_t = v

  opaque type GLshort = CShort
  object GLshort:
    given _tag: Tag[GLshort] = Tag.Short
    inline def apply(inline o: CShort): GLshort = o
    extension (v: GLshort)
      inline def value: CShort = v

  opaque type GLsizei = CInt
  object GLsizei:
    given _tag: Tag[GLsizei] = Tag.Int
    inline def apply(inline o: CInt): GLsizei = o
    extension (v: GLsizei)
      inline def value: CInt = v

  type GLsizeiptr = ptrdiff_t
  object GLsizeiptr:
    given _tag: Tag[GLsizeiptr] = ptrdiff_t._tag
    inline def apply(inline o: ptrdiff_t): GLsizeiptr = o
    extension (v: GLsizeiptr)
      inline def value: ptrdiff_t = v

  type GLsizeiptrARB = ptrdiff_t
  object GLsizeiptrARB:
    given _tag: Tag[GLsizeiptrARB] = ptrdiff_t._tag
    inline def apply(inline o: ptrdiff_t): GLsizeiptrARB = o
    extension (v: GLsizeiptrARB)
      inline def value: ptrdiff_t = v

  opaque type GLsync = Ptr[__GLsync]
  object GLsync:
    given _tag: Tag[GLsync] = Tag.Ptr[__GLsync](__GLsync._tag)
    inline def apply(inline o: Ptr[__GLsync]): GLsync = o
    extension (v: GLsync)
      inline def value: Ptr[__GLsync] = v

  opaque type GLubyte = CUnsignedChar
  object GLubyte:
    given _tag: Tag[GLubyte] = Tag.UByte
    inline def apply(inline o: CUnsignedChar): GLubyte = o
    extension (v: GLubyte)
      inline def value: CUnsignedChar = v

  opaque type GLuint = CUnsignedInt
  object GLuint:
    given _tag: Tag[GLuint] = Tag.UInt
    inline def apply(inline o: CUnsignedInt): GLuint = o
    extension (v: GLuint)
      inline def value: CUnsignedInt = v

  type GLuint64 = GLuint64EXT
  object GLuint64:
    given _tag: Tag[GLuint64] = GLuint64EXT._tag
    inline def apply(inline o: GLuint64EXT): GLuint64 = o
    extension (v: GLuint64)
      inline def value: GLuint64EXT = v

  type GLuint64EXT = uint64_t
  object GLuint64EXT:
    given _tag: Tag[GLuint64EXT] = uint64_t._tag
    inline def apply(inline o: uint64_t): GLuint64EXT = o
    extension (v: GLuint64EXT)
      inline def value: uint64_t = v

  opaque type GLulong = CUnsignedLongInt
  object GLulong:
    // MANUAL INTERVENTION: Changed ULong to USize
    // given _tag: Tag[GLulong] = Tag.ULong
    given _tag: Tag[GLulong] = Tag.USize
    inline def apply(inline o: CUnsignedLongInt): GLulong = o
    extension (v: GLulong)
      inline def value: CUnsignedLongInt = v

  opaque type GLushort = CUnsignedShort
  object GLushort:
    given _tag: Tag[GLushort] = Tag.UShort
    inline def apply(inline o: CUnsignedShort): GLushort = o
    extension (v: GLushort)
      inline def value: CUnsignedShort = v

  type GLvdpauSurfaceNV = GLintptr
  object GLvdpauSurfaceNV:
    given _tag: Tag[GLvdpauSurfaceNV] = GLintptr._tag
    inline def apply(inline o: GLintptr): GLvdpauSurfaceNV = o
    extension (v: GLvdpauSurfaceNV)
      inline def value: GLintptr = v

  type GLvoid = Unit
  object GLvoid:
    given _tag: Tag[GLvoid] = Tag.Unit
    inline def apply(inline o: Unit): GLvoid = o
    extension (v: GLvoid)
      inline def value: Unit = v

  opaque type PFNGLACQUIREKEYEDMUTEXWIN32EXTPROC = CFuncPtr3[GLuint, GLuint64, GLuint, GLboolean]
  object PFNGLACQUIREKEYEDMUTEXWIN32EXTPROC:
    given _tag: Tag[PFNGLACQUIREKEYEDMUTEXWIN32EXTPROC] = Tag.materializeCFuncPtr3[GLuint, GLuint64, GLuint, GLboolean]
    inline def fromPtr(ptr: Ptr[Byte] | Ptr[?]): PFNGLACQUIREKEYEDMUTEXWIN32EXTPROC = CFuncPtr.fromPtr(ptr.asInstanceOf[Ptr[Byte]])
    inline def apply(inline o: CFuncPtr3[GLuint, GLuint64, GLuint, GLboolean]): PFNGLACQUIREKEYEDMUTEXWIN32EXTPROC = o
    extension (v: PFNGLACQUIREKEYEDMUTEXWIN32EXTPROC)
      inline def value: CFuncPtr3[GLuint, GLuint64, GLuint, GLboolean] = v
      inline def toPtr: Ptr[?] = CFuncPtr.toPtr(v)

  opaque type PFNGLACTIVEPROGRAMEXTPROC = CFuncPtr1[GLuint, Unit]
  object PFNGLACTIVEPROGRAMEXTPROC:
    given _tag: Tag[PFNGLACTIVEPROGRAMEXTPROC] = Tag.materializeCFuncPtr1[GLuint, Unit]
    inline def fromPtr(ptr: Ptr[Byte] | Ptr[?]): PFNGLACTIVEPROGRAMEXTPROC = CFuncPtr.fromPtr(ptr.asInstanceOf[Ptr[Byte]])
    inline def apply(inline o: CFuncPtr1[GLuint, Unit]): PFNGLACTIVEPROGRAMEXTPROC = o
    extension (v: PFNGLACTIVEPROGRAMEXTPROC)
      inline def value: CFuncPtr1[GLuint, Unit] = v
      inline def toPtr: Ptr[?] = CFuncPtr.toPtr(v)

  opaque type PFNGLACTIVESHADERPROGRAMPROC = CFuncPtr2[GLuint, GLuint, Unit]
  object PFNGLACTIVESHADERPROGRAMPROC:
    given _tag: Tag[PFNGLACTIVESHADERPROGRAMPROC] = Tag.materializeCFuncPtr2[GLuint, GLuint, Unit]
    inline def fromPtr(ptr: Ptr[Byte] | Ptr[?]): PFNGLACTIVESHADERPROGRAMPROC = CFuncPtr.fromPtr(ptr.asInstanceOf[Ptr[Byte]])
    inline def apply(inline o: CFuncPtr2[GLuint, GLuint, Unit]): PFNGLACTIVESHADERPROGRAMPROC = o
    extension (v: PFNGLACTIVESHADERPROGRAMPROC)
      inline def value: CFuncPtr2[GLuint, GLuint, Unit] = v
      inline def toPtr: Ptr[?] = CFuncPtr.toPtr(v)

  opaque type PFNGLACTIVESTENCILFACEEXTPROC = CFuncPtr1[GLenum, Unit]
  object PFNGLACTIVESTENCILFACEEXTPROC:
    given _tag: Tag[PFNGLACTIVESTENCILFACEEXTPROC] = Tag.materializeCFuncPtr1[GLenum, Unit]
    inline def fromPtr(ptr: Ptr[Byte] | Ptr[?]): PFNGLACTIVESTENCILFACEEXTPROC = CFuncPtr.fromPtr(ptr.asInstanceOf[Ptr[Byte]])
    inline def apply(inline o: CFuncPtr1[GLenum, Unit]): PFNGLACTIVESTENCILFACEEXTPROC = o
    extension (v: PFNGLACTIVESTENCILFACEEXTPROC)
      inline def value: CFuncPtr1[GLenum, Unit] = v
      inline def toPtr: Ptr[?] = CFuncPtr.toPtr(v)

  opaque type PFNGLACTIVETEXTUREARBPROC = CFuncPtr1[GLenum, Unit]
  object PFNGLACTIVETEXTUREARBPROC:
    given _tag: Tag[PFNGLACTIVETEXTUREARBPROC] = Tag.materializeCFuncPtr1[GLenum, Unit]
    inline def fromPtr(ptr: Ptr[Byte] | Ptr[?]): PFNGLACTIVETEXTUREARBPROC = CFuncPtr.fromPtr(ptr.asInstanceOf[Ptr[Byte]])
    inline def apply(inline o: CFuncPtr1[GLenum, Unit]): PFNGLACTIVETEXTUREARBPROC = o
    extension (v: PFNGLACTIVETEXTUREARBPROC)
      inline def value: CFuncPtr1[GLenum, Unit] = v
      inline def toPtr: Ptr[?] = CFuncPtr.toPtr(v)

  opaque type PFNGLACTIVETEXTUREPROC = CFuncPtr1[GLenum, Unit]
  object PFNGLACTIVETEXTUREPROC:
    given _tag: Tag[PFNGLACTIVETEXTUREPROC] = Tag.materializeCFuncPtr1[GLenum, Unit]
    inline def fromPtr(ptr: Ptr[Byte] | Ptr[?]): PFNGLACTIVETEXTUREPROC = CFuncPtr.fromPtr(ptr.asInstanceOf[Ptr[Byte]])
    inline def apply(inline o: CFuncPtr1[GLenum, Unit]): PFNGLACTIVETEXTUREPROC = o
    extension (v: PFNGLACTIVETEXTUREPROC)
      inline def value: CFuncPtr1[GLenum, Unit] = v
      inline def toPtr: Ptr[?] = CFuncPtr.toPtr(v)

  opaque type PFNGLACTIVEVARYINGNVPROC = CFuncPtr2[GLuint, Ptr[GLchar], Unit]
  object PFNGLACTIVEVARYINGNVPROC:
    given _tag: Tag[PFNGLACTIVEVARYINGNVPROC] = Tag.materializeCFuncPtr2[GLuint, Ptr[GLchar], Unit]
    inline def fromPtr(ptr: Ptr[Byte] | Ptr[?]): PFNGLACTIVEVARYINGNVPROC = CFuncPtr.fromPtr(ptr.asInstanceOf[Ptr[Byte]])
    inline def apply(inline o: CFuncPtr2[GLuint, Ptr[GLchar], Unit]): PFNGLACTIVEVARYINGNVPROC = o
    extension (v: PFNGLACTIVEVARYINGNVPROC)
      inline def value: CFuncPtr2[GLuint, Ptr[GLchar], Unit] = v
      inline def toPtr: Ptr[?] = CFuncPtr.toPtr(v)

  opaque type PFNGLADDRESSSPACEPROC = CFuncPtr2[GLenum, GLbitfield, Unit]
  object PFNGLADDRESSSPACEPROC:
    given _tag: Tag[PFNGLADDRESSSPACEPROC] = Tag.materializeCFuncPtr2[GLenum, GLbitfield, Unit]
    inline def fromPtr(ptr: Ptr[Byte] | Ptr[?]): PFNGLADDRESSSPACEPROC = CFuncPtr.fromPtr(ptr.asInstanceOf[Ptr[Byte]])
    inline def apply(inline o: CFuncPtr2[GLenum, GLbitfield, Unit]): PFNGLADDRESSSPACEPROC = o
    extension (v: PFNGLADDRESSSPACEPROC)
      inline def value: CFuncPtr2[GLenum, GLbitfield, Unit] = v
      inline def toPtr: Ptr[?] = CFuncPtr.toPtr(v)

  opaque type PFNGLADDSWAPHINTRECTWINPROC = CFuncPtr4[GLint, GLint, GLsizei, GLsizei, Unit]
  object PFNGLADDSWAPHINTRECTWINPROC:
    given _tag: Tag[PFNGLADDSWAPHINTRECTWINPROC] = Tag.materializeCFuncPtr4[GLint, GLint, GLsizei, GLsizei, Unit]
    inline def fromPtr(ptr: Ptr[Byte] | Ptr[?]): PFNGLADDSWAPHINTRECTWINPROC = CFuncPtr.fromPtr(ptr.asInstanceOf[Ptr[Byte]])
    inline def apply(inline o: CFuncPtr4[GLint, GLint, GLsizei, GLsizei, Unit]): PFNGLADDSWAPHINTRECTWINPROC = o
    extension (v: PFNGLADDSWAPHINTRECTWINPROC)
      inline def value: CFuncPtr4[GLint, GLint, GLsizei, GLsizei, Unit] = v
      inline def toPtr: Ptr[?] = CFuncPtr.toPtr(v)

  opaque type PFNGLALLOCMPEGPREDICTORSSGIXPROC = CFuncPtr4[GLsizei, GLsizei, GLsizei, Ptr[GLuint], Unit]
  object PFNGLALLOCMPEGPREDICTORSSGIXPROC:
    given _tag: Tag[PFNGLALLOCMPEGPREDICTORSSGIXPROC] = Tag.materializeCFuncPtr4[GLsizei, GLsizei, GLsizei, Ptr[GLuint], Unit]
    inline def fromPtr(ptr: Ptr[Byte] | Ptr[?]): PFNGLALLOCMPEGPREDICTORSSGIXPROC = CFuncPtr.fromPtr(ptr.asInstanceOf[Ptr[Byte]])
    inline def apply(inline o: CFuncPtr4[GLsizei, GLsizei, GLsizei, Ptr[GLuint], Unit]): PFNGLALLOCMPEGPREDICTORSSGIXPROC = o
    extension (v: PFNGLALLOCMPEGPREDICTORSSGIXPROC)
      inline def value: CFuncPtr4[GLsizei, GLsizei, GLsizei, Ptr[GLuint], Unit] = v
      inline def toPtr: Ptr[?] = CFuncPtr.toPtr(v)

  opaque type PFNGLALPHAFRAGMENTOP1ATIPROC = CFuncPtr6[GLenum, GLuint, GLuint, GLuint, GLuint, GLuint, Unit]
  object PFNGLALPHAFRAGMENTOP1ATIPROC:
    given _tag: Tag[PFNGLALPHAFRAGMENTOP1ATIPROC] = Tag.materializeCFuncPtr6[GLenum, GLuint, GLuint, GLuint, GLuint, GLuint, Unit]
    inline def fromPtr(ptr: Ptr[Byte] | Ptr[?]): PFNGLALPHAFRAGMENTOP1ATIPROC = CFuncPtr.fromPtr(ptr.asInstanceOf[Ptr[Byte]])
    inline def apply(inline o: CFuncPtr6[GLenum, GLuint, GLuint, GLuint, GLuint, GLuint, Unit]): PFNGLALPHAFRAGMENTOP1ATIPROC = o
    extension (v: PFNGLALPHAFRAGMENTOP1ATIPROC)
      inline def value: CFuncPtr6[GLenum, GLuint, GLuint, GLuint, GLuint, GLuint, Unit] = v
      inline def toPtr: Ptr[?] = CFuncPtr.toPtr(v)

  opaque type PFNGLALPHAFRAGMENTOP2ATIPROC = CFuncPtr9[GLenum, GLuint, GLuint, GLuint, GLuint, GLuint, GLuint, GLuint, GLuint, Unit]
  object PFNGLALPHAFRAGMENTOP2ATIPROC:
    given _tag: Tag[PFNGLALPHAFRAGMENTOP2ATIPROC] = Tag.materializeCFuncPtr9[GLenum, GLuint, GLuint, GLuint, GLuint, GLuint, GLuint, GLuint, GLuint, Unit]
    inline def fromPtr(ptr: Ptr[Byte] | Ptr[?]): PFNGLALPHAFRAGMENTOP2ATIPROC = CFuncPtr.fromPtr(ptr.asInstanceOf[Ptr[Byte]])
    inline def apply(inline o: CFuncPtr9[GLenum, GLuint, GLuint, GLuint, GLuint, GLuint, GLuint, GLuint, GLuint, Unit]): PFNGLALPHAFRAGMENTOP2ATIPROC = o
    extension (v: PFNGLALPHAFRAGMENTOP2ATIPROC)
      inline def value: CFuncPtr9[GLenum, GLuint, GLuint, GLuint, GLuint, GLuint, GLuint, GLuint, GLuint, Unit] = v
      inline def toPtr: Ptr[?] = CFuncPtr.toPtr(v)

  opaque type PFNGLALPHAFRAGMENTOP3ATIPROC = CFuncPtr12[GLenum, GLuint, GLuint, GLuint, GLuint, GLuint, GLuint, GLuint, GLuint, GLuint, GLuint, GLuint, Unit]
  object PFNGLALPHAFRAGMENTOP3ATIPROC:
    given _tag: Tag[PFNGLALPHAFRAGMENTOP3ATIPROC] = Tag.materializeCFuncPtr12[GLenum, GLuint, GLuint, GLuint, GLuint, GLuint, GLuint, GLuint, GLuint, GLuint, GLuint, GLuint, Unit]
    inline def fromPtr(ptr: Ptr[Byte] | Ptr[?]): PFNGLALPHAFRAGMENTOP3ATIPROC = CFuncPtr.fromPtr(ptr.asInstanceOf[Ptr[Byte]])
    inline def apply(inline o: CFuncPtr12[GLenum, GLuint, GLuint, GLuint, GLuint, GLuint, GLuint, GLuint, GLuint, GLuint, GLuint, GLuint, Unit]): PFNGLALPHAFRAGMENTOP3ATIPROC = o
    extension (v: PFNGLALPHAFRAGMENTOP3ATIPROC)
      inline def value: CFuncPtr12[GLenum, GLuint, GLuint, GLuint, GLuint, GLuint, GLuint, GLuint, GLuint, GLuint, GLuint, GLuint, Unit] = v
      inline def toPtr: Ptr[?] = CFuncPtr.toPtr(v)

  opaque type PFNGLALPHAFUNCQCOMPROC = CFuncPtr2[GLenum, GLclampf, Unit]
  object PFNGLALPHAFUNCQCOMPROC:
    given _tag: Tag[PFNGLALPHAFUNCQCOMPROC] = Tag.materializeCFuncPtr2[GLenum, GLclampf, Unit]
    inline def fromPtr(ptr: Ptr[Byte] | Ptr[?]): PFNGLALPHAFUNCQCOMPROC = CFuncPtr.fromPtr(ptr.asInstanceOf[Ptr[Byte]])
    inline def apply(inline o: CFuncPtr2[GLenum, GLclampf, Unit]): PFNGLALPHAFUNCQCOMPROC = o
    extension (v: PFNGLALPHAFUNCQCOMPROC)
      inline def value: CFuncPtr2[GLenum, GLclampf, Unit] = v
      inline def toPtr: Ptr[?] = CFuncPtr.toPtr(v)

  opaque type PFNGLALPHAFUNCXPROC = CFuncPtr2[GLenum, GLclampx, Unit]
  object PFNGLALPHAFUNCXPROC:
    given _tag: Tag[PFNGLALPHAFUNCXPROC] = Tag.materializeCFuncPtr2[GLenum, GLclampx, Unit]
    inline def fromPtr(ptr: Ptr[Byte] | Ptr[?]): PFNGLALPHAFUNCXPROC = CFuncPtr.fromPtr(ptr.asInstanceOf[Ptr[Byte]])
    inline def apply(inline o: CFuncPtr2[GLenum, GLclampx, Unit]): PFNGLALPHAFUNCXPROC = o
    extension (v: PFNGLALPHAFUNCXPROC)
      inline def value: CFuncPtr2[GLenum, GLclampx, Unit] = v
      inline def toPtr: Ptr[?] = CFuncPtr.toPtr(v)

  opaque type PFNGLALPHATOCOVERAGEDITHERCONTROLNVPROC = CFuncPtr1[GLenum, Unit]
  object PFNGLALPHATOCOVERAGEDITHERCONTROLNVPROC:
    given _tag: Tag[PFNGLALPHATOCOVERAGEDITHERCONTROLNVPROC] = Tag.materializeCFuncPtr1[GLenum, Unit]
    inline def fromPtr(ptr: Ptr[Byte] | Ptr[?]): PFNGLALPHATOCOVERAGEDITHERCONTROLNVPROC = CFuncPtr.fromPtr(ptr.asInstanceOf[Ptr[Byte]])
    inline def apply(inline o: CFuncPtr1[GLenum, Unit]): PFNGLALPHATOCOVERAGEDITHERCONTROLNVPROC = o
    extension (v: PFNGLALPHATOCOVERAGEDITHERCONTROLNVPROC)
      inline def value: CFuncPtr1[GLenum, Unit] = v
      inline def toPtr: Ptr[?] = CFuncPtr.toPtr(v)

  opaque type PFNGLAPPLYTEXTUREEXTPROC = CFuncPtr1[GLenum, Unit]
  object PFNGLAPPLYTEXTUREEXTPROC:
    given _tag: Tag[PFNGLAPPLYTEXTUREEXTPROC] = Tag.materializeCFuncPtr1[GLenum, Unit]
    inline def fromPtr(ptr: Ptr[Byte] | Ptr[?]): PFNGLAPPLYTEXTUREEXTPROC = CFuncPtr.fromPtr(ptr.asInstanceOf[Ptr[Byte]])
    inline def apply(inline o: CFuncPtr1[GLenum, Unit]): PFNGLAPPLYTEXTUREEXTPROC = o
    extension (v: PFNGLAPPLYTEXTUREEXTPROC)
      inline def value: CFuncPtr1[GLenum, Unit] = v
      inline def toPtr: Ptr[?] = CFuncPtr.toPtr(v)

  opaque type PFNGLAREPROGRAMSRESIDENTNVPROC = CFuncPtr3[GLsizei, Ptr[GLuint], Ptr[GLboolean], GLboolean]
  object PFNGLAREPROGRAMSRESIDENTNVPROC:
    given _tag: Tag[PFNGLAREPROGRAMSRESIDENTNVPROC] = Tag.materializeCFuncPtr3[GLsizei, Ptr[GLuint], Ptr[GLboolean], GLboolean]
    inline def fromPtr(ptr: Ptr[Byte] | Ptr[?]): PFNGLAREPROGRAMSRESIDENTNVPROC = CFuncPtr.fromPtr(ptr.asInstanceOf[Ptr[Byte]])
    inline def apply(inline o: CFuncPtr3[GLsizei, Ptr[GLuint], Ptr[GLboolean], GLboolean]): PFNGLAREPROGRAMSRESIDENTNVPROC = o
    extension (v: PFNGLAREPROGRAMSRESIDENTNVPROC)
      inline def value: CFuncPtr3[GLsizei, Ptr[GLuint], Ptr[GLboolean], GLboolean] = v
      inline def toPtr: Ptr[?] = CFuncPtr.toPtr(v)

  opaque type PFNGLARETEXTURESRESIDENTEXTPROC = CFuncPtr3[GLsizei, Ptr[GLuint], Ptr[GLboolean], GLboolean]
  object PFNGLARETEXTURESRESIDENTEXTPROC:
    given _tag: Tag[PFNGLARETEXTURESRESIDENTEXTPROC] = Tag.materializeCFuncPtr3[GLsizei, Ptr[GLuint], Ptr[GLboolean], GLboolean]
    inline def fromPtr(ptr: Ptr[Byte] | Ptr[?]): PFNGLARETEXTURESRESIDENTEXTPROC = CFuncPtr.fromPtr(ptr.asInstanceOf[Ptr[Byte]])
    inline def apply(inline o: CFuncPtr3[GLsizei, Ptr[GLuint], Ptr[GLboolean], GLboolean]): PFNGLARETEXTURESRESIDENTEXTPROC = o
    extension (v: PFNGLARETEXTURESRESIDENTEXTPROC)
      inline def value: CFuncPtr3[GLsizei, Ptr[GLuint], Ptr[GLboolean], GLboolean] = v
      inline def toPtr: Ptr[?] = CFuncPtr.toPtr(v)

  opaque type PFNGLAREVERTEXARRAYSRESIDENTSGIXPROC = CFuncPtr3[GLsizei, Ptr[GLuint], Ptr[GLboolean], GLboolean]
  object PFNGLAREVERTEXARRAYSRESIDENTSGIXPROC:
    given _tag: Tag[PFNGLAREVERTEXARRAYSRESIDENTSGIXPROC] = Tag.materializeCFuncPtr3[GLsizei, Ptr[GLuint], Ptr[GLboolean], GLboolean]
    inline def fromPtr(ptr: Ptr[Byte] | Ptr[?]): PFNGLAREVERTEXARRAYSRESIDENTSGIXPROC = CFuncPtr.fromPtr(ptr.asInstanceOf[Ptr[Byte]])
    inline def apply(inline o: CFuncPtr3[GLsizei, Ptr[GLuint], Ptr[GLboolean], GLboolean]): PFNGLAREVERTEXARRAYSRESIDENTSGIXPROC = o
    extension (v: PFNGLAREVERTEXARRAYSRESIDENTSGIXPROC)
      inline def value: CFuncPtr3[GLsizei, Ptr[GLuint], Ptr[GLboolean], GLboolean] = v
      inline def toPtr: Ptr[?] = CFuncPtr.toPtr(v)

  opaque type PFNGLARRAYELEMENTEXTPROC = CFuncPtr1[GLint, Unit]
  object PFNGLARRAYELEMENTEXTPROC:
    given _tag: Tag[PFNGLARRAYELEMENTEXTPROC] = Tag.materializeCFuncPtr1[GLint, Unit]
    inline def fromPtr(ptr: Ptr[Byte] | Ptr[?]): PFNGLARRAYELEMENTEXTPROC = CFuncPtr.fromPtr(ptr.asInstanceOf[Ptr[Byte]])
    inline def apply(inline o: CFuncPtr1[GLint, Unit]): PFNGLARRAYELEMENTEXTPROC = o
    extension (v: PFNGLARRAYELEMENTEXTPROC)
      inline def value: CFuncPtr1[GLint, Unit] = v
      inline def toPtr: Ptr[?] = CFuncPtr.toPtr(v)

  opaque type PFNGLARRAYOBJECTATIPROC = CFuncPtr6[GLenum, GLint, GLenum, GLsizei, GLuint, GLuint, Unit]
  object PFNGLARRAYOBJECTATIPROC:
    given _tag: Tag[PFNGLARRAYOBJECTATIPROC] = Tag.materializeCFuncPtr6[GLenum, GLint, GLenum, GLsizei, GLuint, GLuint, Unit]
    inline def fromPtr(ptr: Ptr[Byte] | Ptr[?]): PFNGLARRAYOBJECTATIPROC = CFuncPtr.fromPtr(ptr.asInstanceOf[Ptr[Byte]])
    inline def apply(inline o: CFuncPtr6[GLenum, GLint, GLenum, GLsizei, GLuint, GLuint, Unit]): PFNGLARRAYOBJECTATIPROC = o
    extension (v: PFNGLARRAYOBJECTATIPROC)
      inline def value: CFuncPtr6[GLenum, GLint, GLenum, GLsizei, GLuint, GLuint, Unit] = v
      inline def toPtr: Ptr[?] = CFuncPtr.toPtr(v)

  opaque type PFNGLASYNCCOPYBUFFERSUBDATANVXPROC = CFuncPtr13[GLsizei, Ptr[GLuint], Ptr[GLuint64], GLuint, GLbitfield, GLuint, GLuint, GLintptr, GLintptr, GLsizeiptr, GLsizei, Ptr[GLuint], Ptr[GLuint64], GLsync]
  object PFNGLASYNCCOPYBUFFERSUBDATANVXPROC:
    given _tag: Tag[PFNGLASYNCCOPYBUFFERSUBDATANVXPROC] = Tag.materializeCFuncPtr13[GLsizei, Ptr[GLuint], Ptr[GLuint64], GLuint, GLbitfield, GLuint, GLuint, GLintptr, GLintptr, GLsizeiptr, GLsizei, Ptr[GLuint], Ptr[GLuint64], GLsync]
    inline def fromPtr(ptr: Ptr[Byte] | Ptr[?]): PFNGLASYNCCOPYBUFFERSUBDATANVXPROC = CFuncPtr.fromPtr(ptr.asInstanceOf[Ptr[Byte]])
    inline def apply(inline o: CFuncPtr13[GLsizei, Ptr[GLuint], Ptr[GLuint64], GLuint, GLbitfield, GLuint, GLuint, GLintptr, GLintptr, GLsizeiptr, GLsizei, Ptr[GLuint], Ptr[GLuint64], GLsync]): PFNGLASYNCCOPYBUFFERSUBDATANVXPROC = o
    extension (v: PFNGLASYNCCOPYBUFFERSUBDATANVXPROC)
      inline def value: CFuncPtr13[GLsizei, Ptr[GLuint], Ptr[GLuint64], GLuint, GLbitfield, GLuint, GLuint, GLintptr, GLintptr, GLsizeiptr, GLsizei, Ptr[GLuint], Ptr[GLuint64], GLsync] = v
      inline def toPtr: Ptr[?] = CFuncPtr.toPtr(v)

  // MANUAL INTERVENTION: no way to express a function of 23 parameters on Scala Native
  // opaque type PFNGLASYNCCOPYIMAGESUBDATANVXPROC = CFuncPtr23[GLsizei, Ptr[GLuint], Ptr[GLuint64], GLuint, GLbitfield, GLuint, GLenum, GLint, GLint, GLint, GLint, GLuint, GLenum, GLint, GLint, GLint, GLint, GLsizei, GLsizei, GLsizei, GLsizei, Ptr[GLuint], Ptr[GLuint64], GLuint]
  // object PFNGLASYNCCOPYIMAGESUBDATANVXPROC:
  //   given _tag: Tag[PFNGLASYNCCOPYIMAGESUBDATANVXPROC] = Tag.materializeCFuncPtr23[GLsizei, Ptr[GLuint], Ptr[GLuint64], GLuint, GLbitfield, GLuint, GLenum, GLint, GLint, GLint, GLint, GLuint, GLenum, GLint, GLint, GLint, GLint, GLsizei, GLsizei, GLsizei, GLsizei, Ptr[GLuint], Ptr[GLuint64], GLuint]
  //   inline def fromPtr(ptr: Ptr[Byte] | Ptr[?]): PFNGLASYNCCOPYIMAGESUBDATANVXPROC = CFuncPtr.fromPtr(ptr.asInstanceOf[Ptr[Byte]])
  //   inline def apply(inline o: CFuncPtr23[GLsizei, Ptr[GLuint], Ptr[GLuint64], GLuint, GLbitfield, GLuint, GLenum, GLint, GLint, GLint, GLint, GLuint, GLenum, GLint, GLint, GLint, GLint, GLsizei, GLsizei, GLsizei, GLsizei, Ptr[GLuint], Ptr[GLuint64], GLuint]): PFNGLASYNCCOPYIMAGESUBDATANVXPROC = o
  //   extension (v: PFNGLASYNCCOPYIMAGESUBDATANVXPROC)
  //     inline def value: CFuncPtr23[GLsizei, Ptr[GLuint], Ptr[GLuint64], GLuint, GLbitfield, GLuint, GLenum, GLint, GLint, GLint, GLint, GLuint, GLenum, GLint, GLint, GLint, GLint, GLsizei, GLsizei, GLsizei, GLsizei, Ptr[GLuint], Ptr[GLuint64], GLuint] = v
  //     inline def toPtr: Ptr[?] = CFuncPtr.toPtr(v)

  opaque type PFNGLASYNCMARKERSGIXPROC = CFuncPtr1[GLuint, Unit]
  object PFNGLASYNCMARKERSGIXPROC:
    given _tag: Tag[PFNGLASYNCMARKERSGIXPROC] = Tag.materializeCFuncPtr1[GLuint, Unit]
    inline def fromPtr(ptr: Ptr[Byte] | Ptr[?]): PFNGLASYNCMARKERSGIXPROC = CFuncPtr.fromPtr(ptr.asInstanceOf[Ptr[Byte]])
    inline def apply(inline o: CFuncPtr1[GLuint, Unit]): PFNGLASYNCMARKERSGIXPROC = o
    extension (v: PFNGLASYNCMARKERSGIXPROC)
      inline def value: CFuncPtr1[GLuint, Unit] = v
      inline def toPtr: Ptr[?] = CFuncPtr.toPtr(v)

  opaque type PFNGLATTACHOBJECTARBPROC = CFuncPtr2[GLhandleARB, GLhandleARB, Unit]
  object PFNGLATTACHOBJECTARBPROC:
    given _tag: Tag[PFNGLATTACHOBJECTARBPROC] = Tag.materializeCFuncPtr2[GLhandleARB, GLhandleARB, Unit]
    inline def fromPtr(ptr: Ptr[Byte] | Ptr[?]): PFNGLATTACHOBJECTARBPROC = CFuncPtr.fromPtr(ptr.asInstanceOf[Ptr[Byte]])
    inline def apply(inline o: CFuncPtr2[GLhandleARB, GLhandleARB, Unit]): PFNGLATTACHOBJECTARBPROC = o
    extension (v: PFNGLATTACHOBJECTARBPROC)
      inline def value: CFuncPtr2[GLhandleARB, GLhandleARB, Unit] = v
      inline def toPtr: Ptr[?] = CFuncPtr.toPtr(v)

  opaque type PFNGLATTACHSHADERPROC = CFuncPtr2[GLuint, GLuint, Unit]
  object PFNGLATTACHSHADERPROC:
    given _tag: Tag[PFNGLATTACHSHADERPROC] = Tag.materializeCFuncPtr2[GLuint, GLuint, Unit]
    inline def fromPtr(ptr: Ptr[Byte] | Ptr[?]): PFNGLATTACHSHADERPROC = CFuncPtr.fromPtr(ptr.asInstanceOf[Ptr[Byte]])
    inline def apply(inline o: CFuncPtr2[GLuint, GLuint, Unit]): PFNGLATTACHSHADERPROC = o
    extension (v: PFNGLATTACHSHADERPROC)
      inline def value: CFuncPtr2[GLuint, GLuint, Unit] = v
      inline def toPtr: Ptr[?] = CFuncPtr.toPtr(v)

  opaque type PFNGLBEGINCONDITIONALRENDERNVPROC = CFuncPtr2[GLuint, GLenum, Unit]
  object PFNGLBEGINCONDITIONALRENDERNVPROC:
    given _tag: Tag[PFNGLBEGINCONDITIONALRENDERNVPROC] = Tag.materializeCFuncPtr2[GLuint, GLenum, Unit]
    inline def fromPtr(ptr: Ptr[Byte] | Ptr[?]): PFNGLBEGINCONDITIONALRENDERNVPROC = CFuncPtr.fromPtr(ptr.asInstanceOf[Ptr[Byte]])
    inline def apply(inline o: CFuncPtr2[GLuint, GLenum, Unit]): PFNGLBEGINCONDITIONALRENDERNVPROC = o
    extension (v: PFNGLBEGINCONDITIONALRENDERNVPROC)
      inline def value: CFuncPtr2[GLuint, GLenum, Unit] = v
      inline def toPtr: Ptr[?] = CFuncPtr.toPtr(v)

  opaque type PFNGLBEGINCONDITIONALRENDERNVXPROC = CFuncPtr1[GLuint, Unit]
  object PFNGLBEGINCONDITIONALRENDERNVXPROC:
    given _tag: Tag[PFNGLBEGINCONDITIONALRENDERNVXPROC] = Tag.materializeCFuncPtr1[GLuint, Unit]
    inline def fromPtr(ptr: Ptr[Byte] | Ptr[?]): PFNGLBEGINCONDITIONALRENDERNVXPROC = CFuncPtr.fromPtr(ptr.asInstanceOf[Ptr[Byte]])
    inline def apply(inline o: CFuncPtr1[GLuint, Unit]): PFNGLBEGINCONDITIONALRENDERNVXPROC = o
    extension (v: PFNGLBEGINCONDITIONALRENDERNVXPROC)
      inline def value: CFuncPtr1[GLuint, Unit] = v
      inline def toPtr: Ptr[?] = CFuncPtr.toPtr(v)

  opaque type PFNGLBEGINCONDITIONALRENDERPROC = CFuncPtr2[GLuint, GLenum, Unit]
  object PFNGLBEGINCONDITIONALRENDERPROC:
    given _tag: Tag[PFNGLBEGINCONDITIONALRENDERPROC] = Tag.materializeCFuncPtr2[GLuint, GLenum, Unit]
    inline def fromPtr(ptr: Ptr[Byte] | Ptr[?]): PFNGLBEGINCONDITIONALRENDERPROC = CFuncPtr.fromPtr(ptr.asInstanceOf[Ptr[Byte]])
    inline def apply(inline o: CFuncPtr2[GLuint, GLenum, Unit]): PFNGLBEGINCONDITIONALRENDERPROC = o
    extension (v: PFNGLBEGINCONDITIONALRENDERPROC)
      inline def value: CFuncPtr2[GLuint, GLenum, Unit] = v
      inline def toPtr: Ptr[?] = CFuncPtr.toPtr(v)

  opaque type PFNGLBEGINFRAGMENTSHADERATIPROC = CFuncPtr0[Unit]
  object PFNGLBEGINFRAGMENTSHADERATIPROC:
    given _tag: Tag[PFNGLBEGINFRAGMENTSHADERATIPROC] = Tag.materializeCFuncPtr0[Unit]
    inline def fromPtr(ptr: Ptr[Byte] | Ptr[?]): PFNGLBEGINFRAGMENTSHADERATIPROC = CFuncPtr.fromPtr(ptr.asInstanceOf[Ptr[Byte]])
    inline def apply(inline o: CFuncPtr0[Unit]): PFNGLBEGINFRAGMENTSHADERATIPROC = o
    extension (v: PFNGLBEGINFRAGMENTSHADERATIPROC)
      inline def value: CFuncPtr0[Unit] = v
      inline def toPtr: Ptr[?] = CFuncPtr.toPtr(v)

  opaque type PFNGLBEGINOCCLUSIONQUERYNVPROC = CFuncPtr1[GLuint, Unit]
  object PFNGLBEGINOCCLUSIONQUERYNVPROC:
    given _tag: Tag[PFNGLBEGINOCCLUSIONQUERYNVPROC] = Tag.materializeCFuncPtr1[GLuint, Unit]
    inline def fromPtr(ptr: Ptr[Byte] | Ptr[?]): PFNGLBEGINOCCLUSIONQUERYNVPROC = CFuncPtr.fromPtr(ptr.asInstanceOf[Ptr[Byte]])
    inline def apply(inline o: CFuncPtr1[GLuint, Unit]): PFNGLBEGINOCCLUSIONQUERYNVPROC = o
    extension (v: PFNGLBEGINOCCLUSIONQUERYNVPROC)
      inline def value: CFuncPtr1[GLuint, Unit] = v
      inline def toPtr: Ptr[?] = CFuncPtr.toPtr(v)

  opaque type PFNGLBEGINPERFMONITORAMDPROC = CFuncPtr1[GLuint, Unit]
  object PFNGLBEGINPERFMONITORAMDPROC:
    given _tag: Tag[PFNGLBEGINPERFMONITORAMDPROC] = Tag.materializeCFuncPtr1[GLuint, Unit]
    inline def fromPtr(ptr: Ptr[Byte] | Ptr[?]): PFNGLBEGINPERFMONITORAMDPROC = CFuncPtr.fromPtr(ptr.asInstanceOf[Ptr[Byte]])
    inline def apply(inline o: CFuncPtr1[GLuint, Unit]): PFNGLBEGINPERFMONITORAMDPROC = o
    extension (v: PFNGLBEGINPERFMONITORAMDPROC)
      inline def value: CFuncPtr1[GLuint, Unit] = v
      inline def toPtr: Ptr[?] = CFuncPtr.toPtr(v)

  opaque type PFNGLBEGINPERFQUERYINTELPROC = CFuncPtr1[GLuint, Unit]
  object PFNGLBEGINPERFQUERYINTELPROC:
    given _tag: Tag[PFNGLBEGINPERFQUERYINTELPROC] = Tag.materializeCFuncPtr1[GLuint, Unit]
    inline def fromPtr(ptr: Ptr[Byte] | Ptr[?]): PFNGLBEGINPERFQUERYINTELPROC = CFuncPtr.fromPtr(ptr.asInstanceOf[Ptr[Byte]])
    inline def apply(inline o: CFuncPtr1[GLuint, Unit]): PFNGLBEGINPERFQUERYINTELPROC = o
    extension (v: PFNGLBEGINPERFQUERYINTELPROC)
      inline def value: CFuncPtr1[GLuint, Unit] = v
      inline def toPtr: Ptr[?] = CFuncPtr.toPtr(v)

  opaque type PFNGLBEGINQUERYANGLEPROC = CFuncPtr2[GLenum, GLuint, Unit]
  object PFNGLBEGINQUERYANGLEPROC:
    given _tag: Tag[PFNGLBEGINQUERYANGLEPROC] = Tag.materializeCFuncPtr2[GLenum, GLuint, Unit]
    inline def fromPtr(ptr: Ptr[Byte] | Ptr[?]): PFNGLBEGINQUERYANGLEPROC = CFuncPtr.fromPtr(ptr.asInstanceOf[Ptr[Byte]])
    inline def apply(inline o: CFuncPtr2[GLenum, GLuint, Unit]): PFNGLBEGINQUERYANGLEPROC = o
    extension (v: PFNGLBEGINQUERYANGLEPROC)
      inline def value: CFuncPtr2[GLenum, GLuint, Unit] = v
      inline def toPtr: Ptr[?] = CFuncPtr.toPtr(v)

  opaque type PFNGLBEGINQUERYARBPROC = CFuncPtr2[GLenum, GLuint, Unit]
  object PFNGLBEGINQUERYARBPROC:
    given _tag: Tag[PFNGLBEGINQUERYARBPROC] = Tag.materializeCFuncPtr2[GLenum, GLuint, Unit]
    inline def fromPtr(ptr: Ptr[Byte] | Ptr[?]): PFNGLBEGINQUERYARBPROC = CFuncPtr.fromPtr(ptr.asInstanceOf[Ptr[Byte]])
    inline def apply(inline o: CFuncPtr2[GLenum, GLuint, Unit]): PFNGLBEGINQUERYARBPROC = o
    extension (v: PFNGLBEGINQUERYARBPROC)
      inline def value: CFuncPtr2[GLenum, GLuint, Unit] = v
      inline def toPtr: Ptr[?] = CFuncPtr.toPtr(v)

  opaque type PFNGLBEGINQUERYEXTPROC = CFuncPtr2[GLenum, GLuint, Unit]
  object PFNGLBEGINQUERYEXTPROC:
    given _tag: Tag[PFNGLBEGINQUERYEXTPROC] = Tag.materializeCFuncPtr2[GLenum, GLuint, Unit]
    inline def fromPtr(ptr: Ptr[Byte] | Ptr[?]): PFNGLBEGINQUERYEXTPROC = CFuncPtr.fromPtr(ptr.asInstanceOf[Ptr[Byte]])
    inline def apply(inline o: CFuncPtr2[GLenum, GLuint, Unit]): PFNGLBEGINQUERYEXTPROC = o
    extension (v: PFNGLBEGINQUERYEXTPROC)
      inline def value: CFuncPtr2[GLenum, GLuint, Unit] = v
      inline def toPtr: Ptr[?] = CFuncPtr.toPtr(v)

  opaque type PFNGLBEGINQUERYINDEXEDPROC = CFuncPtr3[GLenum, GLuint, GLuint, Unit]
  object PFNGLBEGINQUERYINDEXEDPROC:
    given _tag: Tag[PFNGLBEGINQUERYINDEXEDPROC] = Tag.materializeCFuncPtr3[GLenum, GLuint, GLuint, Unit]
    inline def fromPtr(ptr: Ptr[Byte] | Ptr[?]): PFNGLBEGINQUERYINDEXEDPROC = CFuncPtr.fromPtr(ptr.asInstanceOf[Ptr[Byte]])
    inline def apply(inline o: CFuncPtr3[GLenum, GLuint, GLuint, Unit]): PFNGLBEGINQUERYINDEXEDPROC = o
    extension (v: PFNGLBEGINQUERYINDEXEDPROC)
      inline def value: CFuncPtr3[GLenum, GLuint, GLuint, Unit] = v
      inline def toPtr: Ptr[?] = CFuncPtr.toPtr(v)

  opaque type PFNGLBEGINQUERYPROC = CFuncPtr2[GLenum, GLuint, Unit]
  object PFNGLBEGINQUERYPROC:
    given _tag: Tag[PFNGLBEGINQUERYPROC] = Tag.materializeCFuncPtr2[GLenum, GLuint, Unit]
    inline def fromPtr(ptr: Ptr[Byte] | Ptr[?]): PFNGLBEGINQUERYPROC = CFuncPtr.fromPtr(ptr.asInstanceOf[Ptr[Byte]])
    inline def apply(inline o: CFuncPtr2[GLenum, GLuint, Unit]): PFNGLBEGINQUERYPROC = o
    extension (v: PFNGLBEGINQUERYPROC)
      inline def value: CFuncPtr2[GLenum, GLuint, Unit] = v
      inline def toPtr: Ptr[?] = CFuncPtr.toPtr(v)

  opaque type PFNGLBEGINSCENEEXTPROC = CFuncPtr0[Unit]
  object PFNGLBEGINSCENEEXTPROC:
    given _tag: Tag[PFNGLBEGINSCENEEXTPROC] = Tag.materializeCFuncPtr0[Unit]
    inline def fromPtr(ptr: Ptr[Byte] | Ptr[?]): PFNGLBEGINSCENEEXTPROC = CFuncPtr.fromPtr(ptr.asInstanceOf[Ptr[Byte]])
    inline def apply(inline o: CFuncPtr0[Unit]): PFNGLBEGINSCENEEXTPROC = o
    extension (v: PFNGLBEGINSCENEEXTPROC)
      inline def value: CFuncPtr0[Unit] = v
      inline def toPtr: Ptr[?] = CFuncPtr.toPtr(v)

  opaque type PFNGLBEGINTRANSFORMFEEDBACKEXTPROC = CFuncPtr1[GLenum, Unit]
  object PFNGLBEGINTRANSFORMFEEDBACKEXTPROC:
    given _tag: Tag[PFNGLBEGINTRANSFORMFEEDBACKEXTPROC] = Tag.materializeCFuncPtr1[GLenum, Unit]
    inline def fromPtr(ptr: Ptr[Byte] | Ptr[?]): PFNGLBEGINTRANSFORMFEEDBACKEXTPROC = CFuncPtr.fromPtr(ptr.asInstanceOf[Ptr[Byte]])
    inline def apply(inline o: CFuncPtr1[GLenum, Unit]): PFNGLBEGINTRANSFORMFEEDBACKEXTPROC = o
    extension (v: PFNGLBEGINTRANSFORMFEEDBACKEXTPROC)
      inline def value: CFuncPtr1[GLenum, Unit] = v
      inline def toPtr: Ptr[?] = CFuncPtr.toPtr(v)

  opaque type PFNGLBEGINTRANSFORMFEEDBACKNVPROC = CFuncPtr1[GLenum, Unit]
  object PFNGLBEGINTRANSFORMFEEDBACKNVPROC:
    given _tag: Tag[PFNGLBEGINTRANSFORMFEEDBACKNVPROC] = Tag.materializeCFuncPtr1[GLenum, Unit]
    inline def fromPtr(ptr: Ptr[Byte] | Ptr[?]): PFNGLBEGINTRANSFORMFEEDBACKNVPROC = CFuncPtr.fromPtr(ptr.asInstanceOf[Ptr[Byte]])
    inline def apply(inline o: CFuncPtr1[GLenum, Unit]): PFNGLBEGINTRANSFORMFEEDBACKNVPROC = o
    extension (v: PFNGLBEGINTRANSFORMFEEDBACKNVPROC)
      inline def value: CFuncPtr1[GLenum, Unit] = v
      inline def toPtr: Ptr[?] = CFuncPtr.toPtr(v)

  opaque type PFNGLBEGINTRANSFORMFEEDBACKPROC = CFuncPtr1[GLenum, Unit]
  object PFNGLBEGINTRANSFORMFEEDBACKPROC:
    given _tag: Tag[PFNGLBEGINTRANSFORMFEEDBACKPROC] = Tag.materializeCFuncPtr1[GLenum, Unit]
    inline def fromPtr(ptr: Ptr[Byte] | Ptr[?]): PFNGLBEGINTRANSFORMFEEDBACKPROC = CFuncPtr.fromPtr(ptr.asInstanceOf[Ptr[Byte]])
    inline def apply(inline o: CFuncPtr1[GLenum, Unit]): PFNGLBEGINTRANSFORMFEEDBACKPROC = o
    extension (v: PFNGLBEGINTRANSFORMFEEDBACKPROC)
      inline def value: CFuncPtr1[GLenum, Unit] = v
      inline def toPtr: Ptr[?] = CFuncPtr.toPtr(v)

  opaque type PFNGLBEGINVERTEXSHADEREXTPROC = CFuncPtr0[Unit]
  object PFNGLBEGINVERTEXSHADEREXTPROC:
    given _tag: Tag[PFNGLBEGINVERTEXSHADEREXTPROC] = Tag.materializeCFuncPtr0[Unit]
    inline def fromPtr(ptr: Ptr[Byte] | Ptr[?]): PFNGLBEGINVERTEXSHADEREXTPROC = CFuncPtr.fromPtr(ptr.asInstanceOf[Ptr[Byte]])
    inline def apply(inline o: CFuncPtr0[Unit]): PFNGLBEGINVERTEXSHADEREXTPROC = o
    extension (v: PFNGLBEGINVERTEXSHADEREXTPROC)
      inline def value: CFuncPtr0[Unit] = v
      inline def toPtr: Ptr[?] = CFuncPtr.toPtr(v)

  opaque type PFNGLBEGINVIDEOCAPTURENVPROC = CFuncPtr1[GLuint, Unit]
  object PFNGLBEGINVIDEOCAPTURENVPROC:
    given _tag: Tag[PFNGLBEGINVIDEOCAPTURENVPROC] = Tag.materializeCFuncPtr1[GLuint, Unit]
    inline def fromPtr(ptr: Ptr[Byte] | Ptr[?]): PFNGLBEGINVIDEOCAPTURENVPROC = CFuncPtr.fromPtr(ptr.asInstanceOf[Ptr[Byte]])
    inline def apply(inline o: CFuncPtr1[GLuint, Unit]): PFNGLBEGINVIDEOCAPTURENVPROC = o
    extension (v: PFNGLBEGINVIDEOCAPTURENVPROC)
      inline def value: CFuncPtr1[GLuint, Unit] = v
      inline def toPtr: Ptr[?] = CFuncPtr.toPtr(v)

  opaque type PFNGLBINDARRAYSETEXTPROC = CFuncPtr1[Ptr[Byte], Unit]
  object PFNGLBINDARRAYSETEXTPROC:
    given _tag: Tag[PFNGLBINDARRAYSETEXTPROC] = Tag.materializeCFuncPtr1[Ptr[Byte], Unit]
    inline def fromPtr(ptr: Ptr[Byte] | Ptr[?]): PFNGLBINDARRAYSETEXTPROC = CFuncPtr.fromPtr(ptr.asInstanceOf[Ptr[Byte]])
    inline def apply(inline o: CFuncPtr1[Ptr[Byte], Unit]): PFNGLBINDARRAYSETEXTPROC = o
    extension (v: PFNGLBINDARRAYSETEXTPROC)
      inline def value: CFuncPtr1[Ptr[Byte], Unit] = v
      inline def toPtr: Ptr[?] = CFuncPtr.toPtr(v)

  opaque type PFNGLBINDATTRIBLOCATIONARBPROC = CFuncPtr3[GLhandleARB, GLuint, Ptr[GLcharARB], Unit]
  object PFNGLBINDATTRIBLOCATIONARBPROC:
    given _tag: Tag[PFNGLBINDATTRIBLOCATIONARBPROC] = Tag.materializeCFuncPtr3[GLhandleARB, GLuint, Ptr[GLcharARB], Unit]
    inline def fromPtr(ptr: Ptr[Byte] | Ptr[?]): PFNGLBINDATTRIBLOCATIONARBPROC = CFuncPtr.fromPtr(ptr.asInstanceOf[Ptr[Byte]])
    inline def apply(inline o: CFuncPtr3[GLhandleARB, GLuint, Ptr[GLcharARB], Unit]): PFNGLBINDATTRIBLOCATIONARBPROC = o
    extension (v: PFNGLBINDATTRIBLOCATIONARBPROC)
      inline def value: CFuncPtr3[GLhandleARB, GLuint, Ptr[GLcharARB], Unit] = v
      inline def toPtr: Ptr[?] = CFuncPtr.toPtr(v)

  opaque type PFNGLBINDATTRIBLOCATIONPROC = CFuncPtr3[GLuint, GLuint, Ptr[GLchar], Unit]
  object PFNGLBINDATTRIBLOCATIONPROC:
    given _tag: Tag[PFNGLBINDATTRIBLOCATIONPROC] = Tag.materializeCFuncPtr3[GLuint, GLuint, Ptr[GLchar], Unit]
    inline def fromPtr(ptr: Ptr[Byte] | Ptr[?]): PFNGLBINDATTRIBLOCATIONPROC = CFuncPtr.fromPtr(ptr.asInstanceOf[Ptr[Byte]])
    inline def apply(inline o: CFuncPtr3[GLuint, GLuint, Ptr[GLchar], Unit]): PFNGLBINDATTRIBLOCATIONPROC = o
    extension (v: PFNGLBINDATTRIBLOCATIONPROC)
      inline def value: CFuncPtr3[GLuint, GLuint, Ptr[GLchar], Unit] = v
      inline def toPtr: Ptr[?] = CFuncPtr.toPtr(v)

  opaque type PFNGLBINDBUFFERARBPROC = CFuncPtr2[GLenum, GLuint, Unit]
  object PFNGLBINDBUFFERARBPROC:
    given _tag: Tag[PFNGLBINDBUFFERARBPROC] = Tag.materializeCFuncPtr2[GLenum, GLuint, Unit]
    inline def fromPtr(ptr: Ptr[Byte] | Ptr[?]): PFNGLBINDBUFFERARBPROC = CFuncPtr.fromPtr(ptr.asInstanceOf[Ptr[Byte]])
    inline def apply(inline o: CFuncPtr2[GLenum, GLuint, Unit]): PFNGLBINDBUFFERARBPROC = o
    extension (v: PFNGLBINDBUFFERARBPROC)
      inline def value: CFuncPtr2[GLenum, GLuint, Unit] = v
      inline def toPtr: Ptr[?] = CFuncPtr.toPtr(v)

  opaque type PFNGLBINDBUFFERBASEEXTPROC = CFuncPtr3[GLenum, GLuint, GLuint, Unit]
  object PFNGLBINDBUFFERBASEEXTPROC:
    given _tag: Tag[PFNGLBINDBUFFERBASEEXTPROC] = Tag.materializeCFuncPtr3[GLenum, GLuint, GLuint, Unit]
    inline def fromPtr(ptr: Ptr[Byte] | Ptr[?]): PFNGLBINDBUFFERBASEEXTPROC = CFuncPtr.fromPtr(ptr.asInstanceOf[Ptr[Byte]])
    inline def apply(inline o: CFuncPtr3[GLenum, GLuint, GLuint, Unit]): PFNGLBINDBUFFERBASEEXTPROC = o
    extension (v: PFNGLBINDBUFFERBASEEXTPROC)
      inline def value: CFuncPtr3[GLenum, GLuint, GLuint, Unit] = v
      inline def toPtr: Ptr[?] = CFuncPtr.toPtr(v)

  opaque type PFNGLBINDBUFFERBASENVPROC = CFuncPtr3[GLenum, GLuint, GLuint, Unit]
  object PFNGLBINDBUFFERBASENVPROC:
    given _tag: Tag[PFNGLBINDBUFFERBASENVPROC] = Tag.materializeCFuncPtr3[GLenum, GLuint, GLuint, Unit]
    inline def fromPtr(ptr: Ptr[Byte] | Ptr[?]): PFNGLBINDBUFFERBASENVPROC = CFuncPtr.fromPtr(ptr.asInstanceOf[Ptr[Byte]])
    inline def apply(inline o: CFuncPtr3[GLenum, GLuint, GLuint, Unit]): PFNGLBINDBUFFERBASENVPROC = o
    extension (v: PFNGLBINDBUFFERBASENVPROC)
      inline def value: CFuncPtr3[GLenum, GLuint, GLuint, Unit] = v
      inline def toPtr: Ptr[?] = CFuncPtr.toPtr(v)

  opaque type PFNGLBINDBUFFERBASEPROC = CFuncPtr3[GLenum, GLuint, GLuint, Unit]
  object PFNGLBINDBUFFERBASEPROC:
    given _tag: Tag[PFNGLBINDBUFFERBASEPROC] = Tag.materializeCFuncPtr3[GLenum, GLuint, GLuint, Unit]
    inline def fromPtr(ptr: Ptr[Byte] | Ptr[?]): PFNGLBINDBUFFERBASEPROC = CFuncPtr.fromPtr(ptr.asInstanceOf[Ptr[Byte]])
    inline def apply(inline o: CFuncPtr3[GLenum, GLuint, GLuint, Unit]): PFNGLBINDBUFFERBASEPROC = o
    extension (v: PFNGLBINDBUFFERBASEPROC)
      inline def value: CFuncPtr3[GLenum, GLuint, GLuint, Unit] = v
      inline def toPtr: Ptr[?] = CFuncPtr.toPtr(v)

  opaque type PFNGLBINDBUFFEROFFSETEXTPROC = CFuncPtr4[GLenum, GLuint, GLuint, GLintptr, Unit]
  object PFNGLBINDBUFFEROFFSETEXTPROC:
    given _tag: Tag[PFNGLBINDBUFFEROFFSETEXTPROC] = Tag.materializeCFuncPtr4[GLenum, GLuint, GLuint, GLintptr, Unit]
    inline def fromPtr(ptr: Ptr[Byte] | Ptr[?]): PFNGLBINDBUFFEROFFSETEXTPROC = CFuncPtr.fromPtr(ptr.asInstanceOf[Ptr[Byte]])
    inline def apply(inline o: CFuncPtr4[GLenum, GLuint, GLuint, GLintptr, Unit]): PFNGLBINDBUFFEROFFSETEXTPROC = o
    extension (v: PFNGLBINDBUFFEROFFSETEXTPROC)
      inline def value: CFuncPtr4[GLenum, GLuint, GLuint, GLintptr, Unit] = v
      inline def toPtr: Ptr[?] = CFuncPtr.toPtr(v)

  opaque type PFNGLBINDBUFFEROFFSETNVPROC = CFuncPtr4[GLenum, GLuint, GLuint, GLintptr, Unit]
  object PFNGLBINDBUFFEROFFSETNVPROC:
    given _tag: Tag[PFNGLBINDBUFFEROFFSETNVPROC] = Tag.materializeCFuncPtr4[GLenum, GLuint, GLuint, GLintptr, Unit]
    inline def fromPtr(ptr: Ptr[Byte] | Ptr[?]): PFNGLBINDBUFFEROFFSETNVPROC = CFuncPtr.fromPtr(ptr.asInstanceOf[Ptr[Byte]])
    inline def apply(inline o: CFuncPtr4[GLenum, GLuint, GLuint, GLintptr, Unit]): PFNGLBINDBUFFEROFFSETNVPROC = o
    extension (v: PFNGLBINDBUFFEROFFSETNVPROC)
      inline def value: CFuncPtr4[GLenum, GLuint, GLuint, GLintptr, Unit] = v
      inline def toPtr: Ptr[?] = CFuncPtr.toPtr(v)

  opaque type PFNGLBINDBUFFERPROC = CFuncPtr2[GLenum, GLuint, Unit]
  object PFNGLBINDBUFFERPROC:
    given _tag: Tag[PFNGLBINDBUFFERPROC] = Tag.materializeCFuncPtr2[GLenum, GLuint, Unit]
    inline def fromPtr(ptr: Ptr[Byte] | Ptr[?]): PFNGLBINDBUFFERPROC = CFuncPtr.fromPtr(ptr.asInstanceOf[Ptr[Byte]])
    inline def apply(inline o: CFuncPtr2[GLenum, GLuint, Unit]): PFNGLBINDBUFFERPROC = o
    extension (v: PFNGLBINDBUFFERPROC)
      inline def value: CFuncPtr2[GLenum, GLuint, Unit] = v
      inline def toPtr: Ptr[?] = CFuncPtr.toPtr(v)

  opaque type PFNGLBINDBUFFERRANGEEXTPROC = CFuncPtr5[GLenum, GLuint, GLuint, GLintptr, GLsizeiptr, Unit]
  object PFNGLBINDBUFFERRANGEEXTPROC:
    given _tag: Tag[PFNGLBINDBUFFERRANGEEXTPROC] = Tag.materializeCFuncPtr5[GLenum, GLuint, GLuint, GLintptr, GLsizeiptr, Unit]
    inline def fromPtr(ptr: Ptr[Byte] | Ptr[?]): PFNGLBINDBUFFERRANGEEXTPROC = CFuncPtr.fromPtr(ptr.asInstanceOf[Ptr[Byte]])
    inline def apply(inline o: CFuncPtr5[GLenum, GLuint, GLuint, GLintptr, GLsizeiptr, Unit]): PFNGLBINDBUFFERRANGEEXTPROC = o
    extension (v: PFNGLBINDBUFFERRANGEEXTPROC)
      inline def value: CFuncPtr5[GLenum, GLuint, GLuint, GLintptr, GLsizeiptr, Unit] = v
      inline def toPtr: Ptr[?] = CFuncPtr.toPtr(v)

  opaque type PFNGLBINDBUFFERRANGENVPROC = CFuncPtr5[GLenum, GLuint, GLuint, GLintptr, GLsizeiptr, Unit]
  object PFNGLBINDBUFFERRANGENVPROC:
    given _tag: Tag[PFNGLBINDBUFFERRANGENVPROC] = Tag.materializeCFuncPtr5[GLenum, GLuint, GLuint, GLintptr, GLsizeiptr, Unit]
    inline def fromPtr(ptr: Ptr[Byte] | Ptr[?]): PFNGLBINDBUFFERRANGENVPROC = CFuncPtr.fromPtr(ptr.asInstanceOf[Ptr[Byte]])
    inline def apply(inline o: CFuncPtr5[GLenum, GLuint, GLuint, GLintptr, GLsizeiptr, Unit]): PFNGLBINDBUFFERRANGENVPROC = o
    extension (v: PFNGLBINDBUFFERRANGENVPROC)
      inline def value: CFuncPtr5[GLenum, GLuint, GLuint, GLintptr, GLsizeiptr, Unit] = v
      inline def toPtr: Ptr[?] = CFuncPtr.toPtr(v)

  opaque type PFNGLBINDBUFFERRANGEPROC = CFuncPtr5[GLenum, GLuint, GLuint, GLintptr, GLsizeiptr, Unit]
  object PFNGLBINDBUFFERRANGEPROC:
    given _tag: Tag[PFNGLBINDBUFFERRANGEPROC] = Tag.materializeCFuncPtr5[GLenum, GLuint, GLuint, GLintptr, GLsizeiptr, Unit]
    inline def fromPtr(ptr: Ptr[Byte] | Ptr[?]): PFNGLBINDBUFFERRANGEPROC = CFuncPtr.fromPtr(ptr.asInstanceOf[Ptr[Byte]])
    inline def apply(inline o: CFuncPtr5[GLenum, GLuint, GLuint, GLintptr, GLsizeiptr, Unit]): PFNGLBINDBUFFERRANGEPROC = o
    extension (v: PFNGLBINDBUFFERRANGEPROC)
      inline def value: CFuncPtr5[GLenum, GLuint, GLuint, GLintptr, GLsizeiptr, Unit] = v
      inline def toPtr: Ptr[?] = CFuncPtr.toPtr(v)

  opaque type PFNGLBINDBUFFERSBASEPROC = CFuncPtr4[GLenum, GLuint, GLsizei, Ptr[GLuint], Unit]
  object PFNGLBINDBUFFERSBASEPROC:
    given _tag: Tag[PFNGLBINDBUFFERSBASEPROC] = Tag.materializeCFuncPtr4[GLenum, GLuint, GLsizei, Ptr[GLuint], Unit]
    inline def fromPtr(ptr: Ptr[Byte] | Ptr[?]): PFNGLBINDBUFFERSBASEPROC = CFuncPtr.fromPtr(ptr.asInstanceOf[Ptr[Byte]])
    inline def apply(inline o: CFuncPtr4[GLenum, GLuint, GLsizei, Ptr[GLuint], Unit]): PFNGLBINDBUFFERSBASEPROC = o
    extension (v: PFNGLBINDBUFFERSBASEPROC)
      inline def value: CFuncPtr4[GLenum, GLuint, GLsizei, Ptr[GLuint], Unit] = v
      inline def toPtr: Ptr[?] = CFuncPtr.toPtr(v)

  opaque type PFNGLBINDBUFFERSRANGEPROC = CFuncPtr6[GLenum, GLuint, GLsizei, Ptr[GLuint], Ptr[GLintptr], Ptr[GLsizeiptr], Unit]
  object PFNGLBINDBUFFERSRANGEPROC:
    given _tag: Tag[PFNGLBINDBUFFERSRANGEPROC] = Tag.materializeCFuncPtr6[GLenum, GLuint, GLsizei, Ptr[GLuint], Ptr[GLintptr], Ptr[GLsizeiptr], Unit]
    inline def fromPtr(ptr: Ptr[Byte] | Ptr[?]): PFNGLBINDBUFFERSRANGEPROC = CFuncPtr.fromPtr(ptr.asInstanceOf[Ptr[Byte]])
    inline def apply(inline o: CFuncPtr6[GLenum, GLuint, GLsizei, Ptr[GLuint], Ptr[GLintptr], Ptr[GLsizeiptr], Unit]): PFNGLBINDBUFFERSRANGEPROC = o
    extension (v: PFNGLBINDBUFFERSRANGEPROC)
      inline def value: CFuncPtr6[GLenum, GLuint, GLsizei, Ptr[GLuint], Ptr[GLintptr], Ptr[GLsizeiptr], Unit] = v
      inline def toPtr: Ptr[?] = CFuncPtr.toPtr(v)

  opaque type PFNGLBINDFRAGDATALOCATIONEXTPROC = CFuncPtr3[GLuint, GLuint, Ptr[GLchar], Unit]
  object PFNGLBINDFRAGDATALOCATIONEXTPROC:
    given _tag: Tag[PFNGLBINDFRAGDATALOCATIONEXTPROC] = Tag.materializeCFuncPtr3[GLuint, GLuint, Ptr[GLchar], Unit]
    inline def fromPtr(ptr: Ptr[Byte] | Ptr[?]): PFNGLBINDFRAGDATALOCATIONEXTPROC = CFuncPtr.fromPtr(ptr.asInstanceOf[Ptr[Byte]])
    inline def apply(inline o: CFuncPtr3[GLuint, GLuint, Ptr[GLchar], Unit]): PFNGLBINDFRAGDATALOCATIONEXTPROC = o
    extension (v: PFNGLBINDFRAGDATALOCATIONEXTPROC)
      inline def value: CFuncPtr3[GLuint, GLuint, Ptr[GLchar], Unit] = v
      inline def toPtr: Ptr[?] = CFuncPtr.toPtr(v)

  opaque type PFNGLBINDFRAGDATALOCATIONINDEXEDEXTPROC = CFuncPtr4[GLuint, GLuint, GLuint, Ptr[GLchar], Unit]
  object PFNGLBINDFRAGDATALOCATIONINDEXEDEXTPROC:
    given _tag: Tag[PFNGLBINDFRAGDATALOCATIONINDEXEDEXTPROC] = Tag.materializeCFuncPtr4[GLuint, GLuint, GLuint, Ptr[GLchar], Unit]
    inline def fromPtr(ptr: Ptr[Byte] | Ptr[?]): PFNGLBINDFRAGDATALOCATIONINDEXEDEXTPROC = CFuncPtr.fromPtr(ptr.asInstanceOf[Ptr[Byte]])
    inline def apply(inline o: CFuncPtr4[GLuint, GLuint, GLuint, Ptr[GLchar], Unit]): PFNGLBINDFRAGDATALOCATIONINDEXEDEXTPROC = o
    extension (v: PFNGLBINDFRAGDATALOCATIONINDEXEDEXTPROC)
      inline def value: CFuncPtr4[GLuint, GLuint, GLuint, Ptr[GLchar], Unit] = v
      inline def toPtr: Ptr[?] = CFuncPtr.toPtr(v)

  opaque type PFNGLBINDFRAGDATALOCATIONINDEXEDPROC = CFuncPtr4[GLuint, GLuint, GLuint, Ptr[GLchar], Unit]
  object PFNGLBINDFRAGDATALOCATIONINDEXEDPROC:
    given _tag: Tag[PFNGLBINDFRAGDATALOCATIONINDEXEDPROC] = Tag.materializeCFuncPtr4[GLuint, GLuint, GLuint, Ptr[GLchar], Unit]
    inline def fromPtr(ptr: Ptr[Byte] | Ptr[?]): PFNGLBINDFRAGDATALOCATIONINDEXEDPROC = CFuncPtr.fromPtr(ptr.asInstanceOf[Ptr[Byte]])
    inline def apply(inline o: CFuncPtr4[GLuint, GLuint, GLuint, Ptr[GLchar], Unit]): PFNGLBINDFRAGDATALOCATIONINDEXEDPROC = o
    extension (v: PFNGLBINDFRAGDATALOCATIONINDEXEDPROC)
      inline def value: CFuncPtr4[GLuint, GLuint, GLuint, Ptr[GLchar], Unit] = v
      inline def toPtr: Ptr[?] = CFuncPtr.toPtr(v)

  opaque type PFNGLBINDFRAGDATALOCATIONPROC = CFuncPtr3[GLuint, GLuint, Ptr[GLchar], Unit]
  object PFNGLBINDFRAGDATALOCATIONPROC:
    given _tag: Tag[PFNGLBINDFRAGDATALOCATIONPROC] = Tag.materializeCFuncPtr3[GLuint, GLuint, Ptr[GLchar], Unit]
    inline def fromPtr(ptr: Ptr[Byte] | Ptr[?]): PFNGLBINDFRAGDATALOCATIONPROC = CFuncPtr.fromPtr(ptr.asInstanceOf[Ptr[Byte]])
    inline def apply(inline o: CFuncPtr3[GLuint, GLuint, Ptr[GLchar], Unit]): PFNGLBINDFRAGDATALOCATIONPROC = o
    extension (v: PFNGLBINDFRAGDATALOCATIONPROC)
      inline def value: CFuncPtr3[GLuint, GLuint, Ptr[GLchar], Unit] = v
      inline def toPtr: Ptr[?] = CFuncPtr.toPtr(v)

  opaque type PFNGLBINDFRAGMENTSHADERATIPROC = CFuncPtr1[GLuint, Unit]
  object PFNGLBINDFRAGMENTSHADERATIPROC:
    given _tag: Tag[PFNGLBINDFRAGMENTSHADERATIPROC] = Tag.materializeCFuncPtr1[GLuint, Unit]
    inline def fromPtr(ptr: Ptr[Byte] | Ptr[?]): PFNGLBINDFRAGMENTSHADERATIPROC = CFuncPtr.fromPtr(ptr.asInstanceOf[Ptr[Byte]])
    inline def apply(inline o: CFuncPtr1[GLuint, Unit]): PFNGLBINDFRAGMENTSHADERATIPROC = o
    extension (v: PFNGLBINDFRAGMENTSHADERATIPROC)
      inline def value: CFuncPtr1[GLuint, Unit] = v
      inline def toPtr: Ptr[?] = CFuncPtr.toPtr(v)

  opaque type PFNGLBINDFRAMEBUFFEREXTPROC = CFuncPtr2[GLenum, GLuint, Unit]
  object PFNGLBINDFRAMEBUFFEREXTPROC:
    given _tag: Tag[PFNGLBINDFRAMEBUFFEREXTPROC] = Tag.materializeCFuncPtr2[GLenum, GLuint, Unit]
    inline def fromPtr(ptr: Ptr[Byte] | Ptr[?]): PFNGLBINDFRAMEBUFFEREXTPROC = CFuncPtr.fromPtr(ptr.asInstanceOf[Ptr[Byte]])
    inline def apply(inline o: CFuncPtr2[GLenum, GLuint, Unit]): PFNGLBINDFRAMEBUFFEREXTPROC = o
    extension (v: PFNGLBINDFRAMEBUFFEREXTPROC)
      inline def value: CFuncPtr2[GLenum, GLuint, Unit] = v
      inline def toPtr: Ptr[?] = CFuncPtr.toPtr(v)

  opaque type PFNGLBINDFRAMEBUFFEROESPROC = CFuncPtr2[GLenum, GLuint, Unit]
  object PFNGLBINDFRAMEBUFFEROESPROC:
    given _tag: Tag[PFNGLBINDFRAMEBUFFEROESPROC] = Tag.materializeCFuncPtr2[GLenum, GLuint, Unit]
    inline def fromPtr(ptr: Ptr[Byte] | Ptr[?]): PFNGLBINDFRAMEBUFFEROESPROC = CFuncPtr.fromPtr(ptr.asInstanceOf[Ptr[Byte]])
    inline def apply(inline o: CFuncPtr2[GLenum, GLuint, Unit]): PFNGLBINDFRAMEBUFFEROESPROC = o
    extension (v: PFNGLBINDFRAMEBUFFEROESPROC)
      inline def value: CFuncPtr2[GLenum, GLuint, Unit] = v
      inline def toPtr: Ptr[?] = CFuncPtr.toPtr(v)

  opaque type PFNGLBINDFRAMEBUFFERPROC = CFuncPtr2[GLenum, GLuint, Unit]
  object PFNGLBINDFRAMEBUFFERPROC:
    given _tag: Tag[PFNGLBINDFRAMEBUFFERPROC] = Tag.materializeCFuncPtr2[GLenum, GLuint, Unit]
    inline def fromPtr(ptr: Ptr[Byte] | Ptr[?]): PFNGLBINDFRAMEBUFFERPROC = CFuncPtr.fromPtr(ptr.asInstanceOf[Ptr[Byte]])
    inline def apply(inline o: CFuncPtr2[GLenum, GLuint, Unit]): PFNGLBINDFRAMEBUFFERPROC = o
    extension (v: PFNGLBINDFRAMEBUFFERPROC)
      inline def value: CFuncPtr2[GLenum, GLuint, Unit] = v
      inline def toPtr: Ptr[?] = CFuncPtr.toPtr(v)

  opaque type PFNGLBINDIMAGETEXTUREEXTPROC = CFuncPtr7[GLuint, GLuint, GLint, GLboolean, GLint, GLenum, GLint, Unit]
  object PFNGLBINDIMAGETEXTUREEXTPROC:
    given _tag: Tag[PFNGLBINDIMAGETEXTUREEXTPROC] = Tag.materializeCFuncPtr7[GLuint, GLuint, GLint, GLboolean, GLint, GLenum, GLint, Unit]
    inline def fromPtr(ptr: Ptr[Byte] | Ptr[?]): PFNGLBINDIMAGETEXTUREEXTPROC = CFuncPtr.fromPtr(ptr.asInstanceOf[Ptr[Byte]])
    inline def apply(inline o: CFuncPtr7[GLuint, GLuint, GLint, GLboolean, GLint, GLenum, GLint, Unit]): PFNGLBINDIMAGETEXTUREEXTPROC = o
    extension (v: PFNGLBINDIMAGETEXTUREEXTPROC)
      inline def value: CFuncPtr7[GLuint, GLuint, GLint, GLboolean, GLint, GLenum, GLint, Unit] = v
      inline def toPtr: Ptr[?] = CFuncPtr.toPtr(v)

  opaque type PFNGLBINDIMAGETEXTUREPROC = CFuncPtr7[GLuint, GLuint, GLint, GLboolean, GLint, GLenum, GLenum, Unit]
  object PFNGLBINDIMAGETEXTUREPROC:
    given _tag: Tag[PFNGLBINDIMAGETEXTUREPROC] = Tag.materializeCFuncPtr7[GLuint, GLuint, GLint, GLboolean, GLint, GLenum, GLenum, Unit]
    inline def fromPtr(ptr: Ptr[Byte] | Ptr[?]): PFNGLBINDIMAGETEXTUREPROC = CFuncPtr.fromPtr(ptr.asInstanceOf[Ptr[Byte]])
    inline def apply(inline o: CFuncPtr7[GLuint, GLuint, GLint, GLboolean, GLint, GLenum, GLenum, Unit]): PFNGLBINDIMAGETEXTUREPROC = o
    extension (v: PFNGLBINDIMAGETEXTUREPROC)
      inline def value: CFuncPtr7[GLuint, GLuint, GLint, GLboolean, GLint, GLenum, GLenum, Unit] = v
      inline def toPtr: Ptr[?] = CFuncPtr.toPtr(v)

  opaque type PFNGLBINDIMAGETEXTURESPROC = CFuncPtr3[GLuint, GLsizei, Ptr[GLuint], Unit]
  object PFNGLBINDIMAGETEXTURESPROC:
    given _tag: Tag[PFNGLBINDIMAGETEXTURESPROC] = Tag.materializeCFuncPtr3[GLuint, GLsizei, Ptr[GLuint], Unit]
    inline def fromPtr(ptr: Ptr[Byte] | Ptr[?]): PFNGLBINDIMAGETEXTURESPROC = CFuncPtr.fromPtr(ptr.asInstanceOf[Ptr[Byte]])
    inline def apply(inline o: CFuncPtr3[GLuint, GLsizei, Ptr[GLuint], Unit]): PFNGLBINDIMAGETEXTURESPROC = o
    extension (v: PFNGLBINDIMAGETEXTURESPROC)
      inline def value: CFuncPtr3[GLuint, GLsizei, Ptr[GLuint], Unit] = v
      inline def toPtr: Ptr[?] = CFuncPtr.toPtr(v)

  opaque type PFNGLBINDLIGHTPARAMETEREXTPROC = CFuncPtr2[GLenum, GLenum, GLuint]
  object PFNGLBINDLIGHTPARAMETEREXTPROC:
    given _tag: Tag[PFNGLBINDLIGHTPARAMETEREXTPROC] = Tag.materializeCFuncPtr2[GLenum, GLenum, GLuint]
    inline def fromPtr(ptr: Ptr[Byte] | Ptr[?]): PFNGLBINDLIGHTPARAMETEREXTPROC = CFuncPtr.fromPtr(ptr.asInstanceOf[Ptr[Byte]])
    inline def apply(inline o: CFuncPtr2[GLenum, GLenum, GLuint]): PFNGLBINDLIGHTPARAMETEREXTPROC = o
    extension (v: PFNGLBINDLIGHTPARAMETEREXTPROC)
      inline def value: CFuncPtr2[GLenum, GLenum, GLuint] = v
      inline def toPtr: Ptr[?] = CFuncPtr.toPtr(v)

  opaque type PFNGLBINDMATERIALPARAMETEREXTPROC = CFuncPtr2[GLenum, GLenum, GLuint]
  object PFNGLBINDMATERIALPARAMETEREXTPROC:
    given _tag: Tag[PFNGLBINDMATERIALPARAMETEREXTPROC] = Tag.materializeCFuncPtr2[GLenum, GLenum, GLuint]
    inline def fromPtr(ptr: Ptr[Byte] | Ptr[?]): PFNGLBINDMATERIALPARAMETEREXTPROC = CFuncPtr.fromPtr(ptr.asInstanceOf[Ptr[Byte]])
    inline def apply(inline o: CFuncPtr2[GLenum, GLenum, GLuint]): PFNGLBINDMATERIALPARAMETEREXTPROC = o
    extension (v: PFNGLBINDMATERIALPARAMETEREXTPROC)
      inline def value: CFuncPtr2[GLenum, GLenum, GLuint] = v
      inline def toPtr: Ptr[?] = CFuncPtr.toPtr(v)

  opaque type PFNGLBINDMULTITEXTUREEXTPROC = CFuncPtr3[GLenum, GLenum, GLuint, Unit]
  object PFNGLBINDMULTITEXTUREEXTPROC:
    given _tag: Tag[PFNGLBINDMULTITEXTUREEXTPROC] = Tag.materializeCFuncPtr3[GLenum, GLenum, GLuint, Unit]
    inline def fromPtr(ptr: Ptr[Byte] | Ptr[?]): PFNGLBINDMULTITEXTUREEXTPROC = CFuncPtr.fromPtr(ptr.asInstanceOf[Ptr[Byte]])
    inline def apply(inline o: CFuncPtr3[GLenum, GLenum, GLuint, Unit]): PFNGLBINDMULTITEXTUREEXTPROC = o
    extension (v: PFNGLBINDMULTITEXTUREEXTPROC)
      inline def value: CFuncPtr3[GLenum, GLenum, GLuint, Unit] = v
      inline def toPtr: Ptr[?] = CFuncPtr.toPtr(v)

  opaque type PFNGLBINDPARAMETEREXTPROC = CFuncPtr1[GLenum, GLuint]
  object PFNGLBINDPARAMETEREXTPROC:
    given _tag: Tag[PFNGLBINDPARAMETEREXTPROC] = Tag.materializeCFuncPtr1[GLenum, GLuint]
    inline def fromPtr(ptr: Ptr[Byte] | Ptr[?]): PFNGLBINDPARAMETEREXTPROC = CFuncPtr.fromPtr(ptr.asInstanceOf[Ptr[Byte]])
    inline def apply(inline o: CFuncPtr1[GLenum, GLuint]): PFNGLBINDPARAMETEREXTPROC = o
    extension (v: PFNGLBINDPARAMETEREXTPROC)
      inline def value: CFuncPtr1[GLenum, GLuint] = v
      inline def toPtr: Ptr[?] = CFuncPtr.toPtr(v)

  opaque type PFNGLBINDPROGRAMARBPROC = CFuncPtr2[GLenum, GLuint, Unit]
  object PFNGLBINDPROGRAMARBPROC:
    given _tag: Tag[PFNGLBINDPROGRAMARBPROC] = Tag.materializeCFuncPtr2[GLenum, GLuint, Unit]
    inline def fromPtr(ptr: Ptr[Byte] | Ptr[?]): PFNGLBINDPROGRAMARBPROC = CFuncPtr.fromPtr(ptr.asInstanceOf[Ptr[Byte]])
    inline def apply(inline o: CFuncPtr2[GLenum, GLuint, Unit]): PFNGLBINDPROGRAMARBPROC = o
    extension (v: PFNGLBINDPROGRAMARBPROC)
      inline def value: CFuncPtr2[GLenum, GLuint, Unit] = v
      inline def toPtr: Ptr[?] = CFuncPtr.toPtr(v)

  opaque type PFNGLBINDPROGRAMNVPROC = CFuncPtr2[GLenum, GLuint, Unit]
  object PFNGLBINDPROGRAMNVPROC:
    given _tag: Tag[PFNGLBINDPROGRAMNVPROC] = Tag.materializeCFuncPtr2[GLenum, GLuint, Unit]
    inline def fromPtr(ptr: Ptr[Byte] | Ptr[?]): PFNGLBINDPROGRAMNVPROC = CFuncPtr.fromPtr(ptr.asInstanceOf[Ptr[Byte]])
    inline def apply(inline o: CFuncPtr2[GLenum, GLuint, Unit]): PFNGLBINDPROGRAMNVPROC = o
    extension (v: PFNGLBINDPROGRAMNVPROC)
      inline def value: CFuncPtr2[GLenum, GLuint, Unit] = v
      inline def toPtr: Ptr[?] = CFuncPtr.toPtr(v)

  opaque type PFNGLBINDPROGRAMPIPELINEPROC = CFuncPtr1[GLuint, Unit]
  object PFNGLBINDPROGRAMPIPELINEPROC:
    given _tag: Tag[PFNGLBINDPROGRAMPIPELINEPROC] = Tag.materializeCFuncPtr1[GLuint, Unit]
    inline def fromPtr(ptr: Ptr[Byte] | Ptr[?]): PFNGLBINDPROGRAMPIPELINEPROC = CFuncPtr.fromPtr(ptr.asInstanceOf[Ptr[Byte]])
    inline def apply(inline o: CFuncPtr1[GLuint, Unit]): PFNGLBINDPROGRAMPIPELINEPROC = o
    extension (v: PFNGLBINDPROGRAMPIPELINEPROC)
      inline def value: CFuncPtr1[GLuint, Unit] = v
      inline def toPtr: Ptr[?] = CFuncPtr.toPtr(v)

  opaque type PFNGLBINDRENDERBUFFEREXTPROC = CFuncPtr2[GLenum, GLuint, Unit]
  object PFNGLBINDRENDERBUFFEREXTPROC:
    given _tag: Tag[PFNGLBINDRENDERBUFFEREXTPROC] = Tag.materializeCFuncPtr2[GLenum, GLuint, Unit]
    inline def fromPtr(ptr: Ptr[Byte] | Ptr[?]): PFNGLBINDRENDERBUFFEREXTPROC = CFuncPtr.fromPtr(ptr.asInstanceOf[Ptr[Byte]])
    inline def apply(inline o: CFuncPtr2[GLenum, GLuint, Unit]): PFNGLBINDRENDERBUFFEREXTPROC = o
    extension (v: PFNGLBINDRENDERBUFFEREXTPROC)
      inline def value: CFuncPtr2[GLenum, GLuint, Unit] = v
      inline def toPtr: Ptr[?] = CFuncPtr.toPtr(v)

  opaque type PFNGLBINDRENDERBUFFEROESPROC = CFuncPtr2[GLenum, GLuint, Unit]
  object PFNGLBINDRENDERBUFFEROESPROC:
    given _tag: Tag[PFNGLBINDRENDERBUFFEROESPROC] = Tag.materializeCFuncPtr2[GLenum, GLuint, Unit]
    inline def fromPtr(ptr: Ptr[Byte] | Ptr[?]): PFNGLBINDRENDERBUFFEROESPROC = CFuncPtr.fromPtr(ptr.asInstanceOf[Ptr[Byte]])
    inline def apply(inline o: CFuncPtr2[GLenum, GLuint, Unit]): PFNGLBINDRENDERBUFFEROESPROC = o
    extension (v: PFNGLBINDRENDERBUFFEROESPROC)
      inline def value: CFuncPtr2[GLenum, GLuint, Unit] = v
      inline def toPtr: Ptr[?] = CFuncPtr.toPtr(v)

  opaque type PFNGLBINDRENDERBUFFERPROC = CFuncPtr2[GLenum, GLuint, Unit]
  object PFNGLBINDRENDERBUFFERPROC:
    given _tag: Tag[PFNGLBINDRENDERBUFFERPROC] = Tag.materializeCFuncPtr2[GLenum, GLuint, Unit]
    inline def fromPtr(ptr: Ptr[Byte] | Ptr[?]): PFNGLBINDRENDERBUFFERPROC = CFuncPtr.fromPtr(ptr.asInstanceOf[Ptr[Byte]])
    inline def apply(inline o: CFuncPtr2[GLenum, GLuint, Unit]): PFNGLBINDRENDERBUFFERPROC = o
    extension (v: PFNGLBINDRENDERBUFFERPROC)
      inline def value: CFuncPtr2[GLenum, GLuint, Unit] = v
      inline def toPtr: Ptr[?] = CFuncPtr.toPtr(v)

  opaque type PFNGLBINDSAMPLERPROC = CFuncPtr2[GLuint, GLuint, Unit]
  object PFNGLBINDSAMPLERPROC:
    given _tag: Tag[PFNGLBINDSAMPLERPROC] = Tag.materializeCFuncPtr2[GLuint, GLuint, Unit]
    inline def fromPtr(ptr: Ptr[Byte] | Ptr[?]): PFNGLBINDSAMPLERPROC = CFuncPtr.fromPtr(ptr.asInstanceOf[Ptr[Byte]])
    inline def apply(inline o: CFuncPtr2[GLuint, GLuint, Unit]): PFNGLBINDSAMPLERPROC = o
    extension (v: PFNGLBINDSAMPLERPROC)
      inline def value: CFuncPtr2[GLuint, GLuint, Unit] = v
      inline def toPtr: Ptr[?] = CFuncPtr.toPtr(v)

  opaque type PFNGLBINDSAMPLERSPROC = CFuncPtr3[GLuint, GLsizei, Ptr[GLuint], Unit]
  object PFNGLBINDSAMPLERSPROC:
    given _tag: Tag[PFNGLBINDSAMPLERSPROC] = Tag.materializeCFuncPtr3[GLuint, GLsizei, Ptr[GLuint], Unit]
    inline def fromPtr(ptr: Ptr[Byte] | Ptr[?]): PFNGLBINDSAMPLERSPROC = CFuncPtr.fromPtr(ptr.asInstanceOf[Ptr[Byte]])
    inline def apply(inline o: CFuncPtr3[GLuint, GLsizei, Ptr[GLuint], Unit]): PFNGLBINDSAMPLERSPROC = o
    extension (v: PFNGLBINDSAMPLERSPROC)
      inline def value: CFuncPtr3[GLuint, GLsizei, Ptr[GLuint], Unit] = v
      inline def toPtr: Ptr[?] = CFuncPtr.toPtr(v)

  opaque type PFNGLBINDSHADINGRATEIMAGENVPROC = CFuncPtr1[GLuint, Unit]
  object PFNGLBINDSHADINGRATEIMAGENVPROC:
    given _tag: Tag[PFNGLBINDSHADINGRATEIMAGENVPROC] = Tag.materializeCFuncPtr1[GLuint, Unit]
    inline def fromPtr(ptr: Ptr[Byte] | Ptr[?]): PFNGLBINDSHADINGRATEIMAGENVPROC = CFuncPtr.fromPtr(ptr.asInstanceOf[Ptr[Byte]])
    inline def apply(inline o: CFuncPtr1[GLuint, Unit]): PFNGLBINDSHADINGRATEIMAGENVPROC = o
    extension (v: PFNGLBINDSHADINGRATEIMAGENVPROC)
      inline def value: CFuncPtr1[GLuint, Unit] = v
      inline def toPtr: Ptr[?] = CFuncPtr.toPtr(v)

  opaque type PFNGLBINDTEXGENPARAMETEREXTPROC = CFuncPtr3[GLenum, GLenum, GLenum, GLuint]
  object PFNGLBINDTEXGENPARAMETEREXTPROC:
    given _tag: Tag[PFNGLBINDTEXGENPARAMETEREXTPROC] = Tag.materializeCFuncPtr3[GLenum, GLenum, GLenum, GLuint]
    inline def fromPtr(ptr: Ptr[Byte] | Ptr[?]): PFNGLBINDTEXGENPARAMETEREXTPROC = CFuncPtr.fromPtr(ptr.asInstanceOf[Ptr[Byte]])
    inline def apply(inline o: CFuncPtr3[GLenum, GLenum, GLenum, GLuint]): PFNGLBINDTEXGENPARAMETEREXTPROC = o
    extension (v: PFNGLBINDTEXGENPARAMETEREXTPROC)
      inline def value: CFuncPtr3[GLenum, GLenum, GLenum, GLuint] = v
      inline def toPtr: Ptr[?] = CFuncPtr.toPtr(v)

  opaque type PFNGLBINDTEXTUREEXTPROC = CFuncPtr2[GLenum, GLuint, Unit]
  object PFNGLBINDTEXTUREEXTPROC:
    given _tag: Tag[PFNGLBINDTEXTUREEXTPROC] = Tag.materializeCFuncPtr2[GLenum, GLuint, Unit]
    inline def fromPtr(ptr: Ptr[Byte] | Ptr[?]): PFNGLBINDTEXTUREEXTPROC = CFuncPtr.fromPtr(ptr.asInstanceOf[Ptr[Byte]])
    inline def apply(inline o: CFuncPtr2[GLenum, GLuint, Unit]): PFNGLBINDTEXTUREEXTPROC = o
    extension (v: PFNGLBINDTEXTUREEXTPROC)
      inline def value: CFuncPtr2[GLenum, GLuint, Unit] = v
      inline def toPtr: Ptr[?] = CFuncPtr.toPtr(v)

  opaque type PFNGLBINDTEXTURESPROC = CFuncPtr3[GLuint, GLsizei, Ptr[GLuint], Unit]
  object PFNGLBINDTEXTURESPROC:
    given _tag: Tag[PFNGLBINDTEXTURESPROC] = Tag.materializeCFuncPtr3[GLuint, GLsizei, Ptr[GLuint], Unit]
    inline def fromPtr(ptr: Ptr[Byte] | Ptr[?]): PFNGLBINDTEXTURESPROC = CFuncPtr.fromPtr(ptr.asInstanceOf[Ptr[Byte]])
    inline def apply(inline o: CFuncPtr3[GLuint, GLsizei, Ptr[GLuint], Unit]): PFNGLBINDTEXTURESPROC = o
    extension (v: PFNGLBINDTEXTURESPROC)
      inline def value: CFuncPtr3[GLuint, GLsizei, Ptr[GLuint], Unit] = v
      inline def toPtr: Ptr[?] = CFuncPtr.toPtr(v)

  opaque type PFNGLBINDTEXTUREUNITPARAMETEREXTPROC = CFuncPtr2[GLenum, GLenum, GLuint]
  object PFNGLBINDTEXTUREUNITPARAMETEREXTPROC:
    given _tag: Tag[PFNGLBINDTEXTUREUNITPARAMETEREXTPROC] = Tag.materializeCFuncPtr2[GLenum, GLenum, GLuint]
    inline def fromPtr(ptr: Ptr[Byte] | Ptr[?]): PFNGLBINDTEXTUREUNITPARAMETEREXTPROC = CFuncPtr.fromPtr(ptr.asInstanceOf[Ptr[Byte]])
    inline def apply(inline o: CFuncPtr2[GLenum, GLenum, GLuint]): PFNGLBINDTEXTUREUNITPARAMETEREXTPROC = o
    extension (v: PFNGLBINDTEXTUREUNITPARAMETEREXTPROC)
      inline def value: CFuncPtr2[GLenum, GLenum, GLuint] = v
      inline def toPtr: Ptr[?] = CFuncPtr.toPtr(v)

  opaque type PFNGLBINDTEXTUREUNITPROC = CFuncPtr2[GLuint, GLuint, Unit]
  object PFNGLBINDTEXTUREUNITPROC:
    given _tag: Tag[PFNGLBINDTEXTUREUNITPROC] = Tag.materializeCFuncPtr2[GLuint, GLuint, Unit]
    inline def fromPtr(ptr: Ptr[Byte] | Ptr[?]): PFNGLBINDTEXTUREUNITPROC = CFuncPtr.fromPtr(ptr.asInstanceOf[Ptr[Byte]])
    inline def apply(inline o: CFuncPtr2[GLuint, GLuint, Unit]): PFNGLBINDTEXTUREUNITPROC = o
    extension (v: PFNGLBINDTEXTUREUNITPROC)
      inline def value: CFuncPtr2[GLuint, GLuint, Unit] = v
      inline def toPtr: Ptr[?] = CFuncPtr.toPtr(v)

  opaque type PFNGLBINDTRANSFORMFEEDBACKNVPROC = CFuncPtr2[GLenum, GLuint, Unit]
  object PFNGLBINDTRANSFORMFEEDBACKNVPROC:
    given _tag: Tag[PFNGLBINDTRANSFORMFEEDBACKNVPROC] = Tag.materializeCFuncPtr2[GLenum, GLuint, Unit]
    inline def fromPtr(ptr: Ptr[Byte] | Ptr[?]): PFNGLBINDTRANSFORMFEEDBACKNVPROC = CFuncPtr.fromPtr(ptr.asInstanceOf[Ptr[Byte]])
    inline def apply(inline o: CFuncPtr2[GLenum, GLuint, Unit]): PFNGLBINDTRANSFORMFEEDBACKNVPROC = o
    extension (v: PFNGLBINDTRANSFORMFEEDBACKNVPROC)
      inline def value: CFuncPtr2[GLenum, GLuint, Unit] = v
      inline def toPtr: Ptr[?] = CFuncPtr.toPtr(v)

  opaque type PFNGLBINDTRANSFORMFEEDBACKPROC = CFuncPtr2[GLenum, GLuint, Unit]
  object PFNGLBINDTRANSFORMFEEDBACKPROC:
    given _tag: Tag[PFNGLBINDTRANSFORMFEEDBACKPROC] = Tag.materializeCFuncPtr2[GLenum, GLuint, Unit]
    inline def fromPtr(ptr: Ptr[Byte] | Ptr[?]): PFNGLBINDTRANSFORMFEEDBACKPROC = CFuncPtr.fromPtr(ptr.asInstanceOf[Ptr[Byte]])
    inline def apply(inline o: CFuncPtr2[GLenum, GLuint, Unit]): PFNGLBINDTRANSFORMFEEDBACKPROC = o
    extension (v: PFNGLBINDTRANSFORMFEEDBACKPROC)
      inline def value: CFuncPtr2[GLenum, GLuint, Unit] = v
      inline def toPtr: Ptr[?] = CFuncPtr.toPtr(v)

  opaque type PFNGLBINDVERTEXARRAYAPPLEPROC = CFuncPtr1[GLuint, Unit]
  object PFNGLBINDVERTEXARRAYAPPLEPROC:
    given _tag: Tag[PFNGLBINDVERTEXARRAYAPPLEPROC] = Tag.materializeCFuncPtr1[GLuint, Unit]
    inline def fromPtr(ptr: Ptr[Byte] | Ptr[?]): PFNGLBINDVERTEXARRAYAPPLEPROC = CFuncPtr.fromPtr(ptr.asInstanceOf[Ptr[Byte]])
    inline def apply(inline o: CFuncPtr1[GLuint, Unit]): PFNGLBINDVERTEXARRAYAPPLEPROC = o
    extension (v: PFNGLBINDVERTEXARRAYAPPLEPROC)
      inline def value: CFuncPtr1[GLuint, Unit] = v
      inline def toPtr: Ptr[?] = CFuncPtr.toPtr(v)

  opaque type PFNGLBINDVERTEXARRAYOESPROC = CFuncPtr1[GLuint, Unit]
  object PFNGLBINDVERTEXARRAYOESPROC:
    given _tag: Tag[PFNGLBINDVERTEXARRAYOESPROC] = Tag.materializeCFuncPtr1[GLuint, Unit]
    inline def fromPtr(ptr: Ptr[Byte] | Ptr[?]): PFNGLBINDVERTEXARRAYOESPROC = CFuncPtr.fromPtr(ptr.asInstanceOf[Ptr[Byte]])
    inline def apply(inline o: CFuncPtr1[GLuint, Unit]): PFNGLBINDVERTEXARRAYOESPROC = o
    extension (v: PFNGLBINDVERTEXARRAYOESPROC)
      inline def value: CFuncPtr1[GLuint, Unit] = v
      inline def toPtr: Ptr[?] = CFuncPtr.toPtr(v)

  opaque type PFNGLBINDVERTEXARRAYPROC = CFuncPtr1[GLuint, Unit]
  object PFNGLBINDVERTEXARRAYPROC:
    given _tag: Tag[PFNGLBINDVERTEXARRAYPROC] = Tag.materializeCFuncPtr1[GLuint, Unit]
    inline def fromPtr(ptr: Ptr[Byte] | Ptr[?]): PFNGLBINDVERTEXARRAYPROC = CFuncPtr.fromPtr(ptr.asInstanceOf[Ptr[Byte]])
    inline def apply(inline o: CFuncPtr1[GLuint, Unit]): PFNGLBINDVERTEXARRAYPROC = o
    extension (v: PFNGLBINDVERTEXARRAYPROC)
      inline def value: CFuncPtr1[GLuint, Unit] = v
      inline def toPtr: Ptr[?] = CFuncPtr.toPtr(v)

  opaque type PFNGLBINDVERTEXARRAYSGIXPROC = CFuncPtr1[GLuint, Unit]
  object PFNGLBINDVERTEXARRAYSGIXPROC:
    given _tag: Tag[PFNGLBINDVERTEXARRAYSGIXPROC] = Tag.materializeCFuncPtr1[GLuint, Unit]
    inline def fromPtr(ptr: Ptr[Byte] | Ptr[?]): PFNGLBINDVERTEXARRAYSGIXPROC = CFuncPtr.fromPtr(ptr.asInstanceOf[Ptr[Byte]])
    inline def apply(inline o: CFuncPtr1[GLuint, Unit]): PFNGLBINDVERTEXARRAYSGIXPROC = o
    extension (v: PFNGLBINDVERTEXARRAYSGIXPROC)
      inline def value: CFuncPtr1[GLuint, Unit] = v
      inline def toPtr: Ptr[?] = CFuncPtr.toPtr(v)

  opaque type PFNGLBINDVERTEXBUFFERPROC = CFuncPtr4[GLuint, GLuint, GLintptr, GLsizei, Unit]
  object PFNGLBINDVERTEXBUFFERPROC:
    given _tag: Tag[PFNGLBINDVERTEXBUFFERPROC] = Tag.materializeCFuncPtr4[GLuint, GLuint, GLintptr, GLsizei, Unit]
    inline def fromPtr(ptr: Ptr[Byte] | Ptr[?]): PFNGLBINDVERTEXBUFFERPROC = CFuncPtr.fromPtr(ptr.asInstanceOf[Ptr[Byte]])
    inline def apply(inline o: CFuncPtr4[GLuint, GLuint, GLintptr, GLsizei, Unit]): PFNGLBINDVERTEXBUFFERPROC = o
    extension (v: PFNGLBINDVERTEXBUFFERPROC)
      inline def value: CFuncPtr4[GLuint, GLuint, GLintptr, GLsizei, Unit] = v
      inline def toPtr: Ptr[?] = CFuncPtr.toPtr(v)

  opaque type PFNGLBINDVERTEXBUFFERSPROC = CFuncPtr5[GLuint, GLsizei, Ptr[GLuint], Ptr[GLintptr], Ptr[GLsizei], Unit]
  object PFNGLBINDVERTEXBUFFERSPROC:
    given _tag: Tag[PFNGLBINDVERTEXBUFFERSPROC] = Tag.materializeCFuncPtr5[GLuint, GLsizei, Ptr[GLuint], Ptr[GLintptr], Ptr[GLsizei], Unit]
    inline def fromPtr(ptr: Ptr[Byte] | Ptr[?]): PFNGLBINDVERTEXBUFFERSPROC = CFuncPtr.fromPtr(ptr.asInstanceOf[Ptr[Byte]])
    inline def apply(inline o: CFuncPtr5[GLuint, GLsizei, Ptr[GLuint], Ptr[GLintptr], Ptr[GLsizei], Unit]): PFNGLBINDVERTEXBUFFERSPROC = o
    extension (v: PFNGLBINDVERTEXBUFFERSPROC)
      inline def value: CFuncPtr5[GLuint, GLsizei, Ptr[GLuint], Ptr[GLintptr], Ptr[GLsizei], Unit] = v
      inline def toPtr: Ptr[?] = CFuncPtr.toPtr(v)

  opaque type PFNGLBINDVERTEXSHADEREXTPROC = CFuncPtr1[GLuint, Unit]
  object PFNGLBINDVERTEXSHADEREXTPROC:
    given _tag: Tag[PFNGLBINDVERTEXSHADEREXTPROC] = Tag.materializeCFuncPtr1[GLuint, Unit]
    inline def fromPtr(ptr: Ptr[Byte] | Ptr[?]): PFNGLBINDVERTEXSHADEREXTPROC = CFuncPtr.fromPtr(ptr.asInstanceOf[Ptr[Byte]])
    inline def apply(inline o: CFuncPtr1[GLuint, Unit]): PFNGLBINDVERTEXSHADEREXTPROC = o
    extension (v: PFNGLBINDVERTEXSHADEREXTPROC)
      inline def value: CFuncPtr1[GLuint, Unit] = v
      inline def toPtr: Ptr[?] = CFuncPtr.toPtr(v)

  opaque type PFNGLBINDVIDEOCAPTURESTREAMBUFFERNVPROC = CFuncPtr4[GLuint, GLuint, GLenum, GLintptrARB, Unit]
  object PFNGLBINDVIDEOCAPTURESTREAMBUFFERNVPROC:
    given _tag: Tag[PFNGLBINDVIDEOCAPTURESTREAMBUFFERNVPROC] = Tag.materializeCFuncPtr4[GLuint, GLuint, GLenum, GLintptrARB, Unit]
    inline def fromPtr(ptr: Ptr[Byte] | Ptr[?]): PFNGLBINDVIDEOCAPTURESTREAMBUFFERNVPROC = CFuncPtr.fromPtr(ptr.asInstanceOf[Ptr[Byte]])
    inline def apply(inline o: CFuncPtr4[GLuint, GLuint, GLenum, GLintptrARB, Unit]): PFNGLBINDVIDEOCAPTURESTREAMBUFFERNVPROC = o
    extension (v: PFNGLBINDVIDEOCAPTURESTREAMBUFFERNVPROC)
      inline def value: CFuncPtr4[GLuint, GLuint, GLenum, GLintptrARB, Unit] = v
      inline def toPtr: Ptr[?] = CFuncPtr.toPtr(v)

  opaque type PFNGLBINDVIDEOCAPTURESTREAMTEXTURENVPROC = CFuncPtr5[GLuint, GLuint, GLenum, GLenum, GLuint, Unit]
  object PFNGLBINDVIDEOCAPTURESTREAMTEXTURENVPROC:
    given _tag: Tag[PFNGLBINDVIDEOCAPTURESTREAMTEXTURENVPROC] = Tag.materializeCFuncPtr5[GLuint, GLuint, GLenum, GLenum, GLuint, Unit]
    inline def fromPtr(ptr: Ptr[Byte] | Ptr[?]): PFNGLBINDVIDEOCAPTURESTREAMTEXTURENVPROC = CFuncPtr.fromPtr(ptr.asInstanceOf[Ptr[Byte]])
    inline def apply(inline o: CFuncPtr5[GLuint, GLuint, GLenum, GLenum, GLuint, Unit]): PFNGLBINDVIDEOCAPTURESTREAMTEXTURENVPROC = o
    extension (v: PFNGLBINDVIDEOCAPTURESTREAMTEXTURENVPROC)
      inline def value: CFuncPtr5[GLuint, GLuint, GLenum, GLenum, GLuint, Unit] = v
      inline def toPtr: Ptr[?] = CFuncPtr.toPtr(v)

  opaque type PFNGLBINORMALPOINTEREXTPROC = CFuncPtr3[GLenum, GLsizei, Ptr[Byte], Unit]
  object PFNGLBINORMALPOINTEREXTPROC:
    given _tag: Tag[PFNGLBINORMALPOINTEREXTPROC] = Tag.materializeCFuncPtr3[GLenum, GLsizei, Ptr[Byte], Unit]
    inline def fromPtr(ptr: Ptr[Byte] | Ptr[?]): PFNGLBINORMALPOINTEREXTPROC = CFuncPtr.fromPtr(ptr.asInstanceOf[Ptr[Byte]])
    inline def apply(inline o: CFuncPtr3[GLenum, GLsizei, Ptr[Byte], Unit]): PFNGLBINORMALPOINTEREXTPROC = o
    extension (v: PFNGLBINORMALPOINTEREXTPROC)
      inline def value: CFuncPtr3[GLenum, GLsizei, Ptr[Byte], Unit] = v
      inline def toPtr: Ptr[?] = CFuncPtr.toPtr(v)

  opaque type PFNGLBLENDBARRIERKHRPROC = CFuncPtr0[Unit]
  object PFNGLBLENDBARRIERKHRPROC:
    given _tag: Tag[PFNGLBLENDBARRIERKHRPROC] = Tag.materializeCFuncPtr0[Unit]
    inline def fromPtr(ptr: Ptr[Byte] | Ptr[?]): PFNGLBLENDBARRIERKHRPROC = CFuncPtr.fromPtr(ptr.asInstanceOf[Ptr[Byte]])
    inline def apply(inline o: CFuncPtr0[Unit]): PFNGLBLENDBARRIERKHRPROC = o
    extension (v: PFNGLBLENDBARRIERKHRPROC)
      inline def value: CFuncPtr0[Unit] = v
      inline def toPtr: Ptr[?] = CFuncPtr.toPtr(v)

  opaque type PFNGLBLENDBARRIERNVPROC = CFuncPtr0[Unit]
  object PFNGLBLENDBARRIERNVPROC:
    given _tag: Tag[PFNGLBLENDBARRIERNVPROC] = Tag.materializeCFuncPtr0[Unit]
    inline def fromPtr(ptr: Ptr[Byte] | Ptr[?]): PFNGLBLENDBARRIERNVPROC = CFuncPtr.fromPtr(ptr.asInstanceOf[Ptr[Byte]])
    inline def apply(inline o: CFuncPtr0[Unit]): PFNGLBLENDBARRIERNVPROC = o
    extension (v: PFNGLBLENDBARRIERNVPROC)
      inline def value: CFuncPtr0[Unit] = v
      inline def toPtr: Ptr[?] = CFuncPtr.toPtr(v)

  opaque type PFNGLBLENDCOLOREXTPROC = CFuncPtr4[GLclampf, GLclampf, GLclampf, GLclampf, Unit]
  object PFNGLBLENDCOLOREXTPROC:
    given _tag: Tag[PFNGLBLENDCOLOREXTPROC] = Tag.materializeCFuncPtr4[GLclampf, GLclampf, GLclampf, GLclampf, Unit]
    inline def fromPtr(ptr: Ptr[Byte] | Ptr[?]): PFNGLBLENDCOLOREXTPROC = CFuncPtr.fromPtr(ptr.asInstanceOf[Ptr[Byte]])
    inline def apply(inline o: CFuncPtr4[GLclampf, GLclampf, GLclampf, GLclampf, Unit]): PFNGLBLENDCOLOREXTPROC = o
    extension (v: PFNGLBLENDCOLOREXTPROC)
      inline def value: CFuncPtr4[GLclampf, GLclampf, GLclampf, GLclampf, Unit] = v
      inline def toPtr: Ptr[?] = CFuncPtr.toPtr(v)

  opaque type PFNGLBLENDCOLORPROC = CFuncPtr4[GLclampf, GLclampf, GLclampf, GLclampf, Unit]
  object PFNGLBLENDCOLORPROC:
    given _tag: Tag[PFNGLBLENDCOLORPROC] = Tag.materializeCFuncPtr4[GLclampf, GLclampf, GLclampf, GLclampf, Unit]
    inline def fromPtr(ptr: Ptr[Byte] | Ptr[?]): PFNGLBLENDCOLORPROC = CFuncPtr.fromPtr(ptr.asInstanceOf[Ptr[Byte]])
    inline def apply(inline o: CFuncPtr4[GLclampf, GLclampf, GLclampf, GLclampf, Unit]): PFNGLBLENDCOLORPROC = o
    extension (v: PFNGLBLENDCOLORPROC)
      inline def value: CFuncPtr4[GLclampf, GLclampf, GLclampf, GLclampf, Unit] = v
      inline def toPtr: Ptr[?] = CFuncPtr.toPtr(v)

  opaque type PFNGLBLENDEQUATIONEXTPROC = CFuncPtr1[GLenum, Unit]
  object PFNGLBLENDEQUATIONEXTPROC:
    given _tag: Tag[PFNGLBLENDEQUATIONEXTPROC] = Tag.materializeCFuncPtr1[GLenum, Unit]
    inline def fromPtr(ptr: Ptr[Byte] | Ptr[?]): PFNGLBLENDEQUATIONEXTPROC = CFuncPtr.fromPtr(ptr.asInstanceOf[Ptr[Byte]])
    inline def apply(inline o: CFuncPtr1[GLenum, Unit]): PFNGLBLENDEQUATIONEXTPROC = o
    extension (v: PFNGLBLENDEQUATIONEXTPROC)
      inline def value: CFuncPtr1[GLenum, Unit] = v
      inline def toPtr: Ptr[?] = CFuncPtr.toPtr(v)

  opaque type PFNGLBLENDEQUATIONIARBPROC = CFuncPtr2[GLuint, GLenum, Unit]
  object PFNGLBLENDEQUATIONIARBPROC:
    given _tag: Tag[PFNGLBLENDEQUATIONIARBPROC] = Tag.materializeCFuncPtr2[GLuint, GLenum, Unit]
    inline def fromPtr(ptr: Ptr[Byte] | Ptr[?]): PFNGLBLENDEQUATIONIARBPROC = CFuncPtr.fromPtr(ptr.asInstanceOf[Ptr[Byte]])
    inline def apply(inline o: CFuncPtr2[GLuint, GLenum, Unit]): PFNGLBLENDEQUATIONIARBPROC = o
    extension (v: PFNGLBLENDEQUATIONIARBPROC)
      inline def value: CFuncPtr2[GLuint, GLenum, Unit] = v
      inline def toPtr: Ptr[?] = CFuncPtr.toPtr(v)

  opaque type PFNGLBLENDEQUATIONIEXTPROC = CFuncPtr2[GLuint, GLenum, Unit]
  object PFNGLBLENDEQUATIONIEXTPROC:
    given _tag: Tag[PFNGLBLENDEQUATIONIEXTPROC] = Tag.materializeCFuncPtr2[GLuint, GLenum, Unit]
    inline def fromPtr(ptr: Ptr[Byte] | Ptr[?]): PFNGLBLENDEQUATIONIEXTPROC = CFuncPtr.fromPtr(ptr.asInstanceOf[Ptr[Byte]])
    inline def apply(inline o: CFuncPtr2[GLuint, GLenum, Unit]): PFNGLBLENDEQUATIONIEXTPROC = o
    extension (v: PFNGLBLENDEQUATIONIEXTPROC)
      inline def value: CFuncPtr2[GLuint, GLenum, Unit] = v
      inline def toPtr: Ptr[?] = CFuncPtr.toPtr(v)

  opaque type PFNGLBLENDEQUATIONINDEXEDAMDPROC = CFuncPtr2[GLuint, GLenum, Unit]
  object PFNGLBLENDEQUATIONINDEXEDAMDPROC:
    given _tag: Tag[PFNGLBLENDEQUATIONINDEXEDAMDPROC] = Tag.materializeCFuncPtr2[GLuint, GLenum, Unit]
    inline def fromPtr(ptr: Ptr[Byte] | Ptr[?]): PFNGLBLENDEQUATIONINDEXEDAMDPROC = CFuncPtr.fromPtr(ptr.asInstanceOf[Ptr[Byte]])
    inline def apply(inline o: CFuncPtr2[GLuint, GLenum, Unit]): PFNGLBLENDEQUATIONINDEXEDAMDPROC = o
    extension (v: PFNGLBLENDEQUATIONINDEXEDAMDPROC)
      inline def value: CFuncPtr2[GLuint, GLenum, Unit] = v
      inline def toPtr: Ptr[?] = CFuncPtr.toPtr(v)

  opaque type PFNGLBLENDEQUATIONIOESPROC = CFuncPtr2[GLuint, GLenum, Unit]
  object PFNGLBLENDEQUATIONIOESPROC:
    given _tag: Tag[PFNGLBLENDEQUATIONIOESPROC] = Tag.materializeCFuncPtr2[GLuint, GLenum, Unit]
    inline def fromPtr(ptr: Ptr[Byte] | Ptr[?]): PFNGLBLENDEQUATIONIOESPROC = CFuncPtr.fromPtr(ptr.asInstanceOf[Ptr[Byte]])
    inline def apply(inline o: CFuncPtr2[GLuint, GLenum, Unit]): PFNGLBLENDEQUATIONIOESPROC = o
    extension (v: PFNGLBLENDEQUATIONIOESPROC)
      inline def value: CFuncPtr2[GLuint, GLenum, Unit] = v
      inline def toPtr: Ptr[?] = CFuncPtr.toPtr(v)

  opaque type PFNGLBLENDEQUATIONIPROC = CFuncPtr2[GLuint, GLenum, Unit]
  object PFNGLBLENDEQUATIONIPROC:
    given _tag: Tag[PFNGLBLENDEQUATIONIPROC] = Tag.materializeCFuncPtr2[GLuint, GLenum, Unit]
    inline def fromPtr(ptr: Ptr[Byte] | Ptr[?]): PFNGLBLENDEQUATIONIPROC = CFuncPtr.fromPtr(ptr.asInstanceOf[Ptr[Byte]])
    inline def apply(inline o: CFuncPtr2[GLuint, GLenum, Unit]): PFNGLBLENDEQUATIONIPROC = o
    extension (v: PFNGLBLENDEQUATIONIPROC)
      inline def value: CFuncPtr2[GLuint, GLenum, Unit] = v
      inline def toPtr: Ptr[?] = CFuncPtr.toPtr(v)

  opaque type PFNGLBLENDEQUATIONOESPROC = CFuncPtr1[GLenum, Unit]
  object PFNGLBLENDEQUATIONOESPROC:
    given _tag: Tag[PFNGLBLENDEQUATIONOESPROC] = Tag.materializeCFuncPtr1[GLenum, Unit]
    inline def fromPtr(ptr: Ptr[Byte] | Ptr[?]): PFNGLBLENDEQUATIONOESPROC = CFuncPtr.fromPtr(ptr.asInstanceOf[Ptr[Byte]])
    inline def apply(inline o: CFuncPtr1[GLenum, Unit]): PFNGLBLENDEQUATIONOESPROC = o
    extension (v: PFNGLBLENDEQUATIONOESPROC)
      inline def value: CFuncPtr1[GLenum, Unit] = v
      inline def toPtr: Ptr[?] = CFuncPtr.toPtr(v)

  opaque type PFNGLBLENDEQUATIONPROC = CFuncPtr1[GLenum, Unit]
  object PFNGLBLENDEQUATIONPROC:
    given _tag: Tag[PFNGLBLENDEQUATIONPROC] = Tag.materializeCFuncPtr1[GLenum, Unit]
    inline def fromPtr(ptr: Ptr[Byte] | Ptr[?]): PFNGLBLENDEQUATIONPROC = CFuncPtr.fromPtr(ptr.asInstanceOf[Ptr[Byte]])
    inline def apply(inline o: CFuncPtr1[GLenum, Unit]): PFNGLBLENDEQUATIONPROC = o
    extension (v: PFNGLBLENDEQUATIONPROC)
      inline def value: CFuncPtr1[GLenum, Unit] = v
      inline def toPtr: Ptr[?] = CFuncPtr.toPtr(v)

  opaque type PFNGLBLENDEQUATIONSEPARATEEXTPROC = CFuncPtr2[GLenum, GLenum, Unit]
  object PFNGLBLENDEQUATIONSEPARATEEXTPROC:
    given _tag: Tag[PFNGLBLENDEQUATIONSEPARATEEXTPROC] = Tag.materializeCFuncPtr2[GLenum, GLenum, Unit]
    inline def fromPtr(ptr: Ptr[Byte] | Ptr[?]): PFNGLBLENDEQUATIONSEPARATEEXTPROC = CFuncPtr.fromPtr(ptr.asInstanceOf[Ptr[Byte]])
    inline def apply(inline o: CFuncPtr2[GLenum, GLenum, Unit]): PFNGLBLENDEQUATIONSEPARATEEXTPROC = o
    extension (v: PFNGLBLENDEQUATIONSEPARATEEXTPROC)
      inline def value: CFuncPtr2[GLenum, GLenum, Unit] = v
      inline def toPtr: Ptr[?] = CFuncPtr.toPtr(v)

  opaque type PFNGLBLENDEQUATIONSEPARATEIARBPROC = CFuncPtr3[GLuint, GLenum, GLenum, Unit]
  object PFNGLBLENDEQUATIONSEPARATEIARBPROC:
    given _tag: Tag[PFNGLBLENDEQUATIONSEPARATEIARBPROC] = Tag.materializeCFuncPtr3[GLuint, GLenum, GLenum, Unit]
    inline def fromPtr(ptr: Ptr[Byte] | Ptr[?]): PFNGLBLENDEQUATIONSEPARATEIARBPROC = CFuncPtr.fromPtr(ptr.asInstanceOf[Ptr[Byte]])
    inline def apply(inline o: CFuncPtr3[GLuint, GLenum, GLenum, Unit]): PFNGLBLENDEQUATIONSEPARATEIARBPROC = o
    extension (v: PFNGLBLENDEQUATIONSEPARATEIARBPROC)
      inline def value: CFuncPtr3[GLuint, GLenum, GLenum, Unit] = v
      inline def toPtr: Ptr[?] = CFuncPtr.toPtr(v)

  opaque type PFNGLBLENDEQUATIONSEPARATEIEXTPROC = CFuncPtr3[GLuint, GLenum, GLenum, Unit]
  object PFNGLBLENDEQUATIONSEPARATEIEXTPROC:
    given _tag: Tag[PFNGLBLENDEQUATIONSEPARATEIEXTPROC] = Tag.materializeCFuncPtr3[GLuint, GLenum, GLenum, Unit]
    inline def fromPtr(ptr: Ptr[Byte] | Ptr[?]): PFNGLBLENDEQUATIONSEPARATEIEXTPROC = CFuncPtr.fromPtr(ptr.asInstanceOf[Ptr[Byte]])
    inline def apply(inline o: CFuncPtr3[GLuint, GLenum, GLenum, Unit]): PFNGLBLENDEQUATIONSEPARATEIEXTPROC = o
    extension (v: PFNGLBLENDEQUATIONSEPARATEIEXTPROC)
      inline def value: CFuncPtr3[GLuint, GLenum, GLenum, Unit] = v
      inline def toPtr: Ptr[?] = CFuncPtr.toPtr(v)

  opaque type PFNGLBLENDEQUATIONSEPARATEINDEXEDAMDPROC = CFuncPtr3[GLuint, GLenum, GLenum, Unit]
  object PFNGLBLENDEQUATIONSEPARATEINDEXEDAMDPROC:
    given _tag: Tag[PFNGLBLENDEQUATIONSEPARATEINDEXEDAMDPROC] = Tag.materializeCFuncPtr3[GLuint, GLenum, GLenum, Unit]
    inline def fromPtr(ptr: Ptr[Byte] | Ptr[?]): PFNGLBLENDEQUATIONSEPARATEINDEXEDAMDPROC = CFuncPtr.fromPtr(ptr.asInstanceOf[Ptr[Byte]])
    inline def apply(inline o: CFuncPtr3[GLuint, GLenum, GLenum, Unit]): PFNGLBLENDEQUATIONSEPARATEINDEXEDAMDPROC = o
    extension (v: PFNGLBLENDEQUATIONSEPARATEINDEXEDAMDPROC)
      inline def value: CFuncPtr3[GLuint, GLenum, GLenum, Unit] = v
      inline def toPtr: Ptr[?] = CFuncPtr.toPtr(v)

  opaque type PFNGLBLENDEQUATIONSEPARATEIOESPROC = CFuncPtr3[GLuint, GLenum, GLenum, Unit]
  object PFNGLBLENDEQUATIONSEPARATEIOESPROC:
    given _tag: Tag[PFNGLBLENDEQUATIONSEPARATEIOESPROC] = Tag.materializeCFuncPtr3[GLuint, GLenum, GLenum, Unit]
    inline def fromPtr(ptr: Ptr[Byte] | Ptr[?]): PFNGLBLENDEQUATIONSEPARATEIOESPROC = CFuncPtr.fromPtr(ptr.asInstanceOf[Ptr[Byte]])
    inline def apply(inline o: CFuncPtr3[GLuint, GLenum, GLenum, Unit]): PFNGLBLENDEQUATIONSEPARATEIOESPROC = o
    extension (v: PFNGLBLENDEQUATIONSEPARATEIOESPROC)
      inline def value: CFuncPtr3[GLuint, GLenum, GLenum, Unit] = v
      inline def toPtr: Ptr[?] = CFuncPtr.toPtr(v)

  opaque type PFNGLBLENDEQUATIONSEPARATEIPROC = CFuncPtr3[GLuint, GLenum, GLenum, Unit]
  object PFNGLBLENDEQUATIONSEPARATEIPROC:
    given _tag: Tag[PFNGLBLENDEQUATIONSEPARATEIPROC] = Tag.materializeCFuncPtr3[GLuint, GLenum, GLenum, Unit]
    inline def fromPtr(ptr: Ptr[Byte] | Ptr[?]): PFNGLBLENDEQUATIONSEPARATEIPROC = CFuncPtr.fromPtr(ptr.asInstanceOf[Ptr[Byte]])
    inline def apply(inline o: CFuncPtr3[GLuint, GLenum, GLenum, Unit]): PFNGLBLENDEQUATIONSEPARATEIPROC = o
    extension (v: PFNGLBLENDEQUATIONSEPARATEIPROC)
      inline def value: CFuncPtr3[GLuint, GLenum, GLenum, Unit] = v
      inline def toPtr: Ptr[?] = CFuncPtr.toPtr(v)

  opaque type PFNGLBLENDEQUATIONSEPARATEOESPROC = CFuncPtr2[GLenum, GLenum, Unit]
  object PFNGLBLENDEQUATIONSEPARATEOESPROC:
    given _tag: Tag[PFNGLBLENDEQUATIONSEPARATEOESPROC] = Tag.materializeCFuncPtr2[GLenum, GLenum, Unit]
    inline def fromPtr(ptr: Ptr[Byte] | Ptr[?]): PFNGLBLENDEQUATIONSEPARATEOESPROC = CFuncPtr.fromPtr(ptr.asInstanceOf[Ptr[Byte]])
    inline def apply(inline o: CFuncPtr2[GLenum, GLenum, Unit]): PFNGLBLENDEQUATIONSEPARATEOESPROC = o
    extension (v: PFNGLBLENDEQUATIONSEPARATEOESPROC)
      inline def value: CFuncPtr2[GLenum, GLenum, Unit] = v
      inline def toPtr: Ptr[?] = CFuncPtr.toPtr(v)

  opaque type PFNGLBLENDEQUATIONSEPARATEPROC = CFuncPtr2[GLenum, GLenum, Unit]
  object PFNGLBLENDEQUATIONSEPARATEPROC:
    given _tag: Tag[PFNGLBLENDEQUATIONSEPARATEPROC] = Tag.materializeCFuncPtr2[GLenum, GLenum, Unit]
    inline def fromPtr(ptr: Ptr[Byte] | Ptr[?]): PFNGLBLENDEQUATIONSEPARATEPROC = CFuncPtr.fromPtr(ptr.asInstanceOf[Ptr[Byte]])
    inline def apply(inline o: CFuncPtr2[GLenum, GLenum, Unit]): PFNGLBLENDEQUATIONSEPARATEPROC = o
    extension (v: PFNGLBLENDEQUATIONSEPARATEPROC)
      inline def value: CFuncPtr2[GLenum, GLenum, Unit] = v
      inline def toPtr: Ptr[?] = CFuncPtr.toPtr(v)

  opaque type PFNGLBLENDFUNCIARBPROC = CFuncPtr3[GLuint, GLenum, GLenum, Unit]
  object PFNGLBLENDFUNCIARBPROC:
    given _tag: Tag[PFNGLBLENDFUNCIARBPROC] = Tag.materializeCFuncPtr3[GLuint, GLenum, GLenum, Unit]
    inline def fromPtr(ptr: Ptr[Byte] | Ptr[?]): PFNGLBLENDFUNCIARBPROC = CFuncPtr.fromPtr(ptr.asInstanceOf[Ptr[Byte]])
    inline def apply(inline o: CFuncPtr3[GLuint, GLenum, GLenum, Unit]): PFNGLBLENDFUNCIARBPROC = o
    extension (v: PFNGLBLENDFUNCIARBPROC)
      inline def value: CFuncPtr3[GLuint, GLenum, GLenum, Unit] = v
      inline def toPtr: Ptr[?] = CFuncPtr.toPtr(v)

  opaque type PFNGLBLENDFUNCIEXTPROC = CFuncPtr3[GLuint, GLenum, GLenum, Unit]
  object PFNGLBLENDFUNCIEXTPROC:
    given _tag: Tag[PFNGLBLENDFUNCIEXTPROC] = Tag.materializeCFuncPtr3[GLuint, GLenum, GLenum, Unit]
    inline def fromPtr(ptr: Ptr[Byte] | Ptr[?]): PFNGLBLENDFUNCIEXTPROC = CFuncPtr.fromPtr(ptr.asInstanceOf[Ptr[Byte]])
    inline def apply(inline o: CFuncPtr3[GLuint, GLenum, GLenum, Unit]): PFNGLBLENDFUNCIEXTPROC = o
    extension (v: PFNGLBLENDFUNCIEXTPROC)
      inline def value: CFuncPtr3[GLuint, GLenum, GLenum, Unit] = v
      inline def toPtr: Ptr[?] = CFuncPtr.toPtr(v)

  opaque type PFNGLBLENDFUNCINDEXEDAMDPROC = CFuncPtr3[GLuint, GLenum, GLenum, Unit]
  object PFNGLBLENDFUNCINDEXEDAMDPROC:
    given _tag: Tag[PFNGLBLENDFUNCINDEXEDAMDPROC] = Tag.materializeCFuncPtr3[GLuint, GLenum, GLenum, Unit]
    inline def fromPtr(ptr: Ptr[Byte] | Ptr[?]): PFNGLBLENDFUNCINDEXEDAMDPROC = CFuncPtr.fromPtr(ptr.asInstanceOf[Ptr[Byte]])
    inline def apply(inline o: CFuncPtr3[GLuint, GLenum, GLenum, Unit]): PFNGLBLENDFUNCINDEXEDAMDPROC = o
    extension (v: PFNGLBLENDFUNCINDEXEDAMDPROC)
      inline def value: CFuncPtr3[GLuint, GLenum, GLenum, Unit] = v
      inline def toPtr: Ptr[?] = CFuncPtr.toPtr(v)

  opaque type PFNGLBLENDFUNCIOESPROC = CFuncPtr3[GLuint, GLenum, GLenum, Unit]
  object PFNGLBLENDFUNCIOESPROC:
    given _tag: Tag[PFNGLBLENDFUNCIOESPROC] = Tag.materializeCFuncPtr3[GLuint, GLenum, GLenum, Unit]
    inline def fromPtr(ptr: Ptr[Byte] | Ptr[?]): PFNGLBLENDFUNCIOESPROC = CFuncPtr.fromPtr(ptr.asInstanceOf[Ptr[Byte]])
    inline def apply(inline o: CFuncPtr3[GLuint, GLenum, GLenum, Unit]): PFNGLBLENDFUNCIOESPROC = o
    extension (v: PFNGLBLENDFUNCIOESPROC)
      inline def value: CFuncPtr3[GLuint, GLenum, GLenum, Unit] = v
      inline def toPtr: Ptr[?] = CFuncPtr.toPtr(v)

  opaque type PFNGLBLENDFUNCIPROC = CFuncPtr3[GLuint, GLenum, GLenum, Unit]
  object PFNGLBLENDFUNCIPROC:
    given _tag: Tag[PFNGLBLENDFUNCIPROC] = Tag.materializeCFuncPtr3[GLuint, GLenum, GLenum, Unit]
    inline def fromPtr(ptr: Ptr[Byte] | Ptr[?]): PFNGLBLENDFUNCIPROC = CFuncPtr.fromPtr(ptr.asInstanceOf[Ptr[Byte]])
    inline def apply(inline o: CFuncPtr3[GLuint, GLenum, GLenum, Unit]): PFNGLBLENDFUNCIPROC = o
    extension (v: PFNGLBLENDFUNCIPROC)
      inline def value: CFuncPtr3[GLuint, GLenum, GLenum, Unit] = v
      inline def toPtr: Ptr[?] = CFuncPtr.toPtr(v)

  opaque type PFNGLBLENDFUNCSEPARATEEXTPROC = CFuncPtr4[GLenum, GLenum, GLenum, GLenum, Unit]
  object PFNGLBLENDFUNCSEPARATEEXTPROC:
    given _tag: Tag[PFNGLBLENDFUNCSEPARATEEXTPROC] = Tag.materializeCFuncPtr4[GLenum, GLenum, GLenum, GLenum, Unit]
    inline def fromPtr(ptr: Ptr[Byte] | Ptr[?]): PFNGLBLENDFUNCSEPARATEEXTPROC = CFuncPtr.fromPtr(ptr.asInstanceOf[Ptr[Byte]])
    inline def apply(inline o: CFuncPtr4[GLenum, GLenum, GLenum, GLenum, Unit]): PFNGLBLENDFUNCSEPARATEEXTPROC = o
    extension (v: PFNGLBLENDFUNCSEPARATEEXTPROC)
      inline def value: CFuncPtr4[GLenum, GLenum, GLenum, GLenum, Unit] = v
      inline def toPtr: Ptr[?] = CFuncPtr.toPtr(v)

  opaque type PFNGLBLENDFUNCSEPARATEIARBPROC = CFuncPtr5[GLuint, GLenum, GLenum, GLenum, GLenum, Unit]
  object PFNGLBLENDFUNCSEPARATEIARBPROC:
    given _tag: Tag[PFNGLBLENDFUNCSEPARATEIARBPROC] = Tag.materializeCFuncPtr5[GLuint, GLenum, GLenum, GLenum, GLenum, Unit]
    inline def fromPtr(ptr: Ptr[Byte] | Ptr[?]): PFNGLBLENDFUNCSEPARATEIARBPROC = CFuncPtr.fromPtr(ptr.asInstanceOf[Ptr[Byte]])
    inline def apply(inline o: CFuncPtr5[GLuint, GLenum, GLenum, GLenum, GLenum, Unit]): PFNGLBLENDFUNCSEPARATEIARBPROC = o
    extension (v: PFNGLBLENDFUNCSEPARATEIARBPROC)
      inline def value: CFuncPtr5[GLuint, GLenum, GLenum, GLenum, GLenum, Unit] = v
      inline def toPtr: Ptr[?] = CFuncPtr.toPtr(v)

  opaque type PFNGLBLENDFUNCSEPARATEIEXTPROC = CFuncPtr5[GLuint, GLenum, GLenum, GLenum, GLenum, Unit]
  object PFNGLBLENDFUNCSEPARATEIEXTPROC:
    given _tag: Tag[PFNGLBLENDFUNCSEPARATEIEXTPROC] = Tag.materializeCFuncPtr5[GLuint, GLenum, GLenum, GLenum, GLenum, Unit]
    inline def fromPtr(ptr: Ptr[Byte] | Ptr[?]): PFNGLBLENDFUNCSEPARATEIEXTPROC = CFuncPtr.fromPtr(ptr.asInstanceOf[Ptr[Byte]])
    inline def apply(inline o: CFuncPtr5[GLuint, GLenum, GLenum, GLenum, GLenum, Unit]): PFNGLBLENDFUNCSEPARATEIEXTPROC = o
    extension (v: PFNGLBLENDFUNCSEPARATEIEXTPROC)
      inline def value: CFuncPtr5[GLuint, GLenum, GLenum, GLenum, GLenum, Unit] = v
      inline def toPtr: Ptr[?] = CFuncPtr.toPtr(v)

  opaque type PFNGLBLENDFUNCSEPARATEINDEXEDAMDPROC = CFuncPtr5[GLuint, GLenum, GLenum, GLenum, GLenum, Unit]
  object PFNGLBLENDFUNCSEPARATEINDEXEDAMDPROC:
    given _tag: Tag[PFNGLBLENDFUNCSEPARATEINDEXEDAMDPROC] = Tag.materializeCFuncPtr5[GLuint, GLenum, GLenum, GLenum, GLenum, Unit]
    inline def fromPtr(ptr: Ptr[Byte] | Ptr[?]): PFNGLBLENDFUNCSEPARATEINDEXEDAMDPROC = CFuncPtr.fromPtr(ptr.asInstanceOf[Ptr[Byte]])
    inline def apply(inline o: CFuncPtr5[GLuint, GLenum, GLenum, GLenum, GLenum, Unit]): PFNGLBLENDFUNCSEPARATEINDEXEDAMDPROC = o
    extension (v: PFNGLBLENDFUNCSEPARATEINDEXEDAMDPROC)
      inline def value: CFuncPtr5[GLuint, GLenum, GLenum, GLenum, GLenum, Unit] = v
      inline def toPtr: Ptr[?] = CFuncPtr.toPtr(v)

  opaque type PFNGLBLENDFUNCSEPARATEIOESPROC = CFuncPtr5[GLuint, GLenum, GLenum, GLenum, GLenum, Unit]
  object PFNGLBLENDFUNCSEPARATEIOESPROC:
    given _tag: Tag[PFNGLBLENDFUNCSEPARATEIOESPROC] = Tag.materializeCFuncPtr5[GLuint, GLenum, GLenum, GLenum, GLenum, Unit]
    inline def fromPtr(ptr: Ptr[Byte] | Ptr[?]): PFNGLBLENDFUNCSEPARATEIOESPROC = CFuncPtr.fromPtr(ptr.asInstanceOf[Ptr[Byte]])
    inline def apply(inline o: CFuncPtr5[GLuint, GLenum, GLenum, GLenum, GLenum, Unit]): PFNGLBLENDFUNCSEPARATEIOESPROC = o
    extension (v: PFNGLBLENDFUNCSEPARATEIOESPROC)
      inline def value: CFuncPtr5[GLuint, GLenum, GLenum, GLenum, GLenum, Unit] = v
      inline def toPtr: Ptr[?] = CFuncPtr.toPtr(v)

  opaque type PFNGLBLENDFUNCSEPARATEIPROC = CFuncPtr5[GLuint, GLenum, GLenum, GLenum, GLenum, Unit]
  object PFNGLBLENDFUNCSEPARATEIPROC:
    given _tag: Tag[PFNGLBLENDFUNCSEPARATEIPROC] = Tag.materializeCFuncPtr5[GLuint, GLenum, GLenum, GLenum, GLenum, Unit]
    inline def fromPtr(ptr: Ptr[Byte] | Ptr[?]): PFNGLBLENDFUNCSEPARATEIPROC = CFuncPtr.fromPtr(ptr.asInstanceOf[Ptr[Byte]])
    inline def apply(inline o: CFuncPtr5[GLuint, GLenum, GLenum, GLenum, GLenum, Unit]): PFNGLBLENDFUNCSEPARATEIPROC = o
    extension (v: PFNGLBLENDFUNCSEPARATEIPROC)
      inline def value: CFuncPtr5[GLuint, GLenum, GLenum, GLenum, GLenum, Unit] = v
      inline def toPtr: Ptr[?] = CFuncPtr.toPtr(v)

  opaque type PFNGLBLENDFUNCSEPARATEOESPROC = CFuncPtr4[GLenum, GLenum, GLenum, GLenum, Unit]
  object PFNGLBLENDFUNCSEPARATEOESPROC:
    given _tag: Tag[PFNGLBLENDFUNCSEPARATEOESPROC] = Tag.materializeCFuncPtr4[GLenum, GLenum, GLenum, GLenum, Unit]
    inline def fromPtr(ptr: Ptr[Byte] | Ptr[?]): PFNGLBLENDFUNCSEPARATEOESPROC = CFuncPtr.fromPtr(ptr.asInstanceOf[Ptr[Byte]])
    inline def apply(inline o: CFuncPtr4[GLenum, GLenum, GLenum, GLenum, Unit]): PFNGLBLENDFUNCSEPARATEOESPROC = o
    extension (v: PFNGLBLENDFUNCSEPARATEOESPROC)
      inline def value: CFuncPtr4[GLenum, GLenum, GLenum, GLenum, Unit] = v
      inline def toPtr: Ptr[?] = CFuncPtr.toPtr(v)

  opaque type PFNGLBLENDFUNCSEPARATEPROC = CFuncPtr4[GLenum, GLenum, GLenum, GLenum, Unit]
  object PFNGLBLENDFUNCSEPARATEPROC:
    given _tag: Tag[PFNGLBLENDFUNCSEPARATEPROC] = Tag.materializeCFuncPtr4[GLenum, GLenum, GLenum, GLenum, Unit]
    inline def fromPtr(ptr: Ptr[Byte] | Ptr[?]): PFNGLBLENDFUNCSEPARATEPROC = CFuncPtr.fromPtr(ptr.asInstanceOf[Ptr[Byte]])
    inline def apply(inline o: CFuncPtr4[GLenum, GLenum, GLenum, GLenum, Unit]): PFNGLBLENDFUNCSEPARATEPROC = o
    extension (v: PFNGLBLENDFUNCSEPARATEPROC)
      inline def value: CFuncPtr4[GLenum, GLenum, GLenum, GLenum, Unit] = v
      inline def toPtr: Ptr[?] = CFuncPtr.toPtr(v)

  opaque type PFNGLBLENDPARAMETERINVPROC = CFuncPtr2[GLenum, GLint, Unit]
  object PFNGLBLENDPARAMETERINVPROC:
    given _tag: Tag[PFNGLBLENDPARAMETERINVPROC] = Tag.materializeCFuncPtr2[GLenum, GLint, Unit]
    inline def fromPtr(ptr: Ptr[Byte] | Ptr[?]): PFNGLBLENDPARAMETERINVPROC = CFuncPtr.fromPtr(ptr.asInstanceOf[Ptr[Byte]])
    inline def apply(inline o: CFuncPtr2[GLenum, GLint, Unit]): PFNGLBLENDPARAMETERINVPROC = o
    extension (v: PFNGLBLENDPARAMETERINVPROC)
      inline def value: CFuncPtr2[GLenum, GLint, Unit] = v
      inline def toPtr: Ptr[?] = CFuncPtr.toPtr(v)

  opaque type PFNGLBLITFRAMEBUFFERANGLEPROC = CFuncPtr10[GLint, GLint, GLint, GLint, GLint, GLint, GLint, GLint, GLbitfield, GLenum, Unit]
  object PFNGLBLITFRAMEBUFFERANGLEPROC:
    given _tag: Tag[PFNGLBLITFRAMEBUFFERANGLEPROC] = Tag.materializeCFuncPtr10[GLint, GLint, GLint, GLint, GLint, GLint, GLint, GLint, GLbitfield, GLenum, Unit]
    inline def fromPtr(ptr: Ptr[Byte] | Ptr[?]): PFNGLBLITFRAMEBUFFERANGLEPROC = CFuncPtr.fromPtr(ptr.asInstanceOf[Ptr[Byte]])
    inline def apply(inline o: CFuncPtr10[GLint, GLint, GLint, GLint, GLint, GLint, GLint, GLint, GLbitfield, GLenum, Unit]): PFNGLBLITFRAMEBUFFERANGLEPROC = o
    extension (v: PFNGLBLITFRAMEBUFFERANGLEPROC)
      inline def value: CFuncPtr10[GLint, GLint, GLint, GLint, GLint, GLint, GLint, GLint, GLbitfield, GLenum, Unit] = v
      inline def toPtr: Ptr[?] = CFuncPtr.toPtr(v)

  opaque type PFNGLBLITFRAMEBUFFEREXTPROC = CFuncPtr10[GLint, GLint, GLint, GLint, GLint, GLint, GLint, GLint, GLbitfield, GLenum, Unit]
  object PFNGLBLITFRAMEBUFFEREXTPROC:
    given _tag: Tag[PFNGLBLITFRAMEBUFFEREXTPROC] = Tag.materializeCFuncPtr10[GLint, GLint, GLint, GLint, GLint, GLint, GLint, GLint, GLbitfield, GLenum, Unit]
    inline def fromPtr(ptr: Ptr[Byte] | Ptr[?]): PFNGLBLITFRAMEBUFFEREXTPROC = CFuncPtr.fromPtr(ptr.asInstanceOf[Ptr[Byte]])
    inline def apply(inline o: CFuncPtr10[GLint, GLint, GLint, GLint, GLint, GLint, GLint, GLint, GLbitfield, GLenum, Unit]): PFNGLBLITFRAMEBUFFEREXTPROC = o
    extension (v: PFNGLBLITFRAMEBUFFEREXTPROC)
      inline def value: CFuncPtr10[GLint, GLint, GLint, GLint, GLint, GLint, GLint, GLint, GLbitfield, GLenum, Unit] = v
      inline def toPtr: Ptr[?] = CFuncPtr.toPtr(v)

  opaque type PFNGLBLITFRAMEBUFFERNVPROC = CFuncPtr10[GLint, GLint, GLint, GLint, GLint, GLint, GLint, GLint, GLbitfield, GLenum, Unit]
  object PFNGLBLITFRAMEBUFFERNVPROC:
    given _tag: Tag[PFNGLBLITFRAMEBUFFERNVPROC] = Tag.materializeCFuncPtr10[GLint, GLint, GLint, GLint, GLint, GLint, GLint, GLint, GLbitfield, GLenum, Unit]
    inline def fromPtr(ptr: Ptr[Byte] | Ptr[?]): PFNGLBLITFRAMEBUFFERNVPROC = CFuncPtr.fromPtr(ptr.asInstanceOf[Ptr[Byte]])
    inline def apply(inline o: CFuncPtr10[GLint, GLint, GLint, GLint, GLint, GLint, GLint, GLint, GLbitfield, GLenum, Unit]): PFNGLBLITFRAMEBUFFERNVPROC = o
    extension (v: PFNGLBLITFRAMEBUFFERNVPROC)
      inline def value: CFuncPtr10[GLint, GLint, GLint, GLint, GLint, GLint, GLint, GLint, GLbitfield, GLenum, Unit] = v
      inline def toPtr: Ptr[?] = CFuncPtr.toPtr(v)

  opaque type PFNGLBLITFRAMEBUFFERPROC = CFuncPtr10[GLint, GLint, GLint, GLint, GLint, GLint, GLint, GLint, GLbitfield, GLenum, Unit]
  object PFNGLBLITFRAMEBUFFERPROC:
    given _tag: Tag[PFNGLBLITFRAMEBUFFERPROC] = Tag.materializeCFuncPtr10[GLint, GLint, GLint, GLint, GLint, GLint, GLint, GLint, GLbitfield, GLenum, Unit]
    inline def fromPtr(ptr: Ptr[Byte] | Ptr[?]): PFNGLBLITFRAMEBUFFERPROC = CFuncPtr.fromPtr(ptr.asInstanceOf[Ptr[Byte]])
    inline def apply(inline o: CFuncPtr10[GLint, GLint, GLint, GLint, GLint, GLint, GLint, GLint, GLbitfield, GLenum, Unit]): PFNGLBLITFRAMEBUFFERPROC = o
    extension (v: PFNGLBLITFRAMEBUFFERPROC)
      inline def value: CFuncPtr10[GLint, GLint, GLint, GLint, GLint, GLint, GLint, GLint, GLbitfield, GLenum, Unit] = v
      inline def toPtr: Ptr[?] = CFuncPtr.toPtr(v)

  opaque type PFNGLBLITNAMEDFRAMEBUFFERPROC = CFuncPtr12[GLuint, GLuint, GLint, GLint, GLint, GLint, GLint, GLint, GLint, GLint, GLbitfield, GLenum, Unit]
  object PFNGLBLITNAMEDFRAMEBUFFERPROC:
    given _tag: Tag[PFNGLBLITNAMEDFRAMEBUFFERPROC] = Tag.materializeCFuncPtr12[GLuint, GLuint, GLint, GLint, GLint, GLint, GLint, GLint, GLint, GLint, GLbitfield, GLenum, Unit]
    inline def fromPtr(ptr: Ptr[Byte] | Ptr[?]): PFNGLBLITNAMEDFRAMEBUFFERPROC = CFuncPtr.fromPtr(ptr.asInstanceOf[Ptr[Byte]])
    inline def apply(inline o: CFuncPtr12[GLuint, GLuint, GLint, GLint, GLint, GLint, GLint, GLint, GLint, GLint, GLbitfield, GLenum, Unit]): PFNGLBLITNAMEDFRAMEBUFFERPROC = o
    extension (v: PFNGLBLITNAMEDFRAMEBUFFERPROC)
      inline def value: CFuncPtr12[GLuint, GLuint, GLint, GLint, GLint, GLint, GLint, GLint, GLint, GLint, GLbitfield, GLenum, Unit] = v
      inline def toPtr: Ptr[?] = CFuncPtr.toPtr(v)

  opaque type PFNGLBUFFERADDRESSRANGENVPROC = CFuncPtr4[GLenum, GLuint, GLuint64EXT, GLsizeiptr, Unit]
  object PFNGLBUFFERADDRESSRANGENVPROC:
    given _tag: Tag[PFNGLBUFFERADDRESSRANGENVPROC] = Tag.materializeCFuncPtr4[GLenum, GLuint, GLuint64EXT, GLsizeiptr, Unit]
    inline def fromPtr(ptr: Ptr[Byte] | Ptr[?]): PFNGLBUFFERADDRESSRANGENVPROC = CFuncPtr.fromPtr(ptr.asInstanceOf[Ptr[Byte]])
    inline def apply(inline o: CFuncPtr4[GLenum, GLuint, GLuint64EXT, GLsizeiptr, Unit]): PFNGLBUFFERADDRESSRANGENVPROC = o
    extension (v: PFNGLBUFFERADDRESSRANGENVPROC)
      inline def value: CFuncPtr4[GLenum, GLuint, GLuint64EXT, GLsizeiptr, Unit] = v
      inline def toPtr: Ptr[?] = CFuncPtr.toPtr(v)

  opaque type PFNGLBUFFERATTACHMEMORYNVPROC = CFuncPtr3[GLenum, GLuint, GLuint64, Unit]
  object PFNGLBUFFERATTACHMEMORYNVPROC:
    given _tag: Tag[PFNGLBUFFERATTACHMEMORYNVPROC] = Tag.materializeCFuncPtr3[GLenum, GLuint, GLuint64, Unit]
    inline def fromPtr(ptr: Ptr[Byte] | Ptr[?]): PFNGLBUFFERATTACHMEMORYNVPROC = CFuncPtr.fromPtr(ptr.asInstanceOf[Ptr[Byte]])
    inline def apply(inline o: CFuncPtr3[GLenum, GLuint, GLuint64, Unit]): PFNGLBUFFERATTACHMEMORYNVPROC = o
    extension (v: PFNGLBUFFERATTACHMEMORYNVPROC)
      inline def value: CFuncPtr3[GLenum, GLuint, GLuint64, Unit] = v
      inline def toPtr: Ptr[?] = CFuncPtr.toPtr(v)

  opaque type PFNGLBUFFERDATAARBPROC = CFuncPtr4[GLenum, GLsizeiptrARB, Ptr[Byte], GLenum, Unit]
  object PFNGLBUFFERDATAARBPROC:
    given _tag: Tag[PFNGLBUFFERDATAARBPROC] = Tag.materializeCFuncPtr4[GLenum, GLsizeiptrARB, Ptr[Byte], GLenum, Unit]
    inline def fromPtr(ptr: Ptr[Byte] | Ptr[?]): PFNGLBUFFERDATAARBPROC = CFuncPtr.fromPtr(ptr.asInstanceOf[Ptr[Byte]])
    inline def apply(inline o: CFuncPtr4[GLenum, GLsizeiptrARB, Ptr[Byte], GLenum, Unit]): PFNGLBUFFERDATAARBPROC = o
    extension (v: PFNGLBUFFERDATAARBPROC)
      inline def value: CFuncPtr4[GLenum, GLsizeiptrARB, Ptr[Byte], GLenum, Unit] = v
      inline def toPtr: Ptr[?] = CFuncPtr.toPtr(v)

  opaque type PFNGLBUFFERDATAPROC = CFuncPtr4[GLenum, GLsizeiptr, Ptr[Byte], GLenum, Unit]
  object PFNGLBUFFERDATAPROC:
    given _tag: Tag[PFNGLBUFFERDATAPROC] = Tag.materializeCFuncPtr4[GLenum, GLsizeiptr, Ptr[Byte], GLenum, Unit]
    inline def fromPtr(ptr: Ptr[Byte] | Ptr[?]): PFNGLBUFFERDATAPROC = CFuncPtr.fromPtr(ptr.asInstanceOf[Ptr[Byte]])
    inline def apply(inline o: CFuncPtr4[GLenum, GLsizeiptr, Ptr[Byte], GLenum, Unit]): PFNGLBUFFERDATAPROC = o
    extension (v: PFNGLBUFFERDATAPROC)
      inline def value: CFuncPtr4[GLenum, GLsizeiptr, Ptr[Byte], GLenum, Unit] = v
      inline def toPtr: Ptr[?] = CFuncPtr.toPtr(v)

  opaque type PFNGLBUFFERPAGECOMMITMENTARBPROC = CFuncPtr4[GLenum, GLintptr, GLsizeiptr, GLboolean, Unit]
  object PFNGLBUFFERPAGECOMMITMENTARBPROC:
    given _tag: Tag[PFNGLBUFFERPAGECOMMITMENTARBPROC] = Tag.materializeCFuncPtr4[GLenum, GLintptr, GLsizeiptr, GLboolean, Unit]
    inline def fromPtr(ptr: Ptr[Byte] | Ptr[?]): PFNGLBUFFERPAGECOMMITMENTARBPROC = CFuncPtr.fromPtr(ptr.asInstanceOf[Ptr[Byte]])
    inline def apply(inline o: CFuncPtr4[GLenum, GLintptr, GLsizeiptr, GLboolean, Unit]): PFNGLBUFFERPAGECOMMITMENTARBPROC = o
    extension (v: PFNGLBUFFERPAGECOMMITMENTARBPROC)
      inline def value: CFuncPtr4[GLenum, GLintptr, GLsizeiptr, GLboolean, Unit] = v
      inline def toPtr: Ptr[?] = CFuncPtr.toPtr(v)

  opaque type PFNGLBUFFERPARAMETERIAPPLEPROC = CFuncPtr3[GLenum, GLenum, GLint, Unit]
  object PFNGLBUFFERPARAMETERIAPPLEPROC:
    given _tag: Tag[PFNGLBUFFERPARAMETERIAPPLEPROC] = Tag.materializeCFuncPtr3[GLenum, GLenum, GLint, Unit]
    inline def fromPtr(ptr: Ptr[Byte] | Ptr[?]): PFNGLBUFFERPARAMETERIAPPLEPROC = CFuncPtr.fromPtr(ptr.asInstanceOf[Ptr[Byte]])
    inline def apply(inline o: CFuncPtr3[GLenum, GLenum, GLint, Unit]): PFNGLBUFFERPARAMETERIAPPLEPROC = o
    extension (v: PFNGLBUFFERPARAMETERIAPPLEPROC)
      inline def value: CFuncPtr3[GLenum, GLenum, GLint, Unit] = v
      inline def toPtr: Ptr[?] = CFuncPtr.toPtr(v)

  opaque type PFNGLBUFFERREGIONENABLEDPROC = CFuncPtr0[GLuint]
  object PFNGLBUFFERREGIONENABLEDPROC:
    given _tag: Tag[PFNGLBUFFERREGIONENABLEDPROC] = Tag.materializeCFuncPtr0[GLuint]
    inline def fromPtr(ptr: Ptr[Byte] | Ptr[?]): PFNGLBUFFERREGIONENABLEDPROC = CFuncPtr.fromPtr(ptr.asInstanceOf[Ptr[Byte]])
    inline def apply(inline o: CFuncPtr0[GLuint]): PFNGLBUFFERREGIONENABLEDPROC = o
    extension (v: PFNGLBUFFERREGIONENABLEDPROC)
      inline def value: CFuncPtr0[GLuint] = v
      inline def toPtr: Ptr[?] = CFuncPtr.toPtr(v)

  opaque type PFNGLBUFFERSTORAGEEXTERNALEXTPROC = CFuncPtr5[GLenum, GLintptr, GLsizeiptr, GLeglClientBufferEXT, GLbitfield, Unit]
  object PFNGLBUFFERSTORAGEEXTERNALEXTPROC:
    given _tag: Tag[PFNGLBUFFERSTORAGEEXTERNALEXTPROC] = Tag.materializeCFuncPtr5[GLenum, GLintptr, GLsizeiptr, GLeglClientBufferEXT, GLbitfield, Unit]
    inline def fromPtr(ptr: Ptr[Byte] | Ptr[?]): PFNGLBUFFERSTORAGEEXTERNALEXTPROC = CFuncPtr.fromPtr(ptr.asInstanceOf[Ptr[Byte]])
    inline def apply(inline o: CFuncPtr5[GLenum, GLintptr, GLsizeiptr, GLeglClientBufferEXT, GLbitfield, Unit]): PFNGLBUFFERSTORAGEEXTERNALEXTPROC = o
    extension (v: PFNGLBUFFERSTORAGEEXTERNALEXTPROC)
      inline def value: CFuncPtr5[GLenum, GLintptr, GLsizeiptr, GLeglClientBufferEXT, GLbitfield, Unit] = v
      inline def toPtr: Ptr[?] = CFuncPtr.toPtr(v)

  opaque type PFNGLBUFFERSTORAGEEXTPROC = CFuncPtr4[GLenum, GLsizeiptr, Ptr[Byte], GLbitfield, Unit]
  object PFNGLBUFFERSTORAGEEXTPROC:
    given _tag: Tag[PFNGLBUFFERSTORAGEEXTPROC] = Tag.materializeCFuncPtr4[GLenum, GLsizeiptr, Ptr[Byte], GLbitfield, Unit]
    inline def fromPtr(ptr: Ptr[Byte] | Ptr[?]): PFNGLBUFFERSTORAGEEXTPROC = CFuncPtr.fromPtr(ptr.asInstanceOf[Ptr[Byte]])
    inline def apply(inline o: CFuncPtr4[GLenum, GLsizeiptr, Ptr[Byte], GLbitfield, Unit]): PFNGLBUFFERSTORAGEEXTPROC = o
    extension (v: PFNGLBUFFERSTORAGEEXTPROC)
      inline def value: CFuncPtr4[GLenum, GLsizeiptr, Ptr[Byte], GLbitfield, Unit] = v
      inline def toPtr: Ptr[?] = CFuncPtr.toPtr(v)

  opaque type PFNGLBUFFERSTORAGEMEMEXTPROC = CFuncPtr4[GLenum, GLsizeiptr, GLuint, GLuint64, Unit]
  object PFNGLBUFFERSTORAGEMEMEXTPROC:
    given _tag: Tag[PFNGLBUFFERSTORAGEMEMEXTPROC] = Tag.materializeCFuncPtr4[GLenum, GLsizeiptr, GLuint, GLuint64, Unit]
    inline def fromPtr(ptr: Ptr[Byte] | Ptr[?]): PFNGLBUFFERSTORAGEMEMEXTPROC = CFuncPtr.fromPtr(ptr.asInstanceOf[Ptr[Byte]])
    inline def apply(inline o: CFuncPtr4[GLenum, GLsizeiptr, GLuint, GLuint64, Unit]): PFNGLBUFFERSTORAGEMEMEXTPROC = o
    extension (v: PFNGLBUFFERSTORAGEMEMEXTPROC)
      inline def value: CFuncPtr4[GLenum, GLsizeiptr, GLuint, GLuint64, Unit] = v
      inline def toPtr: Ptr[?] = CFuncPtr.toPtr(v)

  opaque type PFNGLBUFFERSTORAGEPROC = CFuncPtr4[GLenum, GLsizeiptr, Ptr[Byte], GLbitfield, Unit]
  object PFNGLBUFFERSTORAGEPROC:
    given _tag: Tag[PFNGLBUFFERSTORAGEPROC] = Tag.materializeCFuncPtr4[GLenum, GLsizeiptr, Ptr[Byte], GLbitfield, Unit]
    inline def fromPtr(ptr: Ptr[Byte] | Ptr[?]): PFNGLBUFFERSTORAGEPROC = CFuncPtr.fromPtr(ptr.asInstanceOf[Ptr[Byte]])
    inline def apply(inline o: CFuncPtr4[GLenum, GLsizeiptr, Ptr[Byte], GLbitfield, Unit]): PFNGLBUFFERSTORAGEPROC = o
    extension (v: PFNGLBUFFERSTORAGEPROC)
      inline def value: CFuncPtr4[GLenum, GLsizeiptr, Ptr[Byte], GLbitfield, Unit] = v
      inline def toPtr: Ptr[?] = CFuncPtr.toPtr(v)

  opaque type PFNGLBUFFERSUBDATAARBPROC = CFuncPtr4[GLenum, GLintptrARB, GLsizeiptrARB, Ptr[Byte], Unit]
  object PFNGLBUFFERSUBDATAARBPROC:
    given _tag: Tag[PFNGLBUFFERSUBDATAARBPROC] = Tag.materializeCFuncPtr4[GLenum, GLintptrARB, GLsizeiptrARB, Ptr[Byte], Unit]
    inline def fromPtr(ptr: Ptr[Byte] | Ptr[?]): PFNGLBUFFERSUBDATAARBPROC = CFuncPtr.fromPtr(ptr.asInstanceOf[Ptr[Byte]])
    inline def apply(inline o: CFuncPtr4[GLenum, GLintptrARB, GLsizeiptrARB, Ptr[Byte], Unit]): PFNGLBUFFERSUBDATAARBPROC = o
    extension (v: PFNGLBUFFERSUBDATAARBPROC)
      inline def value: CFuncPtr4[GLenum, GLintptrARB, GLsizeiptrARB, Ptr[Byte], Unit] = v
      inline def toPtr: Ptr[?] = CFuncPtr.toPtr(v)

  opaque type PFNGLBUFFERSUBDATAPROC = CFuncPtr4[GLenum, GLintptr, GLsizeiptr, Ptr[Byte], Unit]
  object PFNGLBUFFERSUBDATAPROC:
    given _tag: Tag[PFNGLBUFFERSUBDATAPROC] = Tag.materializeCFuncPtr4[GLenum, GLintptr, GLsizeiptr, Ptr[Byte], Unit]
    inline def fromPtr(ptr: Ptr[Byte] | Ptr[?]): PFNGLBUFFERSUBDATAPROC = CFuncPtr.fromPtr(ptr.asInstanceOf[Ptr[Byte]])
    inline def apply(inline o: CFuncPtr4[GLenum, GLintptr, GLsizeiptr, Ptr[Byte], Unit]): PFNGLBUFFERSUBDATAPROC = o
    extension (v: PFNGLBUFFERSUBDATAPROC)
      inline def value: CFuncPtr4[GLenum, GLintptr, GLsizeiptr, Ptr[Byte], Unit] = v
      inline def toPtr: Ptr[?] = CFuncPtr.toPtr(v)

  opaque type PFNGLCALLCOMMANDLISTNVPROC = CFuncPtr1[GLuint, Unit]
  object PFNGLCALLCOMMANDLISTNVPROC:
    given _tag: Tag[PFNGLCALLCOMMANDLISTNVPROC] = Tag.materializeCFuncPtr1[GLuint, Unit]
    inline def fromPtr(ptr: Ptr[Byte] | Ptr[?]): PFNGLCALLCOMMANDLISTNVPROC = CFuncPtr.fromPtr(ptr.asInstanceOf[Ptr[Byte]])
    inline def apply(inline o: CFuncPtr1[GLuint, Unit]): PFNGLCALLCOMMANDLISTNVPROC = o
    extension (v: PFNGLCALLCOMMANDLISTNVPROC)
      inline def value: CFuncPtr1[GLuint, Unit] = v
      inline def toPtr: Ptr[?] = CFuncPtr.toPtr(v)

  opaque type PFNGLCHECKFRAMEBUFFERSTATUSEXTPROC = CFuncPtr1[GLenum, GLenum]
  object PFNGLCHECKFRAMEBUFFERSTATUSEXTPROC:
    given _tag: Tag[PFNGLCHECKFRAMEBUFFERSTATUSEXTPROC] = Tag.materializeCFuncPtr1[GLenum, GLenum]
    inline def fromPtr(ptr: Ptr[Byte] | Ptr[?]): PFNGLCHECKFRAMEBUFFERSTATUSEXTPROC = CFuncPtr.fromPtr(ptr.asInstanceOf[Ptr[Byte]])
    inline def apply(inline o: CFuncPtr1[GLenum, GLenum]): PFNGLCHECKFRAMEBUFFERSTATUSEXTPROC = o
    extension (v: PFNGLCHECKFRAMEBUFFERSTATUSEXTPROC)
      inline def value: CFuncPtr1[GLenum, GLenum] = v
      inline def toPtr: Ptr[?] = CFuncPtr.toPtr(v)

  opaque type PFNGLCHECKFRAMEBUFFERSTATUSOESPROC = CFuncPtr1[GLenum, GLenum]
  object PFNGLCHECKFRAMEBUFFERSTATUSOESPROC:
    given _tag: Tag[PFNGLCHECKFRAMEBUFFERSTATUSOESPROC] = Tag.materializeCFuncPtr1[GLenum, GLenum]
    inline def fromPtr(ptr: Ptr[Byte] | Ptr[?]): PFNGLCHECKFRAMEBUFFERSTATUSOESPROC = CFuncPtr.fromPtr(ptr.asInstanceOf[Ptr[Byte]])
    inline def apply(inline o: CFuncPtr1[GLenum, GLenum]): PFNGLCHECKFRAMEBUFFERSTATUSOESPROC = o
    extension (v: PFNGLCHECKFRAMEBUFFERSTATUSOESPROC)
      inline def value: CFuncPtr1[GLenum, GLenum] = v
      inline def toPtr: Ptr[?] = CFuncPtr.toPtr(v)

  opaque type PFNGLCHECKFRAMEBUFFERSTATUSPROC = CFuncPtr1[GLenum, GLenum]
  object PFNGLCHECKFRAMEBUFFERSTATUSPROC:
    given _tag: Tag[PFNGLCHECKFRAMEBUFFERSTATUSPROC] = Tag.materializeCFuncPtr1[GLenum, GLenum]
    inline def fromPtr(ptr: Ptr[Byte] | Ptr[?]): PFNGLCHECKFRAMEBUFFERSTATUSPROC = CFuncPtr.fromPtr(ptr.asInstanceOf[Ptr[Byte]])
    inline def apply(inline o: CFuncPtr1[GLenum, GLenum]): PFNGLCHECKFRAMEBUFFERSTATUSPROC = o
    extension (v: PFNGLCHECKFRAMEBUFFERSTATUSPROC)
      inline def value: CFuncPtr1[GLenum, GLenum] = v
      inline def toPtr: Ptr[?] = CFuncPtr.toPtr(v)

  opaque type PFNGLCHECKNAMEDFRAMEBUFFERSTATUSEXTPROC = CFuncPtr2[GLuint, GLenum, GLenum]
  object PFNGLCHECKNAMEDFRAMEBUFFERSTATUSEXTPROC:
    given _tag: Tag[PFNGLCHECKNAMEDFRAMEBUFFERSTATUSEXTPROC] = Tag.materializeCFuncPtr2[GLuint, GLenum, GLenum]
    inline def fromPtr(ptr: Ptr[Byte] | Ptr[?]): PFNGLCHECKNAMEDFRAMEBUFFERSTATUSEXTPROC = CFuncPtr.fromPtr(ptr.asInstanceOf[Ptr[Byte]])
    inline def apply(inline o: CFuncPtr2[GLuint, GLenum, GLenum]): PFNGLCHECKNAMEDFRAMEBUFFERSTATUSEXTPROC = o
    extension (v: PFNGLCHECKNAMEDFRAMEBUFFERSTATUSEXTPROC)
      inline def value: CFuncPtr2[GLuint, GLenum, GLenum] = v
      inline def toPtr: Ptr[?] = CFuncPtr.toPtr(v)

  opaque type PFNGLCHECKNAMEDFRAMEBUFFERSTATUSPROC = CFuncPtr2[GLuint, GLenum, GLenum]
  object PFNGLCHECKNAMEDFRAMEBUFFERSTATUSPROC:
    given _tag: Tag[PFNGLCHECKNAMEDFRAMEBUFFERSTATUSPROC] = Tag.materializeCFuncPtr2[GLuint, GLenum, GLenum]
    inline def fromPtr(ptr: Ptr[Byte] | Ptr[?]): PFNGLCHECKNAMEDFRAMEBUFFERSTATUSPROC = CFuncPtr.fromPtr(ptr.asInstanceOf[Ptr[Byte]])
    inline def apply(inline o: CFuncPtr2[GLuint, GLenum, GLenum]): PFNGLCHECKNAMEDFRAMEBUFFERSTATUSPROC = o
    extension (v: PFNGLCHECKNAMEDFRAMEBUFFERSTATUSPROC)
      inline def value: CFuncPtr2[GLuint, GLenum, GLenum] = v
      inline def toPtr: Ptr[?] = CFuncPtr.toPtr(v)

  opaque type PFNGLCLAMPCOLORARBPROC = CFuncPtr2[GLenum, GLenum, Unit]
  object PFNGLCLAMPCOLORARBPROC:
    given _tag: Tag[PFNGLCLAMPCOLORARBPROC] = Tag.materializeCFuncPtr2[GLenum, GLenum, Unit]
    inline def fromPtr(ptr: Ptr[Byte] | Ptr[?]): PFNGLCLAMPCOLORARBPROC = CFuncPtr.fromPtr(ptr.asInstanceOf[Ptr[Byte]])
    inline def apply(inline o: CFuncPtr2[GLenum, GLenum, Unit]): PFNGLCLAMPCOLORARBPROC = o
    extension (v: PFNGLCLAMPCOLORARBPROC)
      inline def value: CFuncPtr2[GLenum, GLenum, Unit] = v
      inline def toPtr: Ptr[?] = CFuncPtr.toPtr(v)

  opaque type PFNGLCLAMPCOLORPROC = CFuncPtr2[GLenum, GLenum, Unit]
  object PFNGLCLAMPCOLORPROC:
    given _tag: Tag[PFNGLCLAMPCOLORPROC] = Tag.materializeCFuncPtr2[GLenum, GLenum, Unit]
    inline def fromPtr(ptr: Ptr[Byte] | Ptr[?]): PFNGLCLAMPCOLORPROC = CFuncPtr.fromPtr(ptr.asInstanceOf[Ptr[Byte]])
    inline def apply(inline o: CFuncPtr2[GLenum, GLenum, Unit]): PFNGLCLAMPCOLORPROC = o
    extension (v: PFNGLCLAMPCOLORPROC)
      inline def value: CFuncPtr2[GLenum, GLenum, Unit] = v
      inline def toPtr: Ptr[?] = CFuncPtr.toPtr(v)

  opaque type PFNGLCLEARBUFFERDATAPROC = CFuncPtr5[GLenum, GLenum, GLenum, GLenum, Ptr[Byte], Unit]
  object PFNGLCLEARBUFFERDATAPROC:
    given _tag: Tag[PFNGLCLEARBUFFERDATAPROC] = Tag.materializeCFuncPtr5[GLenum, GLenum, GLenum, GLenum, Ptr[Byte], Unit]
    inline def fromPtr(ptr: Ptr[Byte] | Ptr[?]): PFNGLCLEARBUFFERDATAPROC = CFuncPtr.fromPtr(ptr.asInstanceOf[Ptr[Byte]])
    inline def apply(inline o: CFuncPtr5[GLenum, GLenum, GLenum, GLenum, Ptr[Byte], Unit]): PFNGLCLEARBUFFERDATAPROC = o
    extension (v: PFNGLCLEARBUFFERDATAPROC)
      inline def value: CFuncPtr5[GLenum, GLenum, GLenum, GLenum, Ptr[Byte], Unit] = v
      inline def toPtr: Ptr[?] = CFuncPtr.toPtr(v)

  opaque type PFNGLCLEARBUFFERFIPROC = CFuncPtr4[GLenum, GLint, GLfloat, GLint, Unit]
  object PFNGLCLEARBUFFERFIPROC:
    given _tag: Tag[PFNGLCLEARBUFFERFIPROC] = Tag.materializeCFuncPtr4[GLenum, GLint, GLfloat, GLint, Unit]
    inline def fromPtr(ptr: Ptr[Byte] | Ptr[?]): PFNGLCLEARBUFFERFIPROC = CFuncPtr.fromPtr(ptr.asInstanceOf[Ptr[Byte]])
    inline def apply(inline o: CFuncPtr4[GLenum, GLint, GLfloat, GLint, Unit]): PFNGLCLEARBUFFERFIPROC = o
    extension (v: PFNGLCLEARBUFFERFIPROC)
      inline def value: CFuncPtr4[GLenum, GLint, GLfloat, GLint, Unit] = v
      inline def toPtr: Ptr[?] = CFuncPtr.toPtr(v)

  opaque type PFNGLCLEARBUFFERFVPROC = CFuncPtr3[GLenum, GLint, Ptr[GLfloat], Unit]
  object PFNGLCLEARBUFFERFVPROC:
    given _tag: Tag[PFNGLCLEARBUFFERFVPROC] = Tag.materializeCFuncPtr3[GLenum, GLint, Ptr[GLfloat], Unit]
    inline def fromPtr(ptr: Ptr[Byte] | Ptr[?]): PFNGLCLEARBUFFERFVPROC = CFuncPtr.fromPtr(ptr.asInstanceOf[Ptr[Byte]])
    inline def apply(inline o: CFuncPtr3[GLenum, GLint, Ptr[GLfloat], Unit]): PFNGLCLEARBUFFERFVPROC = o
    extension (v: PFNGLCLEARBUFFERFVPROC)
      inline def value: CFuncPtr3[GLenum, GLint, Ptr[GLfloat], Unit] = v
      inline def toPtr: Ptr[?] = CFuncPtr.toPtr(v)

  opaque type PFNGLCLEARBUFFERIVPROC = CFuncPtr3[GLenum, GLint, Ptr[GLint], Unit]
  object PFNGLCLEARBUFFERIVPROC:
    given _tag: Tag[PFNGLCLEARBUFFERIVPROC] = Tag.materializeCFuncPtr3[GLenum, GLint, Ptr[GLint], Unit]
    inline def fromPtr(ptr: Ptr[Byte] | Ptr[?]): PFNGLCLEARBUFFERIVPROC = CFuncPtr.fromPtr(ptr.asInstanceOf[Ptr[Byte]])
    inline def apply(inline o: CFuncPtr3[GLenum, GLint, Ptr[GLint], Unit]): PFNGLCLEARBUFFERIVPROC = o
    extension (v: PFNGLCLEARBUFFERIVPROC)
      inline def value: CFuncPtr3[GLenum, GLint, Ptr[GLint], Unit] = v
      inline def toPtr: Ptr[?] = CFuncPtr.toPtr(v)

  opaque type PFNGLCLEARBUFFERSUBDATAPROC = CFuncPtr7[GLenum, GLenum, GLintptr, GLsizeiptr, GLenum, GLenum, Ptr[Byte], Unit]
  object PFNGLCLEARBUFFERSUBDATAPROC:
    given _tag: Tag[PFNGLCLEARBUFFERSUBDATAPROC] = Tag.materializeCFuncPtr7[GLenum, GLenum, GLintptr, GLsizeiptr, GLenum, GLenum, Ptr[Byte], Unit]
    inline def fromPtr(ptr: Ptr[Byte] | Ptr[?]): PFNGLCLEARBUFFERSUBDATAPROC = CFuncPtr.fromPtr(ptr.asInstanceOf[Ptr[Byte]])
    inline def apply(inline o: CFuncPtr7[GLenum, GLenum, GLintptr, GLsizeiptr, GLenum, GLenum, Ptr[Byte], Unit]): PFNGLCLEARBUFFERSUBDATAPROC = o
    extension (v: PFNGLCLEARBUFFERSUBDATAPROC)
      inline def value: CFuncPtr7[GLenum, GLenum, GLintptr, GLsizeiptr, GLenum, GLenum, Ptr[Byte], Unit] = v
      inline def toPtr: Ptr[?] = CFuncPtr.toPtr(v)

  opaque type PFNGLCLEARBUFFERUIVPROC = CFuncPtr3[GLenum, GLint, Ptr[GLuint], Unit]
  object PFNGLCLEARBUFFERUIVPROC:
    given _tag: Tag[PFNGLCLEARBUFFERUIVPROC] = Tag.materializeCFuncPtr3[GLenum, GLint, Ptr[GLuint], Unit]
    inline def fromPtr(ptr: Ptr[Byte] | Ptr[?]): PFNGLCLEARBUFFERUIVPROC = CFuncPtr.fromPtr(ptr.asInstanceOf[Ptr[Byte]])
    inline def apply(inline o: CFuncPtr3[GLenum, GLint, Ptr[GLuint], Unit]): PFNGLCLEARBUFFERUIVPROC = o
    extension (v: PFNGLCLEARBUFFERUIVPROC)
      inline def value: CFuncPtr3[GLenum, GLint, Ptr[GLuint], Unit] = v
      inline def toPtr: Ptr[?] = CFuncPtr.toPtr(v)

  opaque type PFNGLCLEARCOLORIIEXTPROC = CFuncPtr4[GLint, GLint, GLint, GLint, Unit]
  object PFNGLCLEARCOLORIIEXTPROC:
    given _tag: Tag[PFNGLCLEARCOLORIIEXTPROC] = Tag.materializeCFuncPtr4[GLint, GLint, GLint, GLint, Unit]
    inline def fromPtr(ptr: Ptr[Byte] | Ptr[?]): PFNGLCLEARCOLORIIEXTPROC = CFuncPtr.fromPtr(ptr.asInstanceOf[Ptr[Byte]])
    inline def apply(inline o: CFuncPtr4[GLint, GLint, GLint, GLint, Unit]): PFNGLCLEARCOLORIIEXTPROC = o
    extension (v: PFNGLCLEARCOLORIIEXTPROC)
      inline def value: CFuncPtr4[GLint, GLint, GLint, GLint, Unit] = v
      inline def toPtr: Ptr[?] = CFuncPtr.toPtr(v)

  opaque type PFNGLCLEARCOLORIUIEXTPROC = CFuncPtr4[GLuint, GLuint, GLuint, GLuint, Unit]
  object PFNGLCLEARCOLORIUIEXTPROC:
    given _tag: Tag[PFNGLCLEARCOLORIUIEXTPROC] = Tag.materializeCFuncPtr4[GLuint, GLuint, GLuint, GLuint, Unit]
    inline def fromPtr(ptr: Ptr[Byte] | Ptr[?]): PFNGLCLEARCOLORIUIEXTPROC = CFuncPtr.fromPtr(ptr.asInstanceOf[Ptr[Byte]])
    inline def apply(inline o: CFuncPtr4[GLuint, GLuint, GLuint, GLuint, Unit]): PFNGLCLEARCOLORIUIEXTPROC = o
    extension (v: PFNGLCLEARCOLORIUIEXTPROC)
      inline def value: CFuncPtr4[GLuint, GLuint, GLuint, GLuint, Unit] = v
      inline def toPtr: Ptr[?] = CFuncPtr.toPtr(v)

  opaque type PFNGLCLEARCOLORXPROC = CFuncPtr4[GLclampx, GLclampx, GLclampx, GLclampx, Unit]
  object PFNGLCLEARCOLORXPROC:
    given _tag: Tag[PFNGLCLEARCOLORXPROC] = Tag.materializeCFuncPtr4[GLclampx, GLclampx, GLclampx, GLclampx, Unit]
    inline def fromPtr(ptr: Ptr[Byte] | Ptr[?]): PFNGLCLEARCOLORXPROC = CFuncPtr.fromPtr(ptr.asInstanceOf[Ptr[Byte]])
    inline def apply(inline o: CFuncPtr4[GLclampx, GLclampx, GLclampx, GLclampx, Unit]): PFNGLCLEARCOLORXPROC = o
    extension (v: PFNGLCLEARCOLORXPROC)
      inline def value: CFuncPtr4[GLclampx, GLclampx, GLclampx, GLclampx, Unit] = v
      inline def toPtr: Ptr[?] = CFuncPtr.toPtr(v)

  opaque type PFNGLCLEARDEPTHDNVPROC = CFuncPtr1[GLdouble, Unit]
  object PFNGLCLEARDEPTHDNVPROC:
    given _tag: Tag[PFNGLCLEARDEPTHDNVPROC] = Tag.materializeCFuncPtr1[GLdouble, Unit]
    inline def fromPtr(ptr: Ptr[Byte] | Ptr[?]): PFNGLCLEARDEPTHDNVPROC = CFuncPtr.fromPtr(ptr.asInstanceOf[Ptr[Byte]])
    inline def apply(inline o: CFuncPtr1[GLdouble, Unit]): PFNGLCLEARDEPTHDNVPROC = o
    extension (v: PFNGLCLEARDEPTHDNVPROC)
      inline def value: CFuncPtr1[GLdouble, Unit] = v
      inline def toPtr: Ptr[?] = CFuncPtr.toPtr(v)

  opaque type PFNGLCLEARDEPTHFOESPROC = CFuncPtr1[GLclampf, Unit]
  object PFNGLCLEARDEPTHFOESPROC:
    given _tag: Tag[PFNGLCLEARDEPTHFOESPROC] = Tag.materializeCFuncPtr1[GLclampf, Unit]
    inline def fromPtr(ptr: Ptr[Byte] | Ptr[?]): PFNGLCLEARDEPTHFOESPROC = CFuncPtr.fromPtr(ptr.asInstanceOf[Ptr[Byte]])
    inline def apply(inline o: CFuncPtr1[GLclampf, Unit]): PFNGLCLEARDEPTHFOESPROC = o
    extension (v: PFNGLCLEARDEPTHFOESPROC)
      inline def value: CFuncPtr1[GLclampf, Unit] = v
      inline def toPtr: Ptr[?] = CFuncPtr.toPtr(v)

  opaque type PFNGLCLEARDEPTHFPROC = CFuncPtr1[GLclampf, Unit]
  object PFNGLCLEARDEPTHFPROC:
    given _tag: Tag[PFNGLCLEARDEPTHFPROC] = Tag.materializeCFuncPtr1[GLclampf, Unit]
    inline def fromPtr(ptr: Ptr[Byte] | Ptr[?]): PFNGLCLEARDEPTHFPROC = CFuncPtr.fromPtr(ptr.asInstanceOf[Ptr[Byte]])
    inline def apply(inline o: CFuncPtr1[GLclampf, Unit]): PFNGLCLEARDEPTHFPROC = o
    extension (v: PFNGLCLEARDEPTHFPROC)
      inline def value: CFuncPtr1[GLclampf, Unit] = v
      inline def toPtr: Ptr[?] = CFuncPtr.toPtr(v)

  opaque type PFNGLCLEARDEPTHXPROC = CFuncPtr1[GLclampx, Unit]
  object PFNGLCLEARDEPTHXPROC:
    given _tag: Tag[PFNGLCLEARDEPTHXPROC] = Tag.materializeCFuncPtr1[GLclampx, Unit]
    inline def fromPtr(ptr: Ptr[Byte] | Ptr[?]): PFNGLCLEARDEPTHXPROC = CFuncPtr.fromPtr(ptr.asInstanceOf[Ptr[Byte]])
    inline def apply(inline o: CFuncPtr1[GLclampx, Unit]): PFNGLCLEARDEPTHXPROC = o
    extension (v: PFNGLCLEARDEPTHXPROC)
      inline def value: CFuncPtr1[GLclampx, Unit] = v
      inline def toPtr: Ptr[?] = CFuncPtr.toPtr(v)

  opaque type PFNGLCLEARNAMEDBUFFERDATAEXTPROC = CFuncPtr5[GLuint, GLenum, GLenum, GLenum, Ptr[Byte], Unit]
  object PFNGLCLEARNAMEDBUFFERDATAEXTPROC:
    given _tag: Tag[PFNGLCLEARNAMEDBUFFERDATAEXTPROC] = Tag.materializeCFuncPtr5[GLuint, GLenum, GLenum, GLenum, Ptr[Byte], Unit]
    inline def fromPtr(ptr: Ptr[Byte] | Ptr[?]): PFNGLCLEARNAMEDBUFFERDATAEXTPROC = CFuncPtr.fromPtr(ptr.asInstanceOf[Ptr[Byte]])
    inline def apply(inline o: CFuncPtr5[GLuint, GLenum, GLenum, GLenum, Ptr[Byte], Unit]): PFNGLCLEARNAMEDBUFFERDATAEXTPROC = o
    extension (v: PFNGLCLEARNAMEDBUFFERDATAEXTPROC)
      inline def value: CFuncPtr5[GLuint, GLenum, GLenum, GLenum, Ptr[Byte], Unit] = v
      inline def toPtr: Ptr[?] = CFuncPtr.toPtr(v)

  opaque type PFNGLCLEARNAMEDBUFFERDATAPROC = CFuncPtr5[GLuint, GLenum, GLenum, GLenum, Ptr[Byte], Unit]
  object PFNGLCLEARNAMEDBUFFERDATAPROC:
    given _tag: Tag[PFNGLCLEARNAMEDBUFFERDATAPROC] = Tag.materializeCFuncPtr5[GLuint, GLenum, GLenum, GLenum, Ptr[Byte], Unit]
    inline def fromPtr(ptr: Ptr[Byte] | Ptr[?]): PFNGLCLEARNAMEDBUFFERDATAPROC = CFuncPtr.fromPtr(ptr.asInstanceOf[Ptr[Byte]])
    inline def apply(inline o: CFuncPtr5[GLuint, GLenum, GLenum, GLenum, Ptr[Byte], Unit]): PFNGLCLEARNAMEDBUFFERDATAPROC = o
    extension (v: PFNGLCLEARNAMEDBUFFERDATAPROC)
      inline def value: CFuncPtr5[GLuint, GLenum, GLenum, GLenum, Ptr[Byte], Unit] = v
      inline def toPtr: Ptr[?] = CFuncPtr.toPtr(v)

  opaque type PFNGLCLEARNAMEDBUFFERSUBDATAEXTPROC = CFuncPtr7[GLuint, GLenum, GLintptr, GLsizeiptr, GLenum, GLenum, Ptr[Byte], Unit]
  object PFNGLCLEARNAMEDBUFFERSUBDATAEXTPROC:
    given _tag: Tag[PFNGLCLEARNAMEDBUFFERSUBDATAEXTPROC] = Tag.materializeCFuncPtr7[GLuint, GLenum, GLintptr, GLsizeiptr, GLenum, GLenum, Ptr[Byte], Unit]
    inline def fromPtr(ptr: Ptr[Byte] | Ptr[?]): PFNGLCLEARNAMEDBUFFERSUBDATAEXTPROC = CFuncPtr.fromPtr(ptr.asInstanceOf[Ptr[Byte]])
    inline def apply(inline o: CFuncPtr7[GLuint, GLenum, GLintptr, GLsizeiptr, GLenum, GLenum, Ptr[Byte], Unit]): PFNGLCLEARNAMEDBUFFERSUBDATAEXTPROC = o
    extension (v: PFNGLCLEARNAMEDBUFFERSUBDATAEXTPROC)
      inline def value: CFuncPtr7[GLuint, GLenum, GLintptr, GLsizeiptr, GLenum, GLenum, Ptr[Byte], Unit] = v
      inline def toPtr: Ptr[?] = CFuncPtr.toPtr(v)

  opaque type PFNGLCLEARNAMEDBUFFERSUBDATAPROC = CFuncPtr7[GLuint, GLenum, GLintptr, GLsizeiptr, GLenum, GLenum, Ptr[Byte], Unit]
  object PFNGLCLEARNAMEDBUFFERSUBDATAPROC:
    given _tag: Tag[PFNGLCLEARNAMEDBUFFERSUBDATAPROC] = Tag.materializeCFuncPtr7[GLuint, GLenum, GLintptr, GLsizeiptr, GLenum, GLenum, Ptr[Byte], Unit]
    inline def fromPtr(ptr: Ptr[Byte] | Ptr[?]): PFNGLCLEARNAMEDBUFFERSUBDATAPROC = CFuncPtr.fromPtr(ptr.asInstanceOf[Ptr[Byte]])
    inline def apply(inline o: CFuncPtr7[GLuint, GLenum, GLintptr, GLsizeiptr, GLenum, GLenum, Ptr[Byte], Unit]): PFNGLCLEARNAMEDBUFFERSUBDATAPROC = o
    extension (v: PFNGLCLEARNAMEDBUFFERSUBDATAPROC)
      inline def value: CFuncPtr7[GLuint, GLenum, GLintptr, GLsizeiptr, GLenum, GLenum, Ptr[Byte], Unit] = v
      inline def toPtr: Ptr[?] = CFuncPtr.toPtr(v)

  opaque type PFNGLCLEARNAMEDFRAMEBUFFERFIPROC = CFuncPtr5[GLuint, GLenum, GLint, GLfloat, GLint, Unit]
  object PFNGLCLEARNAMEDFRAMEBUFFERFIPROC:
    given _tag: Tag[PFNGLCLEARNAMEDFRAMEBUFFERFIPROC] = Tag.materializeCFuncPtr5[GLuint, GLenum, GLint, GLfloat, GLint, Unit]
    inline def fromPtr(ptr: Ptr[Byte] | Ptr[?]): PFNGLCLEARNAMEDFRAMEBUFFERFIPROC = CFuncPtr.fromPtr(ptr.asInstanceOf[Ptr[Byte]])
    inline def apply(inline o: CFuncPtr5[GLuint, GLenum, GLint, GLfloat, GLint, Unit]): PFNGLCLEARNAMEDFRAMEBUFFERFIPROC = o
    extension (v: PFNGLCLEARNAMEDFRAMEBUFFERFIPROC)
      inline def value: CFuncPtr5[GLuint, GLenum, GLint, GLfloat, GLint, Unit] = v
      inline def toPtr: Ptr[?] = CFuncPtr.toPtr(v)

  opaque type PFNGLCLEARNAMEDFRAMEBUFFERFVPROC = CFuncPtr4[GLuint, GLenum, GLint, Ptr[GLfloat], Unit]
  object PFNGLCLEARNAMEDFRAMEBUFFERFVPROC:
    given _tag: Tag[PFNGLCLEARNAMEDFRAMEBUFFERFVPROC] = Tag.materializeCFuncPtr4[GLuint, GLenum, GLint, Ptr[GLfloat], Unit]
    inline def fromPtr(ptr: Ptr[Byte] | Ptr[?]): PFNGLCLEARNAMEDFRAMEBUFFERFVPROC = CFuncPtr.fromPtr(ptr.asInstanceOf[Ptr[Byte]])
    inline def apply(inline o: CFuncPtr4[GLuint, GLenum, GLint, Ptr[GLfloat], Unit]): PFNGLCLEARNAMEDFRAMEBUFFERFVPROC = o
    extension (v: PFNGLCLEARNAMEDFRAMEBUFFERFVPROC)
      inline def value: CFuncPtr4[GLuint, GLenum, GLint, Ptr[GLfloat], Unit] = v
      inline def toPtr: Ptr[?] = CFuncPtr.toPtr(v)

  opaque type PFNGLCLEARNAMEDFRAMEBUFFERIVPROC = CFuncPtr4[GLuint, GLenum, GLint, Ptr[GLint], Unit]
  object PFNGLCLEARNAMEDFRAMEBUFFERIVPROC:
    given _tag: Tag[PFNGLCLEARNAMEDFRAMEBUFFERIVPROC] = Tag.materializeCFuncPtr4[GLuint, GLenum, GLint, Ptr[GLint], Unit]
    inline def fromPtr(ptr: Ptr[Byte] | Ptr[?]): PFNGLCLEARNAMEDFRAMEBUFFERIVPROC = CFuncPtr.fromPtr(ptr.asInstanceOf[Ptr[Byte]])
    inline def apply(inline o: CFuncPtr4[GLuint, GLenum, GLint, Ptr[GLint], Unit]): PFNGLCLEARNAMEDFRAMEBUFFERIVPROC = o
    extension (v: PFNGLCLEARNAMEDFRAMEBUFFERIVPROC)
      inline def value: CFuncPtr4[GLuint, GLenum, GLint, Ptr[GLint], Unit] = v
      inline def toPtr: Ptr[?] = CFuncPtr.toPtr(v)

  opaque type PFNGLCLEARNAMEDFRAMEBUFFERUIVPROC = CFuncPtr4[GLuint, GLenum, GLint, Ptr[GLuint], Unit]
  object PFNGLCLEARNAMEDFRAMEBUFFERUIVPROC:
    given _tag: Tag[PFNGLCLEARNAMEDFRAMEBUFFERUIVPROC] = Tag.materializeCFuncPtr4[GLuint, GLenum, GLint, Ptr[GLuint], Unit]
    inline def fromPtr(ptr: Ptr[Byte] | Ptr[?]): PFNGLCLEARNAMEDFRAMEBUFFERUIVPROC = CFuncPtr.fromPtr(ptr.asInstanceOf[Ptr[Byte]])
    inline def apply(inline o: CFuncPtr4[GLuint, GLenum, GLint, Ptr[GLuint], Unit]): PFNGLCLEARNAMEDFRAMEBUFFERUIVPROC = o
    extension (v: PFNGLCLEARNAMEDFRAMEBUFFERUIVPROC)
      inline def value: CFuncPtr4[GLuint, GLenum, GLint, Ptr[GLuint], Unit] = v
      inline def toPtr: Ptr[?] = CFuncPtr.toPtr(v)

  opaque type PFNGLCLEARPIXELLOCALSTORAGEUIEXTPROC = CFuncPtr3[GLsizei, GLsizei, Ptr[GLuint], Unit]
  object PFNGLCLEARPIXELLOCALSTORAGEUIEXTPROC:
    given _tag: Tag[PFNGLCLEARPIXELLOCALSTORAGEUIEXTPROC] = Tag.materializeCFuncPtr3[GLsizei, GLsizei, Ptr[GLuint], Unit]
    inline def fromPtr(ptr: Ptr[Byte] | Ptr[?]): PFNGLCLEARPIXELLOCALSTORAGEUIEXTPROC = CFuncPtr.fromPtr(ptr.asInstanceOf[Ptr[Byte]])
    inline def apply(inline o: CFuncPtr3[GLsizei, GLsizei, Ptr[GLuint], Unit]): PFNGLCLEARPIXELLOCALSTORAGEUIEXTPROC = o
    extension (v: PFNGLCLEARPIXELLOCALSTORAGEUIEXTPROC)
      inline def value: CFuncPtr3[GLsizei, GLsizei, Ptr[GLuint], Unit] = v
      inline def toPtr: Ptr[?] = CFuncPtr.toPtr(v)

  opaque type PFNGLCLEARTEXIMAGEEXTPROC = CFuncPtr5[GLuint, GLint, GLenum, GLenum, Ptr[Byte], Unit]
  object PFNGLCLEARTEXIMAGEEXTPROC:
    given _tag: Tag[PFNGLCLEARTEXIMAGEEXTPROC] = Tag.materializeCFuncPtr5[GLuint, GLint, GLenum, GLenum, Ptr[Byte], Unit]
    inline def fromPtr(ptr: Ptr[Byte] | Ptr[?]): PFNGLCLEARTEXIMAGEEXTPROC = CFuncPtr.fromPtr(ptr.asInstanceOf[Ptr[Byte]])
    inline def apply(inline o: CFuncPtr5[GLuint, GLint, GLenum, GLenum, Ptr[Byte], Unit]): PFNGLCLEARTEXIMAGEEXTPROC = o
    extension (v: PFNGLCLEARTEXIMAGEEXTPROC)
      inline def value: CFuncPtr5[GLuint, GLint, GLenum, GLenum, Ptr[Byte], Unit] = v
      inline def toPtr: Ptr[?] = CFuncPtr.toPtr(v)

  opaque type PFNGLCLEARTEXIMAGEPROC = CFuncPtr5[GLuint, GLint, GLenum, GLenum, Ptr[Byte], Unit]
  object PFNGLCLEARTEXIMAGEPROC:
    given _tag: Tag[PFNGLCLEARTEXIMAGEPROC] = Tag.materializeCFuncPtr5[GLuint, GLint, GLenum, GLenum, Ptr[Byte], Unit]
    inline def fromPtr(ptr: Ptr[Byte] | Ptr[?]): PFNGLCLEARTEXIMAGEPROC = CFuncPtr.fromPtr(ptr.asInstanceOf[Ptr[Byte]])
    inline def apply(inline o: CFuncPtr5[GLuint, GLint, GLenum, GLenum, Ptr[Byte], Unit]): PFNGLCLEARTEXIMAGEPROC = o
    extension (v: PFNGLCLEARTEXIMAGEPROC)
      inline def value: CFuncPtr5[GLuint, GLint, GLenum, GLenum, Ptr[Byte], Unit] = v
      inline def toPtr: Ptr[?] = CFuncPtr.toPtr(v)

  opaque type PFNGLCLEARTEXSUBIMAGEEXTPROC = CFuncPtr11[GLuint, GLint, GLint, GLint, GLint, GLsizei, GLsizei, GLsizei, GLenum, GLenum, Ptr[Byte], Unit]
  object PFNGLCLEARTEXSUBIMAGEEXTPROC:
    given _tag: Tag[PFNGLCLEARTEXSUBIMAGEEXTPROC] = Tag.materializeCFuncPtr11[GLuint, GLint, GLint, GLint, GLint, GLsizei, GLsizei, GLsizei, GLenum, GLenum, Ptr[Byte], Unit]
    inline def fromPtr(ptr: Ptr[Byte] | Ptr[?]): PFNGLCLEARTEXSUBIMAGEEXTPROC = CFuncPtr.fromPtr(ptr.asInstanceOf[Ptr[Byte]])
    inline def apply(inline o: CFuncPtr11[GLuint, GLint, GLint, GLint, GLint, GLsizei, GLsizei, GLsizei, GLenum, GLenum, Ptr[Byte], Unit]): PFNGLCLEARTEXSUBIMAGEEXTPROC = o
    extension (v: PFNGLCLEARTEXSUBIMAGEEXTPROC)
      inline def value: CFuncPtr11[GLuint, GLint, GLint, GLint, GLint, GLsizei, GLsizei, GLsizei, GLenum, GLenum, Ptr[Byte], Unit] = v
      inline def toPtr: Ptr[?] = CFuncPtr.toPtr(v)

  opaque type PFNGLCLEARTEXSUBIMAGEPROC = CFuncPtr11[GLuint, GLint, GLint, GLint, GLint, GLsizei, GLsizei, GLsizei, GLenum, GLenum, Ptr[Byte], Unit]
  object PFNGLCLEARTEXSUBIMAGEPROC:
    given _tag: Tag[PFNGLCLEARTEXSUBIMAGEPROC] = Tag.materializeCFuncPtr11[GLuint, GLint, GLint, GLint, GLint, GLsizei, GLsizei, GLsizei, GLenum, GLenum, Ptr[Byte], Unit]
    inline def fromPtr(ptr: Ptr[Byte] | Ptr[?]): PFNGLCLEARTEXSUBIMAGEPROC = CFuncPtr.fromPtr(ptr.asInstanceOf[Ptr[Byte]])
    inline def apply(inline o: CFuncPtr11[GLuint, GLint, GLint, GLint, GLint, GLsizei, GLsizei, GLsizei, GLenum, GLenum, Ptr[Byte], Unit]): PFNGLCLEARTEXSUBIMAGEPROC = o
    extension (v: PFNGLCLEARTEXSUBIMAGEPROC)
      inline def value: CFuncPtr11[GLuint, GLint, GLint, GLint, GLint, GLsizei, GLsizei, GLsizei, GLenum, GLenum, Ptr[Byte], Unit] = v
      inline def toPtr: Ptr[?] = CFuncPtr.toPtr(v)

  opaque type PFNGLCLIENTACTIVETEXTUREARBPROC = CFuncPtr1[GLenum, Unit]
  object PFNGLCLIENTACTIVETEXTUREARBPROC:
    given _tag: Tag[PFNGLCLIENTACTIVETEXTUREARBPROC] = Tag.materializeCFuncPtr1[GLenum, Unit]
    inline def fromPtr(ptr: Ptr[Byte] | Ptr[?]): PFNGLCLIENTACTIVETEXTUREARBPROC = CFuncPtr.fromPtr(ptr.asInstanceOf[Ptr[Byte]])
    inline def apply(inline o: CFuncPtr1[GLenum, Unit]): PFNGLCLIENTACTIVETEXTUREARBPROC = o
    extension (v: PFNGLCLIENTACTIVETEXTUREARBPROC)
      inline def value: CFuncPtr1[GLenum, Unit] = v
      inline def toPtr: Ptr[?] = CFuncPtr.toPtr(v)

  opaque type PFNGLCLIENTACTIVETEXTUREPROC = CFuncPtr1[GLenum, Unit]
  object PFNGLCLIENTACTIVETEXTUREPROC:
    given _tag: Tag[PFNGLCLIENTACTIVETEXTUREPROC] = Tag.materializeCFuncPtr1[GLenum, Unit]
    inline def fromPtr(ptr: Ptr[Byte] | Ptr[?]): PFNGLCLIENTACTIVETEXTUREPROC = CFuncPtr.fromPtr(ptr.asInstanceOf[Ptr[Byte]])
    inline def apply(inline o: CFuncPtr1[GLenum, Unit]): PFNGLCLIENTACTIVETEXTUREPROC = o
    extension (v: PFNGLCLIENTACTIVETEXTUREPROC)
      inline def value: CFuncPtr1[GLenum, Unit] = v
      inline def toPtr: Ptr[?] = CFuncPtr.toPtr(v)

  opaque type PFNGLCLIENTACTIVEVERTEXSTREAMATIPROC = CFuncPtr1[GLenum, Unit]
  object PFNGLCLIENTACTIVEVERTEXSTREAMATIPROC:
    given _tag: Tag[PFNGLCLIENTACTIVEVERTEXSTREAMATIPROC] = Tag.materializeCFuncPtr1[GLenum, Unit]
    inline def fromPtr(ptr: Ptr[Byte] | Ptr[?]): PFNGLCLIENTACTIVEVERTEXSTREAMATIPROC = CFuncPtr.fromPtr(ptr.asInstanceOf[Ptr[Byte]])
    inline def apply(inline o: CFuncPtr1[GLenum, Unit]): PFNGLCLIENTACTIVEVERTEXSTREAMATIPROC = o
    extension (v: PFNGLCLIENTACTIVEVERTEXSTREAMATIPROC)
      inline def value: CFuncPtr1[GLenum, Unit] = v
      inline def toPtr: Ptr[?] = CFuncPtr.toPtr(v)

  opaque type PFNGLCLIENTATTRIBDEFAULTEXTPROC = CFuncPtr1[GLbitfield, Unit]
  object PFNGLCLIENTATTRIBDEFAULTEXTPROC:
    given _tag: Tag[PFNGLCLIENTATTRIBDEFAULTEXTPROC] = Tag.materializeCFuncPtr1[GLbitfield, Unit]
    inline def fromPtr(ptr: Ptr[Byte] | Ptr[?]): PFNGLCLIENTATTRIBDEFAULTEXTPROC = CFuncPtr.fromPtr(ptr.asInstanceOf[Ptr[Byte]])
    inline def apply(inline o: CFuncPtr1[GLbitfield, Unit]): PFNGLCLIENTATTRIBDEFAULTEXTPROC = o
    extension (v: PFNGLCLIENTATTRIBDEFAULTEXTPROC)
      inline def value: CFuncPtr1[GLbitfield, Unit] = v
      inline def toPtr: Ptr[?] = CFuncPtr.toPtr(v)

  opaque type PFNGLCLIENTWAITSEMAPHOREUI64NVXPROC = CFuncPtr3[GLsizei, Ptr[GLuint], Ptr[GLuint64], Unit]
  object PFNGLCLIENTWAITSEMAPHOREUI64NVXPROC:
    given _tag: Tag[PFNGLCLIENTWAITSEMAPHOREUI64NVXPROC] = Tag.materializeCFuncPtr3[GLsizei, Ptr[GLuint], Ptr[GLuint64], Unit]
    inline def fromPtr(ptr: Ptr[Byte] | Ptr[?]): PFNGLCLIENTWAITSEMAPHOREUI64NVXPROC = CFuncPtr.fromPtr(ptr.asInstanceOf[Ptr[Byte]])
    inline def apply(inline o: CFuncPtr3[GLsizei, Ptr[GLuint], Ptr[GLuint64], Unit]): PFNGLCLIENTWAITSEMAPHOREUI64NVXPROC = o
    extension (v: PFNGLCLIENTWAITSEMAPHOREUI64NVXPROC)
      inline def value: CFuncPtr3[GLsizei, Ptr[GLuint], Ptr[GLuint64], Unit] = v
      inline def toPtr: Ptr[?] = CFuncPtr.toPtr(v)

  opaque type PFNGLCLIENTWAITSYNCAPPLEPROC = CFuncPtr3[GLsync, GLbitfield, GLuint64, GLenum]
  object PFNGLCLIENTWAITSYNCAPPLEPROC:
    given _tag: Tag[PFNGLCLIENTWAITSYNCAPPLEPROC] = Tag.materializeCFuncPtr3[GLsync, GLbitfield, GLuint64, GLenum]
    inline def fromPtr(ptr: Ptr[Byte] | Ptr[?]): PFNGLCLIENTWAITSYNCAPPLEPROC = CFuncPtr.fromPtr(ptr.asInstanceOf[Ptr[Byte]])
    inline def apply(inline o: CFuncPtr3[GLsync, GLbitfield, GLuint64, GLenum]): PFNGLCLIENTWAITSYNCAPPLEPROC = o
    extension (v: PFNGLCLIENTWAITSYNCAPPLEPROC)
      inline def value: CFuncPtr3[GLsync, GLbitfield, GLuint64, GLenum] = v
      inline def toPtr: Ptr[?] = CFuncPtr.toPtr(v)

  opaque type PFNGLCLIENTWAITSYNCPROC = CFuncPtr3[GLsync, GLbitfield, GLuint64, GLenum]
  object PFNGLCLIENTWAITSYNCPROC:
    given _tag: Tag[PFNGLCLIENTWAITSYNCPROC] = Tag.materializeCFuncPtr3[GLsync, GLbitfield, GLuint64, GLenum]
    inline def fromPtr(ptr: Ptr[Byte] | Ptr[?]): PFNGLCLIENTWAITSYNCPROC = CFuncPtr.fromPtr(ptr.asInstanceOf[Ptr[Byte]])
    inline def apply(inline o: CFuncPtr3[GLsync, GLbitfield, GLuint64, GLenum]): PFNGLCLIENTWAITSYNCPROC = o
    extension (v: PFNGLCLIENTWAITSYNCPROC)
      inline def value: CFuncPtr3[GLsync, GLbitfield, GLuint64, GLenum] = v
      inline def toPtr: Ptr[?] = CFuncPtr.toPtr(v)

  opaque type PFNGLCLIPCONTROLEXTPROC = CFuncPtr2[GLenum, GLenum, Unit]
  object PFNGLCLIPCONTROLEXTPROC:
    given _tag: Tag[PFNGLCLIPCONTROLEXTPROC] = Tag.materializeCFuncPtr2[GLenum, GLenum, Unit]
    inline def fromPtr(ptr: Ptr[Byte] | Ptr[?]): PFNGLCLIPCONTROLEXTPROC = CFuncPtr.fromPtr(ptr.asInstanceOf[Ptr[Byte]])
    inline def apply(inline o: CFuncPtr2[GLenum, GLenum, Unit]): PFNGLCLIPCONTROLEXTPROC = o
    extension (v: PFNGLCLIPCONTROLEXTPROC)
      inline def value: CFuncPtr2[GLenum, GLenum, Unit] = v
      inline def toPtr: Ptr[?] = CFuncPtr.toPtr(v)

  opaque type PFNGLCLIPCONTROLPROC = CFuncPtr2[GLenum, GLenum, Unit]
  object PFNGLCLIPCONTROLPROC:
    given _tag: Tag[PFNGLCLIPCONTROLPROC] = Tag.materializeCFuncPtr2[GLenum, GLenum, Unit]
    inline def fromPtr(ptr: Ptr[Byte] | Ptr[?]): PFNGLCLIPCONTROLPROC = CFuncPtr.fromPtr(ptr.asInstanceOf[Ptr[Byte]])
    inline def apply(inline o: CFuncPtr2[GLenum, GLenum, Unit]): PFNGLCLIPCONTROLPROC = o
    extension (v: PFNGLCLIPCONTROLPROC)
      inline def value: CFuncPtr2[GLenum, GLenum, Unit] = v
      inline def toPtr: Ptr[?] = CFuncPtr.toPtr(v)

  opaque type PFNGLCLIPPLANEFOESPROC = CFuncPtr2[GLenum, Ptr[GLfloat], Unit]
  object PFNGLCLIPPLANEFOESPROC:
    given _tag: Tag[PFNGLCLIPPLANEFOESPROC] = Tag.materializeCFuncPtr2[GLenum, Ptr[GLfloat], Unit]
    inline def fromPtr(ptr: Ptr[Byte] | Ptr[?]): PFNGLCLIPPLANEFOESPROC = CFuncPtr.fromPtr(ptr.asInstanceOf[Ptr[Byte]])
    inline def apply(inline o: CFuncPtr2[GLenum, Ptr[GLfloat], Unit]): PFNGLCLIPPLANEFOESPROC = o
    extension (v: PFNGLCLIPPLANEFOESPROC)
      inline def value: CFuncPtr2[GLenum, Ptr[GLfloat], Unit] = v
      inline def toPtr: Ptr[?] = CFuncPtr.toPtr(v)

  opaque type PFNGLCLIPPLANEFPROC = CFuncPtr2[GLenum, Ptr[GLfloat], Unit]
  object PFNGLCLIPPLANEFPROC:
    given _tag: Tag[PFNGLCLIPPLANEFPROC] = Tag.materializeCFuncPtr2[GLenum, Ptr[GLfloat], Unit]
    inline def fromPtr(ptr: Ptr[Byte] | Ptr[?]): PFNGLCLIPPLANEFPROC = CFuncPtr.fromPtr(ptr.asInstanceOf[Ptr[Byte]])
    inline def apply(inline o: CFuncPtr2[GLenum, Ptr[GLfloat], Unit]): PFNGLCLIPPLANEFPROC = o
    extension (v: PFNGLCLIPPLANEFPROC)
      inline def value: CFuncPtr2[GLenum, Ptr[GLfloat], Unit] = v
      inline def toPtr: Ptr[?] = CFuncPtr.toPtr(v)

  opaque type PFNGLCLIPPLANEXPROC = CFuncPtr2[GLenum, Ptr[GLfixed], Unit]
  object PFNGLCLIPPLANEXPROC:
    given _tag: Tag[PFNGLCLIPPLANEXPROC] = Tag.materializeCFuncPtr2[GLenum, Ptr[GLfixed], Unit]
    inline def fromPtr(ptr: Ptr[Byte] | Ptr[?]): PFNGLCLIPPLANEXPROC = CFuncPtr.fromPtr(ptr.asInstanceOf[Ptr[Byte]])
    inline def apply(inline o: CFuncPtr2[GLenum, Ptr[GLfixed], Unit]): PFNGLCLIPPLANEXPROC = o
    extension (v: PFNGLCLIPPLANEXPROC)
      inline def value: CFuncPtr2[GLenum, Ptr[GLfixed], Unit] = v
      inline def toPtr: Ptr[?] = CFuncPtr.toPtr(v)

  opaque type PFNGLCOLOR3FVERTEX3FSUNPROC = CFuncPtr6[GLfloat, GLfloat, GLfloat, GLfloat, GLfloat, GLfloat, Unit]
  object PFNGLCOLOR3FVERTEX3FSUNPROC:
    given _tag: Tag[PFNGLCOLOR3FVERTEX3FSUNPROC] = Tag.materializeCFuncPtr6[GLfloat, GLfloat, GLfloat, GLfloat, GLfloat, GLfloat, Unit]
    inline def fromPtr(ptr: Ptr[Byte] | Ptr[?]): PFNGLCOLOR3FVERTEX3FSUNPROC = CFuncPtr.fromPtr(ptr.asInstanceOf[Ptr[Byte]])
    inline def apply(inline o: CFuncPtr6[GLfloat, GLfloat, GLfloat, GLfloat, GLfloat, GLfloat, Unit]): PFNGLCOLOR3FVERTEX3FSUNPROC = o
    extension (v: PFNGLCOLOR3FVERTEX3FSUNPROC)
      inline def value: CFuncPtr6[GLfloat, GLfloat, GLfloat, GLfloat, GLfloat, GLfloat, Unit] = v
      inline def toPtr: Ptr[?] = CFuncPtr.toPtr(v)

  opaque type PFNGLCOLOR3FVERTEX3FVSUNPROC = CFuncPtr2[Ptr[GLfloat], Ptr[GLfloat], Unit]
  object PFNGLCOLOR3FVERTEX3FVSUNPROC:
    given _tag: Tag[PFNGLCOLOR3FVERTEX3FVSUNPROC] = Tag.materializeCFuncPtr2[Ptr[GLfloat], Ptr[GLfloat], Unit]
    inline def fromPtr(ptr: Ptr[Byte] | Ptr[?]): PFNGLCOLOR3FVERTEX3FVSUNPROC = CFuncPtr.fromPtr(ptr.asInstanceOf[Ptr[Byte]])
    inline def apply(inline o: CFuncPtr2[Ptr[GLfloat], Ptr[GLfloat], Unit]): PFNGLCOLOR3FVERTEX3FVSUNPROC = o
    extension (v: PFNGLCOLOR3FVERTEX3FVSUNPROC)
      inline def value: CFuncPtr2[Ptr[GLfloat], Ptr[GLfloat], Unit] = v
      inline def toPtr: Ptr[?] = CFuncPtr.toPtr(v)

  opaque type PFNGLCOLOR3HNVPROC = CFuncPtr3[GLhalf, GLhalf, GLhalf, Unit]
  object PFNGLCOLOR3HNVPROC:
    given _tag: Tag[PFNGLCOLOR3HNVPROC] = Tag.materializeCFuncPtr3[GLhalf, GLhalf, GLhalf, Unit]
    inline def fromPtr(ptr: Ptr[Byte] | Ptr[?]): PFNGLCOLOR3HNVPROC = CFuncPtr.fromPtr(ptr.asInstanceOf[Ptr[Byte]])
    inline def apply(inline o: CFuncPtr3[GLhalf, GLhalf, GLhalf, Unit]): PFNGLCOLOR3HNVPROC = o
    extension (v: PFNGLCOLOR3HNVPROC)
      inline def value: CFuncPtr3[GLhalf, GLhalf, GLhalf, Unit] = v
      inline def toPtr: Ptr[?] = CFuncPtr.toPtr(v)

  opaque type PFNGLCOLOR3HVNVPROC = CFuncPtr1[Ptr[GLhalf], Unit]
  object PFNGLCOLOR3HVNVPROC:
    given _tag: Tag[PFNGLCOLOR3HVNVPROC] = Tag.materializeCFuncPtr1[Ptr[GLhalf], Unit]
    inline def fromPtr(ptr: Ptr[Byte] | Ptr[?]): PFNGLCOLOR3HVNVPROC = CFuncPtr.fromPtr(ptr.asInstanceOf[Ptr[Byte]])
    inline def apply(inline o: CFuncPtr1[Ptr[GLhalf], Unit]): PFNGLCOLOR3HVNVPROC = o
    extension (v: PFNGLCOLOR3HVNVPROC)
      inline def value: CFuncPtr1[Ptr[GLhalf], Unit] = v
      inline def toPtr: Ptr[?] = CFuncPtr.toPtr(v)

  opaque type PFNGLCOLOR4FNORMAL3FVERTEX3FSUNPROC = CFuncPtr10[GLfloat, GLfloat, GLfloat, GLfloat, GLfloat, GLfloat, GLfloat, GLfloat, GLfloat, GLfloat, Unit]
  object PFNGLCOLOR4FNORMAL3FVERTEX3FSUNPROC:
    given _tag: Tag[PFNGLCOLOR4FNORMAL3FVERTEX3FSUNPROC] = Tag.materializeCFuncPtr10[GLfloat, GLfloat, GLfloat, GLfloat, GLfloat, GLfloat, GLfloat, GLfloat, GLfloat, GLfloat, Unit]
    inline def fromPtr(ptr: Ptr[Byte] | Ptr[?]): PFNGLCOLOR4FNORMAL3FVERTEX3FSUNPROC = CFuncPtr.fromPtr(ptr.asInstanceOf[Ptr[Byte]])
    inline def apply(inline o: CFuncPtr10[GLfloat, GLfloat, GLfloat, GLfloat, GLfloat, GLfloat, GLfloat, GLfloat, GLfloat, GLfloat, Unit]): PFNGLCOLOR4FNORMAL3FVERTEX3FSUNPROC = o
    extension (v: PFNGLCOLOR4FNORMAL3FVERTEX3FSUNPROC)
      inline def value: CFuncPtr10[GLfloat, GLfloat, GLfloat, GLfloat, GLfloat, GLfloat, GLfloat, GLfloat, GLfloat, GLfloat, Unit] = v
      inline def toPtr: Ptr[?] = CFuncPtr.toPtr(v)

  opaque type PFNGLCOLOR4FNORMAL3FVERTEX3FVSUNPROC = CFuncPtr3[Ptr[GLfloat], Ptr[GLfloat], Ptr[GLfloat], Unit]
  object PFNGLCOLOR4FNORMAL3FVERTEX3FVSUNPROC:
    given _tag: Tag[PFNGLCOLOR4FNORMAL3FVERTEX3FVSUNPROC] = Tag.materializeCFuncPtr3[Ptr[GLfloat], Ptr[GLfloat], Ptr[GLfloat], Unit]
    inline def fromPtr(ptr: Ptr[Byte] | Ptr[?]): PFNGLCOLOR4FNORMAL3FVERTEX3FVSUNPROC = CFuncPtr.fromPtr(ptr.asInstanceOf[Ptr[Byte]])
    inline def apply(inline o: CFuncPtr3[Ptr[GLfloat], Ptr[GLfloat], Ptr[GLfloat], Unit]): PFNGLCOLOR4FNORMAL3FVERTEX3FVSUNPROC = o
    extension (v: PFNGLCOLOR4FNORMAL3FVERTEX3FVSUNPROC)
      inline def value: CFuncPtr3[Ptr[GLfloat], Ptr[GLfloat], Ptr[GLfloat], Unit] = v
      inline def toPtr: Ptr[?] = CFuncPtr.toPtr(v)

  opaque type PFNGLCOLOR4HNVPROC = CFuncPtr4[GLhalf, GLhalf, GLhalf, GLhalf, Unit]
  object PFNGLCOLOR4HNVPROC:
    given _tag: Tag[PFNGLCOLOR4HNVPROC] = Tag.materializeCFuncPtr4[GLhalf, GLhalf, GLhalf, GLhalf, Unit]
    inline def fromPtr(ptr: Ptr[Byte] | Ptr[?]): PFNGLCOLOR4HNVPROC = CFuncPtr.fromPtr(ptr.asInstanceOf[Ptr[Byte]])
    inline def apply(inline o: CFuncPtr4[GLhalf, GLhalf, GLhalf, GLhalf, Unit]): PFNGLCOLOR4HNVPROC = o
    extension (v: PFNGLCOLOR4HNVPROC)
      inline def value: CFuncPtr4[GLhalf, GLhalf, GLhalf, GLhalf, Unit] = v
      inline def toPtr: Ptr[?] = CFuncPtr.toPtr(v)

  opaque type PFNGLCOLOR4HVNVPROC = CFuncPtr1[Ptr[GLhalf], Unit]
  object PFNGLCOLOR4HVNVPROC:
    given _tag: Tag[PFNGLCOLOR4HVNVPROC] = Tag.materializeCFuncPtr1[Ptr[GLhalf], Unit]
    inline def fromPtr(ptr: Ptr[Byte] | Ptr[?]): PFNGLCOLOR4HVNVPROC = CFuncPtr.fromPtr(ptr.asInstanceOf[Ptr[Byte]])
    inline def apply(inline o: CFuncPtr1[Ptr[GLhalf], Unit]): PFNGLCOLOR4HVNVPROC = o
    extension (v: PFNGLCOLOR4HVNVPROC)
      inline def value: CFuncPtr1[Ptr[GLhalf], Unit] = v
      inline def toPtr: Ptr[?] = CFuncPtr.toPtr(v)

  opaque type PFNGLCOLOR4UBVERTEX2FSUNPROC = CFuncPtr6[GLubyte, GLubyte, GLubyte, GLubyte, GLfloat, GLfloat, Unit]
  object PFNGLCOLOR4UBVERTEX2FSUNPROC:
    given _tag: Tag[PFNGLCOLOR4UBVERTEX2FSUNPROC] = Tag.materializeCFuncPtr6[GLubyte, GLubyte, GLubyte, GLubyte, GLfloat, GLfloat, Unit]
    inline def fromPtr(ptr: Ptr[Byte] | Ptr[?]): PFNGLCOLOR4UBVERTEX2FSUNPROC = CFuncPtr.fromPtr(ptr.asInstanceOf[Ptr[Byte]])
    inline def apply(inline o: CFuncPtr6[GLubyte, GLubyte, GLubyte, GLubyte, GLfloat, GLfloat, Unit]): PFNGLCOLOR4UBVERTEX2FSUNPROC = o
    extension (v: PFNGLCOLOR4UBVERTEX2FSUNPROC)
      inline def value: CFuncPtr6[GLubyte, GLubyte, GLubyte, GLubyte, GLfloat, GLfloat, Unit] = v
      inline def toPtr: Ptr[?] = CFuncPtr.toPtr(v)

  opaque type PFNGLCOLOR4UBVERTEX2FVSUNPROC = CFuncPtr2[Ptr[GLubyte], Ptr[GLfloat], Unit]
  object PFNGLCOLOR4UBVERTEX2FVSUNPROC:
    given _tag: Tag[PFNGLCOLOR4UBVERTEX2FVSUNPROC] = Tag.materializeCFuncPtr2[Ptr[GLubyte], Ptr[GLfloat], Unit]
    inline def fromPtr(ptr: Ptr[Byte] | Ptr[?]): PFNGLCOLOR4UBVERTEX2FVSUNPROC = CFuncPtr.fromPtr(ptr.asInstanceOf[Ptr[Byte]])
    inline def apply(inline o: CFuncPtr2[Ptr[GLubyte], Ptr[GLfloat], Unit]): PFNGLCOLOR4UBVERTEX2FVSUNPROC = o
    extension (v: PFNGLCOLOR4UBVERTEX2FVSUNPROC)
      inline def value: CFuncPtr2[Ptr[GLubyte], Ptr[GLfloat], Unit] = v
      inline def toPtr: Ptr[?] = CFuncPtr.toPtr(v)

  opaque type PFNGLCOLOR4UBVERTEX3FSUNPROC = CFuncPtr7[GLubyte, GLubyte, GLubyte, GLubyte, GLfloat, GLfloat, GLfloat, Unit]
  object PFNGLCOLOR4UBVERTEX3FSUNPROC:
    given _tag: Tag[PFNGLCOLOR4UBVERTEX3FSUNPROC] = Tag.materializeCFuncPtr7[GLubyte, GLubyte, GLubyte, GLubyte, GLfloat, GLfloat, GLfloat, Unit]
    inline def fromPtr(ptr: Ptr[Byte] | Ptr[?]): PFNGLCOLOR4UBVERTEX3FSUNPROC = CFuncPtr.fromPtr(ptr.asInstanceOf[Ptr[Byte]])
    inline def apply(inline o: CFuncPtr7[GLubyte, GLubyte, GLubyte, GLubyte, GLfloat, GLfloat, GLfloat, Unit]): PFNGLCOLOR4UBVERTEX3FSUNPROC = o
    extension (v: PFNGLCOLOR4UBVERTEX3FSUNPROC)
      inline def value: CFuncPtr7[GLubyte, GLubyte, GLubyte, GLubyte, GLfloat, GLfloat, GLfloat, Unit] = v
      inline def toPtr: Ptr[?] = CFuncPtr.toPtr(v)

  opaque type PFNGLCOLOR4UBVERTEX3FVSUNPROC = CFuncPtr2[Ptr[GLubyte], Ptr[GLfloat], Unit]
  object PFNGLCOLOR4UBVERTEX3FVSUNPROC:
    given _tag: Tag[PFNGLCOLOR4UBVERTEX3FVSUNPROC] = Tag.materializeCFuncPtr2[Ptr[GLubyte], Ptr[GLfloat], Unit]
    inline def fromPtr(ptr: Ptr[Byte] | Ptr[?]): PFNGLCOLOR4UBVERTEX3FVSUNPROC = CFuncPtr.fromPtr(ptr.asInstanceOf[Ptr[Byte]])
    inline def apply(inline o: CFuncPtr2[Ptr[GLubyte], Ptr[GLfloat], Unit]): PFNGLCOLOR4UBVERTEX3FVSUNPROC = o
    extension (v: PFNGLCOLOR4UBVERTEX3FVSUNPROC)
      inline def value: CFuncPtr2[Ptr[GLubyte], Ptr[GLfloat], Unit] = v
      inline def toPtr: Ptr[?] = CFuncPtr.toPtr(v)

  opaque type PFNGLCOLOR4XPROC = CFuncPtr4[GLfixed, GLfixed, GLfixed, GLfixed, Unit]
  object PFNGLCOLOR4XPROC:
    given _tag: Tag[PFNGLCOLOR4XPROC] = Tag.materializeCFuncPtr4[GLfixed, GLfixed, GLfixed, GLfixed, Unit]
    inline def fromPtr(ptr: Ptr[Byte] | Ptr[?]): PFNGLCOLOR4XPROC = CFuncPtr.fromPtr(ptr.asInstanceOf[Ptr[Byte]])
    inline def apply(inline o: CFuncPtr4[GLfixed, GLfixed, GLfixed, GLfixed, Unit]): PFNGLCOLOR4XPROC = o
    extension (v: PFNGLCOLOR4XPROC)
      inline def value: CFuncPtr4[GLfixed, GLfixed, GLfixed, GLfixed, Unit] = v
      inline def toPtr: Ptr[?] = CFuncPtr.toPtr(v)

  opaque type PFNGLCOLORFORMATNVPROC = CFuncPtr3[GLint, GLenum, GLsizei, Unit]
  object PFNGLCOLORFORMATNVPROC:
    given _tag: Tag[PFNGLCOLORFORMATNVPROC] = Tag.materializeCFuncPtr3[GLint, GLenum, GLsizei, Unit]
    inline def fromPtr(ptr: Ptr[Byte] | Ptr[?]): PFNGLCOLORFORMATNVPROC = CFuncPtr.fromPtr(ptr.asInstanceOf[Ptr[Byte]])
    inline def apply(inline o: CFuncPtr3[GLint, GLenum, GLsizei, Unit]): PFNGLCOLORFORMATNVPROC = o
    extension (v: PFNGLCOLORFORMATNVPROC)
      inline def value: CFuncPtr3[GLint, GLenum, GLsizei, Unit] = v
      inline def toPtr: Ptr[?] = CFuncPtr.toPtr(v)

  opaque type PFNGLCOLORFRAGMENTOP1ATIPROC = CFuncPtr7[GLenum, GLuint, GLuint, GLuint, GLuint, GLuint, GLuint, Unit]
  object PFNGLCOLORFRAGMENTOP1ATIPROC:
    given _tag: Tag[PFNGLCOLORFRAGMENTOP1ATIPROC] = Tag.materializeCFuncPtr7[GLenum, GLuint, GLuint, GLuint, GLuint, GLuint, GLuint, Unit]
    inline def fromPtr(ptr: Ptr[Byte] | Ptr[?]): PFNGLCOLORFRAGMENTOP1ATIPROC = CFuncPtr.fromPtr(ptr.asInstanceOf[Ptr[Byte]])
    inline def apply(inline o: CFuncPtr7[GLenum, GLuint, GLuint, GLuint, GLuint, GLuint, GLuint, Unit]): PFNGLCOLORFRAGMENTOP1ATIPROC = o
    extension (v: PFNGLCOLORFRAGMENTOP1ATIPROC)
      inline def value: CFuncPtr7[GLenum, GLuint, GLuint, GLuint, GLuint, GLuint, GLuint, Unit] = v
      inline def toPtr: Ptr[?] = CFuncPtr.toPtr(v)

  opaque type PFNGLCOLORFRAGMENTOP2ATIPROC = CFuncPtr10[GLenum, GLuint, GLuint, GLuint, GLuint, GLuint, GLuint, GLuint, GLuint, GLuint, Unit]
  object PFNGLCOLORFRAGMENTOP2ATIPROC:
    given _tag: Tag[PFNGLCOLORFRAGMENTOP2ATIPROC] = Tag.materializeCFuncPtr10[GLenum, GLuint, GLuint, GLuint, GLuint, GLuint, GLuint, GLuint, GLuint, GLuint, Unit]
    inline def fromPtr(ptr: Ptr[Byte] | Ptr[?]): PFNGLCOLORFRAGMENTOP2ATIPROC = CFuncPtr.fromPtr(ptr.asInstanceOf[Ptr[Byte]])
    inline def apply(inline o: CFuncPtr10[GLenum, GLuint, GLuint, GLuint, GLuint, GLuint, GLuint, GLuint, GLuint, GLuint, Unit]): PFNGLCOLORFRAGMENTOP2ATIPROC = o
    extension (v: PFNGLCOLORFRAGMENTOP2ATIPROC)
      inline def value: CFuncPtr10[GLenum, GLuint, GLuint, GLuint, GLuint, GLuint, GLuint, GLuint, GLuint, GLuint, Unit] = v
      inline def toPtr: Ptr[?] = CFuncPtr.toPtr(v)

  opaque type PFNGLCOLORFRAGMENTOP3ATIPROC = CFuncPtr13[GLenum, GLuint, GLuint, GLuint, GLuint, GLuint, GLuint, GLuint, GLuint, GLuint, GLuint, GLuint, GLuint, Unit]
  object PFNGLCOLORFRAGMENTOP3ATIPROC:
    given _tag: Tag[PFNGLCOLORFRAGMENTOP3ATIPROC] = Tag.materializeCFuncPtr13[GLenum, GLuint, GLuint, GLuint, GLuint, GLuint, GLuint, GLuint, GLuint, GLuint, GLuint, GLuint, GLuint, Unit]
    inline def fromPtr(ptr: Ptr[Byte] | Ptr[?]): PFNGLCOLORFRAGMENTOP3ATIPROC = CFuncPtr.fromPtr(ptr.asInstanceOf[Ptr[Byte]])
    inline def apply(inline o: CFuncPtr13[GLenum, GLuint, GLuint, GLuint, GLuint, GLuint, GLuint, GLuint, GLuint, GLuint, GLuint, GLuint, GLuint, Unit]): PFNGLCOLORFRAGMENTOP3ATIPROC = o
    extension (v: PFNGLCOLORFRAGMENTOP3ATIPROC)
      inline def value: CFuncPtr13[GLenum, GLuint, GLuint, GLuint, GLuint, GLuint, GLuint, GLuint, GLuint, GLuint, GLuint, GLuint, GLuint, Unit] = v
      inline def toPtr: Ptr[?] = CFuncPtr.toPtr(v)

  opaque type PFNGLCOLORMASKIEXTPROC = CFuncPtr5[GLuint, GLboolean, GLboolean, GLboolean, GLboolean, Unit]
  object PFNGLCOLORMASKIEXTPROC:
    given _tag: Tag[PFNGLCOLORMASKIEXTPROC] = Tag.materializeCFuncPtr5[GLuint, GLboolean, GLboolean, GLboolean, GLboolean, Unit]
    inline def fromPtr(ptr: Ptr[Byte] | Ptr[?]): PFNGLCOLORMASKIEXTPROC = CFuncPtr.fromPtr(ptr.asInstanceOf[Ptr[Byte]])
    inline def apply(inline o: CFuncPtr5[GLuint, GLboolean, GLboolean, GLboolean, GLboolean, Unit]): PFNGLCOLORMASKIEXTPROC = o
    extension (v: PFNGLCOLORMASKIEXTPROC)
      inline def value: CFuncPtr5[GLuint, GLboolean, GLboolean, GLboolean, GLboolean, Unit] = v
      inline def toPtr: Ptr[?] = CFuncPtr.toPtr(v)

  opaque type PFNGLCOLORMASKINDEXEDEXTPROC = CFuncPtr5[GLuint, GLboolean, GLboolean, GLboolean, GLboolean, Unit]
  object PFNGLCOLORMASKINDEXEDEXTPROC:
    given _tag: Tag[PFNGLCOLORMASKINDEXEDEXTPROC] = Tag.materializeCFuncPtr5[GLuint, GLboolean, GLboolean, GLboolean, GLboolean, Unit]
    inline def fromPtr(ptr: Ptr[Byte] | Ptr[?]): PFNGLCOLORMASKINDEXEDEXTPROC = CFuncPtr.fromPtr(ptr.asInstanceOf[Ptr[Byte]])
    inline def apply(inline o: CFuncPtr5[GLuint, GLboolean, GLboolean, GLboolean, GLboolean, Unit]): PFNGLCOLORMASKINDEXEDEXTPROC = o
    extension (v: PFNGLCOLORMASKINDEXEDEXTPROC)
      inline def value: CFuncPtr5[GLuint, GLboolean, GLboolean, GLboolean, GLboolean, Unit] = v
      inline def toPtr: Ptr[?] = CFuncPtr.toPtr(v)

  opaque type PFNGLCOLORMASKIOESPROC = CFuncPtr5[GLuint, GLboolean, GLboolean, GLboolean, GLboolean, Unit]
  object PFNGLCOLORMASKIOESPROC:
    given _tag: Tag[PFNGLCOLORMASKIOESPROC] = Tag.materializeCFuncPtr5[GLuint, GLboolean, GLboolean, GLboolean, GLboolean, Unit]
    inline def fromPtr(ptr: Ptr[Byte] | Ptr[?]): PFNGLCOLORMASKIOESPROC = CFuncPtr.fromPtr(ptr.asInstanceOf[Ptr[Byte]])
    inline def apply(inline o: CFuncPtr5[GLuint, GLboolean, GLboolean, GLboolean, GLboolean, Unit]): PFNGLCOLORMASKIOESPROC = o
    extension (v: PFNGLCOLORMASKIOESPROC)
      inline def value: CFuncPtr5[GLuint, GLboolean, GLboolean, GLboolean, GLboolean, Unit] = v
      inline def toPtr: Ptr[?] = CFuncPtr.toPtr(v)

  opaque type PFNGLCOLORMASKIPROC = CFuncPtr5[GLuint, GLboolean, GLboolean, GLboolean, GLboolean, Unit]
  object PFNGLCOLORMASKIPROC:
    given _tag: Tag[PFNGLCOLORMASKIPROC] = Tag.materializeCFuncPtr5[GLuint, GLboolean, GLboolean, GLboolean, GLboolean, Unit]
    inline def fromPtr(ptr: Ptr[Byte] | Ptr[?]): PFNGLCOLORMASKIPROC = CFuncPtr.fromPtr(ptr.asInstanceOf[Ptr[Byte]])
    inline def apply(inline o: CFuncPtr5[GLuint, GLboolean, GLboolean, GLboolean, GLboolean, Unit]): PFNGLCOLORMASKIPROC = o
    extension (v: PFNGLCOLORMASKIPROC)
      inline def value: CFuncPtr5[GLuint, GLboolean, GLboolean, GLboolean, GLboolean, Unit] = v
      inline def toPtr: Ptr[?] = CFuncPtr.toPtr(v)

  opaque type PFNGLCOLORP3UIPROC = CFuncPtr2[GLenum, GLuint, Unit]
  object PFNGLCOLORP3UIPROC:
    given _tag: Tag[PFNGLCOLORP3UIPROC] = Tag.materializeCFuncPtr2[GLenum, GLuint, Unit]
    inline def fromPtr(ptr: Ptr[Byte] | Ptr[?]): PFNGLCOLORP3UIPROC = CFuncPtr.fromPtr(ptr.asInstanceOf[Ptr[Byte]])
    inline def apply(inline o: CFuncPtr2[GLenum, GLuint, Unit]): PFNGLCOLORP3UIPROC = o
    extension (v: PFNGLCOLORP3UIPROC)
      inline def value: CFuncPtr2[GLenum, GLuint, Unit] = v
      inline def toPtr: Ptr[?] = CFuncPtr.toPtr(v)

  opaque type PFNGLCOLORP3UIVPROC = CFuncPtr2[GLenum, Ptr[GLuint], Unit]
  object PFNGLCOLORP3UIVPROC:
    given _tag: Tag[PFNGLCOLORP3UIVPROC] = Tag.materializeCFuncPtr2[GLenum, Ptr[GLuint], Unit]
    inline def fromPtr(ptr: Ptr[Byte] | Ptr[?]): PFNGLCOLORP3UIVPROC = CFuncPtr.fromPtr(ptr.asInstanceOf[Ptr[Byte]])
    inline def apply(inline o: CFuncPtr2[GLenum, Ptr[GLuint], Unit]): PFNGLCOLORP3UIVPROC = o
    extension (v: PFNGLCOLORP3UIVPROC)
      inline def value: CFuncPtr2[GLenum, Ptr[GLuint], Unit] = v
      inline def toPtr: Ptr[?] = CFuncPtr.toPtr(v)

  opaque type PFNGLCOLORP4UIPROC = CFuncPtr2[GLenum, GLuint, Unit]
  object PFNGLCOLORP4UIPROC:
    given _tag: Tag[PFNGLCOLORP4UIPROC] = Tag.materializeCFuncPtr2[GLenum, GLuint, Unit]
    inline def fromPtr(ptr: Ptr[Byte] | Ptr[?]): PFNGLCOLORP4UIPROC = CFuncPtr.fromPtr(ptr.asInstanceOf[Ptr[Byte]])
    inline def apply(inline o: CFuncPtr2[GLenum, GLuint, Unit]): PFNGLCOLORP4UIPROC = o
    extension (v: PFNGLCOLORP4UIPROC)
      inline def value: CFuncPtr2[GLenum, GLuint, Unit] = v
      inline def toPtr: Ptr[?] = CFuncPtr.toPtr(v)

  opaque type PFNGLCOLORP4UIVPROC = CFuncPtr2[GLenum, Ptr[GLuint], Unit]
  object PFNGLCOLORP4UIVPROC:
    given _tag: Tag[PFNGLCOLORP4UIVPROC] = Tag.materializeCFuncPtr2[GLenum, Ptr[GLuint], Unit]
    inline def fromPtr(ptr: Ptr[Byte] | Ptr[?]): PFNGLCOLORP4UIVPROC = CFuncPtr.fromPtr(ptr.asInstanceOf[Ptr[Byte]])
    inline def apply(inline o: CFuncPtr2[GLenum, Ptr[GLuint], Unit]): PFNGLCOLORP4UIVPROC = o
    extension (v: PFNGLCOLORP4UIVPROC)
      inline def value: CFuncPtr2[GLenum, Ptr[GLuint], Unit] = v
      inline def toPtr: Ptr[?] = CFuncPtr.toPtr(v)

  opaque type PFNGLCOLORPOINTEREXTPROC = CFuncPtr5[GLint, GLenum, GLsizei, GLsizei, Ptr[Byte], Unit]
  object PFNGLCOLORPOINTEREXTPROC:
    given _tag: Tag[PFNGLCOLORPOINTEREXTPROC] = Tag.materializeCFuncPtr5[GLint, GLenum, GLsizei, GLsizei, Ptr[Byte], Unit]
    inline def fromPtr(ptr: Ptr[Byte] | Ptr[?]): PFNGLCOLORPOINTEREXTPROC = CFuncPtr.fromPtr(ptr.asInstanceOf[Ptr[Byte]])
    inline def apply(inline o: CFuncPtr5[GLint, GLenum, GLsizei, GLsizei, Ptr[Byte], Unit]): PFNGLCOLORPOINTEREXTPROC = o
    extension (v: PFNGLCOLORPOINTEREXTPROC)
      inline def value: CFuncPtr5[GLint, GLenum, GLsizei, GLsizei, Ptr[Byte], Unit] = v
      inline def toPtr: Ptr[?] = CFuncPtr.toPtr(v)

  opaque type PFNGLCOLORPOINTERLISTIBMPROC = CFuncPtr5[GLint, GLenum, GLint, Ptr[Ptr[Byte]], GLint, Unit]
  object PFNGLCOLORPOINTERLISTIBMPROC:
    given _tag: Tag[PFNGLCOLORPOINTERLISTIBMPROC] = Tag.materializeCFuncPtr5[GLint, GLenum, GLint, Ptr[Ptr[Byte]], GLint, Unit]
    inline def fromPtr(ptr: Ptr[Byte] | Ptr[?]): PFNGLCOLORPOINTERLISTIBMPROC = CFuncPtr.fromPtr(ptr.asInstanceOf[Ptr[Byte]])
    inline def apply(inline o: CFuncPtr5[GLint, GLenum, GLint, Ptr[Ptr[Byte]], GLint, Unit]): PFNGLCOLORPOINTERLISTIBMPROC = o
    extension (v: PFNGLCOLORPOINTERLISTIBMPROC)
      inline def value: CFuncPtr5[GLint, GLenum, GLint, Ptr[Ptr[Byte]], GLint, Unit] = v
      inline def toPtr: Ptr[?] = CFuncPtr.toPtr(v)

  opaque type PFNGLCOLORPOINTERVINTELPROC = CFuncPtr3[GLint, GLenum, Ptr[Ptr[Byte]], Unit]
  object PFNGLCOLORPOINTERVINTELPROC:
    given _tag: Tag[PFNGLCOLORPOINTERVINTELPROC] = Tag.materializeCFuncPtr3[GLint, GLenum, Ptr[Ptr[Byte]], Unit]
    inline def fromPtr(ptr: Ptr[Byte] | Ptr[?]): PFNGLCOLORPOINTERVINTELPROC = CFuncPtr.fromPtr(ptr.asInstanceOf[Ptr[Byte]])
    inline def apply(inline o: CFuncPtr3[GLint, GLenum, Ptr[Ptr[Byte]], Unit]): PFNGLCOLORPOINTERVINTELPROC = o
    extension (v: PFNGLCOLORPOINTERVINTELPROC)
      inline def value: CFuncPtr3[GLint, GLenum, Ptr[Ptr[Byte]], Unit] = v
      inline def toPtr: Ptr[?] = CFuncPtr.toPtr(v)

  opaque type PFNGLCOLORSUBTABLEEXTPROC = CFuncPtr6[GLenum, GLsizei, GLsizei, GLenum, GLenum, Ptr[Byte], Unit]
  object PFNGLCOLORSUBTABLEEXTPROC:
    given _tag: Tag[PFNGLCOLORSUBTABLEEXTPROC] = Tag.materializeCFuncPtr6[GLenum, GLsizei, GLsizei, GLenum, GLenum, Ptr[Byte], Unit]
    inline def fromPtr(ptr: Ptr[Byte] | Ptr[?]): PFNGLCOLORSUBTABLEEXTPROC = CFuncPtr.fromPtr(ptr.asInstanceOf[Ptr[Byte]])
    inline def apply(inline o: CFuncPtr6[GLenum, GLsizei, GLsizei, GLenum, GLenum, Ptr[Byte], Unit]): PFNGLCOLORSUBTABLEEXTPROC = o
    extension (v: PFNGLCOLORSUBTABLEEXTPROC)
      inline def value: CFuncPtr6[GLenum, GLsizei, GLsizei, GLenum, GLenum, Ptr[Byte], Unit] = v
      inline def toPtr: Ptr[?] = CFuncPtr.toPtr(v)

  opaque type PFNGLCOLORSUBTABLEPROC = CFuncPtr6[GLenum, GLsizei, GLsizei, GLenum, GLenum, Ptr[Byte], Unit]
  object PFNGLCOLORSUBTABLEPROC:
    given _tag: Tag[PFNGLCOLORSUBTABLEPROC] = Tag.materializeCFuncPtr6[GLenum, GLsizei, GLsizei, GLenum, GLenum, Ptr[Byte], Unit]
    inline def fromPtr(ptr: Ptr[Byte] | Ptr[?]): PFNGLCOLORSUBTABLEPROC = CFuncPtr.fromPtr(ptr.asInstanceOf[Ptr[Byte]])
    inline def apply(inline o: CFuncPtr6[GLenum, GLsizei, GLsizei, GLenum, GLenum, Ptr[Byte], Unit]): PFNGLCOLORSUBTABLEPROC = o
    extension (v: PFNGLCOLORSUBTABLEPROC)
      inline def value: CFuncPtr6[GLenum, GLsizei, GLsizei, GLenum, GLenum, Ptr[Byte], Unit] = v
      inline def toPtr: Ptr[?] = CFuncPtr.toPtr(v)

  opaque type PFNGLCOLORTABLEEXTPROC = CFuncPtr6[GLenum, GLenum, GLsizei, GLenum, GLenum, Ptr[Byte], Unit]
  object PFNGLCOLORTABLEEXTPROC:
    given _tag: Tag[PFNGLCOLORTABLEEXTPROC] = Tag.materializeCFuncPtr6[GLenum, GLenum, GLsizei, GLenum, GLenum, Ptr[Byte], Unit]
    inline def fromPtr(ptr: Ptr[Byte] | Ptr[?]): PFNGLCOLORTABLEEXTPROC = CFuncPtr.fromPtr(ptr.asInstanceOf[Ptr[Byte]])
    inline def apply(inline o: CFuncPtr6[GLenum, GLenum, GLsizei, GLenum, GLenum, Ptr[Byte], Unit]): PFNGLCOLORTABLEEXTPROC = o
    extension (v: PFNGLCOLORTABLEEXTPROC)
      inline def value: CFuncPtr6[GLenum, GLenum, GLsizei, GLenum, GLenum, Ptr[Byte], Unit] = v
      inline def toPtr: Ptr[?] = CFuncPtr.toPtr(v)

  opaque type PFNGLCOLORTABLEPARAMETERFVPROC = CFuncPtr3[GLenum, GLenum, Ptr[GLfloat], Unit]
  object PFNGLCOLORTABLEPARAMETERFVPROC:
    given _tag: Tag[PFNGLCOLORTABLEPARAMETERFVPROC] = Tag.materializeCFuncPtr3[GLenum, GLenum, Ptr[GLfloat], Unit]
    inline def fromPtr(ptr: Ptr[Byte] | Ptr[?]): PFNGLCOLORTABLEPARAMETERFVPROC = CFuncPtr.fromPtr(ptr.asInstanceOf[Ptr[Byte]])
    inline def apply(inline o: CFuncPtr3[GLenum, GLenum, Ptr[GLfloat], Unit]): PFNGLCOLORTABLEPARAMETERFVPROC = o
    extension (v: PFNGLCOLORTABLEPARAMETERFVPROC)
      inline def value: CFuncPtr3[GLenum, GLenum, Ptr[GLfloat], Unit] = v
      inline def toPtr: Ptr[?] = CFuncPtr.toPtr(v)

  opaque type PFNGLCOLORTABLEPARAMETERFVSGIPROC = CFuncPtr3[GLenum, GLenum, Ptr[GLfloat], Unit]
  object PFNGLCOLORTABLEPARAMETERFVSGIPROC:
    given _tag: Tag[PFNGLCOLORTABLEPARAMETERFVSGIPROC] = Tag.materializeCFuncPtr3[GLenum, GLenum, Ptr[GLfloat], Unit]
    inline def fromPtr(ptr: Ptr[Byte] | Ptr[?]): PFNGLCOLORTABLEPARAMETERFVSGIPROC = CFuncPtr.fromPtr(ptr.asInstanceOf[Ptr[Byte]])
    inline def apply(inline o: CFuncPtr3[GLenum, GLenum, Ptr[GLfloat], Unit]): PFNGLCOLORTABLEPARAMETERFVSGIPROC = o
    extension (v: PFNGLCOLORTABLEPARAMETERFVSGIPROC)
      inline def value: CFuncPtr3[GLenum, GLenum, Ptr[GLfloat], Unit] = v
      inline def toPtr: Ptr[?] = CFuncPtr.toPtr(v)

  opaque type PFNGLCOLORTABLEPARAMETERIVPROC = CFuncPtr3[GLenum, GLenum, Ptr[GLint], Unit]
  object PFNGLCOLORTABLEPARAMETERIVPROC:
    given _tag: Tag[PFNGLCOLORTABLEPARAMETERIVPROC] = Tag.materializeCFuncPtr3[GLenum, GLenum, Ptr[GLint], Unit]
    inline def fromPtr(ptr: Ptr[Byte] | Ptr[?]): PFNGLCOLORTABLEPARAMETERIVPROC = CFuncPtr.fromPtr(ptr.asInstanceOf[Ptr[Byte]])
    inline def apply(inline o: CFuncPtr3[GLenum, GLenum, Ptr[GLint], Unit]): PFNGLCOLORTABLEPARAMETERIVPROC = o
    extension (v: PFNGLCOLORTABLEPARAMETERIVPROC)
      inline def value: CFuncPtr3[GLenum, GLenum, Ptr[GLint], Unit] = v
      inline def toPtr: Ptr[?] = CFuncPtr.toPtr(v)

  opaque type PFNGLCOLORTABLEPARAMETERIVSGIPROC = CFuncPtr3[GLenum, GLenum, Ptr[GLint], Unit]
  object PFNGLCOLORTABLEPARAMETERIVSGIPROC:
    given _tag: Tag[PFNGLCOLORTABLEPARAMETERIVSGIPROC] = Tag.materializeCFuncPtr3[GLenum, GLenum, Ptr[GLint], Unit]
    inline def fromPtr(ptr: Ptr[Byte] | Ptr[?]): PFNGLCOLORTABLEPARAMETERIVSGIPROC = CFuncPtr.fromPtr(ptr.asInstanceOf[Ptr[Byte]])
    inline def apply(inline o: CFuncPtr3[GLenum, GLenum, Ptr[GLint], Unit]): PFNGLCOLORTABLEPARAMETERIVSGIPROC = o
    extension (v: PFNGLCOLORTABLEPARAMETERIVSGIPROC)
      inline def value: CFuncPtr3[GLenum, GLenum, Ptr[GLint], Unit] = v
      inline def toPtr: Ptr[?] = CFuncPtr.toPtr(v)

  opaque type PFNGLCOLORTABLEPROC = CFuncPtr6[GLenum, GLenum, GLsizei, GLenum, GLenum, Ptr[Byte], Unit]
  object PFNGLCOLORTABLEPROC:
    given _tag: Tag[PFNGLCOLORTABLEPROC] = Tag.materializeCFuncPtr6[GLenum, GLenum, GLsizei, GLenum, GLenum, Ptr[Byte], Unit]
    inline def fromPtr(ptr: Ptr[Byte] | Ptr[?]): PFNGLCOLORTABLEPROC = CFuncPtr.fromPtr(ptr.asInstanceOf[Ptr[Byte]])
    inline def apply(inline o: CFuncPtr6[GLenum, GLenum, GLsizei, GLenum, GLenum, Ptr[Byte], Unit]): PFNGLCOLORTABLEPROC = o
    extension (v: PFNGLCOLORTABLEPROC)
      inline def value: CFuncPtr6[GLenum, GLenum, GLsizei, GLenum, GLenum, Ptr[Byte], Unit] = v
      inline def toPtr: Ptr[?] = CFuncPtr.toPtr(v)

  opaque type PFNGLCOLORTABLESGIPROC = CFuncPtr6[GLenum, GLenum, GLsizei, GLenum, GLenum, Ptr[Byte], Unit]
  object PFNGLCOLORTABLESGIPROC:
    given _tag: Tag[PFNGLCOLORTABLESGIPROC] = Tag.materializeCFuncPtr6[GLenum, GLenum, GLsizei, GLenum, GLenum, Ptr[Byte], Unit]
    inline def fromPtr(ptr: Ptr[Byte] | Ptr[?]): PFNGLCOLORTABLESGIPROC = CFuncPtr.fromPtr(ptr.asInstanceOf[Ptr[Byte]])
    inline def apply(inline o: CFuncPtr6[GLenum, GLenum, GLsizei, GLenum, GLenum, Ptr[Byte], Unit]): PFNGLCOLORTABLESGIPROC = o
    extension (v: PFNGLCOLORTABLESGIPROC)
      inline def value: CFuncPtr6[GLenum, GLenum, GLsizei, GLenum, GLenum, Ptr[Byte], Unit] = v
      inline def toPtr: Ptr[?] = CFuncPtr.toPtr(v)

  opaque type PFNGLCOMBINERINPUTNVPROC = CFuncPtr6[GLenum, GLenum, GLenum, GLenum, GLenum, GLenum, Unit]
  object PFNGLCOMBINERINPUTNVPROC:
    given _tag: Tag[PFNGLCOMBINERINPUTNVPROC] = Tag.materializeCFuncPtr6[GLenum, GLenum, GLenum, GLenum, GLenum, GLenum, Unit]
    inline def fromPtr(ptr: Ptr[Byte] | Ptr[?]): PFNGLCOMBINERINPUTNVPROC = CFuncPtr.fromPtr(ptr.asInstanceOf[Ptr[Byte]])
    inline def apply(inline o: CFuncPtr6[GLenum, GLenum, GLenum, GLenum, GLenum, GLenum, Unit]): PFNGLCOMBINERINPUTNVPROC = o
    extension (v: PFNGLCOMBINERINPUTNVPROC)
      inline def value: CFuncPtr6[GLenum, GLenum, GLenum, GLenum, GLenum, GLenum, Unit] = v
      inline def toPtr: Ptr[?] = CFuncPtr.toPtr(v)

  opaque type PFNGLCOMBINEROUTPUTNVPROC = CFuncPtr10[GLenum, GLenum, GLenum, GLenum, GLenum, GLenum, GLenum, GLboolean, GLboolean, GLboolean, Unit]
  object PFNGLCOMBINEROUTPUTNVPROC:
    given _tag: Tag[PFNGLCOMBINEROUTPUTNVPROC] = Tag.materializeCFuncPtr10[GLenum, GLenum, GLenum, GLenum, GLenum, GLenum, GLenum, GLboolean, GLboolean, GLboolean, Unit]
    inline def fromPtr(ptr: Ptr[Byte] | Ptr[?]): PFNGLCOMBINEROUTPUTNVPROC = CFuncPtr.fromPtr(ptr.asInstanceOf[Ptr[Byte]])
    inline def apply(inline o: CFuncPtr10[GLenum, GLenum, GLenum, GLenum, GLenum, GLenum, GLenum, GLboolean, GLboolean, GLboolean, Unit]): PFNGLCOMBINEROUTPUTNVPROC = o
    extension (v: PFNGLCOMBINEROUTPUTNVPROC)
      inline def value: CFuncPtr10[GLenum, GLenum, GLenum, GLenum, GLenum, GLenum, GLenum, GLboolean, GLboolean, GLboolean, Unit] = v
      inline def toPtr: Ptr[?] = CFuncPtr.toPtr(v)

  opaque type PFNGLCOMBINERPARAMETERFNVPROC = CFuncPtr2[GLenum, GLfloat, Unit]
  object PFNGLCOMBINERPARAMETERFNVPROC:
    given _tag: Tag[PFNGLCOMBINERPARAMETERFNVPROC] = Tag.materializeCFuncPtr2[GLenum, GLfloat, Unit]
    inline def fromPtr(ptr: Ptr[Byte] | Ptr[?]): PFNGLCOMBINERPARAMETERFNVPROC = CFuncPtr.fromPtr(ptr.asInstanceOf[Ptr[Byte]])
    inline def apply(inline o: CFuncPtr2[GLenum, GLfloat, Unit]): PFNGLCOMBINERPARAMETERFNVPROC = o
    extension (v: PFNGLCOMBINERPARAMETERFNVPROC)
      inline def value: CFuncPtr2[GLenum, GLfloat, Unit] = v
      inline def toPtr: Ptr[?] = CFuncPtr.toPtr(v)

  opaque type PFNGLCOMBINERPARAMETERFVNVPROC = CFuncPtr2[GLenum, Ptr[GLfloat], Unit]
  object PFNGLCOMBINERPARAMETERFVNVPROC:
    given _tag: Tag[PFNGLCOMBINERPARAMETERFVNVPROC] = Tag.materializeCFuncPtr2[GLenum, Ptr[GLfloat], Unit]
    inline def fromPtr(ptr: Ptr[Byte] | Ptr[?]): PFNGLCOMBINERPARAMETERFVNVPROC = CFuncPtr.fromPtr(ptr.asInstanceOf[Ptr[Byte]])
    inline def apply(inline o: CFuncPtr2[GLenum, Ptr[GLfloat], Unit]): PFNGLCOMBINERPARAMETERFVNVPROC = o
    extension (v: PFNGLCOMBINERPARAMETERFVNVPROC)
      inline def value: CFuncPtr2[GLenum, Ptr[GLfloat], Unit] = v
      inline def toPtr: Ptr[?] = CFuncPtr.toPtr(v)

  opaque type PFNGLCOMBINERPARAMETERINVPROC = CFuncPtr2[GLenum, GLint, Unit]
  object PFNGLCOMBINERPARAMETERINVPROC:
    given _tag: Tag[PFNGLCOMBINERPARAMETERINVPROC] = Tag.materializeCFuncPtr2[GLenum, GLint, Unit]
    inline def fromPtr(ptr: Ptr[Byte] | Ptr[?]): PFNGLCOMBINERPARAMETERINVPROC = CFuncPtr.fromPtr(ptr.asInstanceOf[Ptr[Byte]])
    inline def apply(inline o: CFuncPtr2[GLenum, GLint, Unit]): PFNGLCOMBINERPARAMETERINVPROC = o
    extension (v: PFNGLCOMBINERPARAMETERINVPROC)
      inline def value: CFuncPtr2[GLenum, GLint, Unit] = v
      inline def toPtr: Ptr[?] = CFuncPtr.toPtr(v)

  opaque type PFNGLCOMBINERPARAMETERIVNVPROC = CFuncPtr2[GLenum, Ptr[GLint], Unit]
  object PFNGLCOMBINERPARAMETERIVNVPROC:
    given _tag: Tag[PFNGLCOMBINERPARAMETERIVNVPROC] = Tag.materializeCFuncPtr2[GLenum, Ptr[GLint], Unit]
    inline def fromPtr(ptr: Ptr[Byte] | Ptr[?]): PFNGLCOMBINERPARAMETERIVNVPROC = CFuncPtr.fromPtr(ptr.asInstanceOf[Ptr[Byte]])
    inline def apply(inline o: CFuncPtr2[GLenum, Ptr[GLint], Unit]): PFNGLCOMBINERPARAMETERIVNVPROC = o
    extension (v: PFNGLCOMBINERPARAMETERIVNVPROC)
      inline def value: CFuncPtr2[GLenum, Ptr[GLint], Unit] = v
      inline def toPtr: Ptr[?] = CFuncPtr.toPtr(v)

  opaque type PFNGLCOMBINERSTAGEPARAMETERFVNVPROC = CFuncPtr3[GLenum, GLenum, Ptr[GLfloat], Unit]
  object PFNGLCOMBINERSTAGEPARAMETERFVNVPROC:
    given _tag: Tag[PFNGLCOMBINERSTAGEPARAMETERFVNVPROC] = Tag.materializeCFuncPtr3[GLenum, GLenum, Ptr[GLfloat], Unit]
    inline def fromPtr(ptr: Ptr[Byte] | Ptr[?]): PFNGLCOMBINERSTAGEPARAMETERFVNVPROC = CFuncPtr.fromPtr(ptr.asInstanceOf[Ptr[Byte]])
    inline def apply(inline o: CFuncPtr3[GLenum, GLenum, Ptr[GLfloat], Unit]): PFNGLCOMBINERSTAGEPARAMETERFVNVPROC = o
    extension (v: PFNGLCOMBINERSTAGEPARAMETERFVNVPROC)
      inline def value: CFuncPtr3[GLenum, GLenum, Ptr[GLfloat], Unit] = v
      inline def toPtr: Ptr[?] = CFuncPtr.toPtr(v)

  opaque type PFNGLCOMMANDLISTSEGMENTSNVPROC = CFuncPtr2[GLuint, GLuint, Unit]
  object PFNGLCOMMANDLISTSEGMENTSNVPROC:
    given _tag: Tag[PFNGLCOMMANDLISTSEGMENTSNVPROC] = Tag.materializeCFuncPtr2[GLuint, GLuint, Unit]
    inline def fromPtr(ptr: Ptr[Byte] | Ptr[?]): PFNGLCOMMANDLISTSEGMENTSNVPROC = CFuncPtr.fromPtr(ptr.asInstanceOf[Ptr[Byte]])
    inline def apply(inline o: CFuncPtr2[GLuint, GLuint, Unit]): PFNGLCOMMANDLISTSEGMENTSNVPROC = o
    extension (v: PFNGLCOMMANDLISTSEGMENTSNVPROC)
      inline def value: CFuncPtr2[GLuint, GLuint, Unit] = v
      inline def toPtr: Ptr[?] = CFuncPtr.toPtr(v)

  opaque type PFNGLCOMPILECOMMANDLISTNVPROC = CFuncPtr1[GLuint, Unit]
  object PFNGLCOMPILECOMMANDLISTNVPROC:
    given _tag: Tag[PFNGLCOMPILECOMMANDLISTNVPROC] = Tag.materializeCFuncPtr1[GLuint, Unit]
    inline def fromPtr(ptr: Ptr[Byte] | Ptr[?]): PFNGLCOMPILECOMMANDLISTNVPROC = CFuncPtr.fromPtr(ptr.asInstanceOf[Ptr[Byte]])
    inline def apply(inline o: CFuncPtr1[GLuint, Unit]): PFNGLCOMPILECOMMANDLISTNVPROC = o
    extension (v: PFNGLCOMPILECOMMANDLISTNVPROC)
      inline def value: CFuncPtr1[GLuint, Unit] = v
      inline def toPtr: Ptr[?] = CFuncPtr.toPtr(v)

  opaque type PFNGLCOMPILESHADERARBPROC = CFuncPtr1[GLhandleARB, Unit]
  object PFNGLCOMPILESHADERARBPROC:
    given _tag: Tag[PFNGLCOMPILESHADERARBPROC] = Tag.materializeCFuncPtr1[GLhandleARB, Unit]
    inline def fromPtr(ptr: Ptr[Byte] | Ptr[?]): PFNGLCOMPILESHADERARBPROC = CFuncPtr.fromPtr(ptr.asInstanceOf[Ptr[Byte]])
    inline def apply(inline o: CFuncPtr1[GLhandleARB, Unit]): PFNGLCOMPILESHADERARBPROC = o
    extension (v: PFNGLCOMPILESHADERARBPROC)
      inline def value: CFuncPtr1[GLhandleARB, Unit] = v
      inline def toPtr: Ptr[?] = CFuncPtr.toPtr(v)

  opaque type PFNGLCOMPILESHADERINCLUDEARBPROC = CFuncPtr4[GLuint, GLsizei, Ptr[Ptr[GLchar]], Ptr[GLint], Unit]
  object PFNGLCOMPILESHADERINCLUDEARBPROC:
    given _tag: Tag[PFNGLCOMPILESHADERINCLUDEARBPROC] = Tag.materializeCFuncPtr4[GLuint, GLsizei, Ptr[Ptr[GLchar]], Ptr[GLint], Unit]
    inline def fromPtr(ptr: Ptr[Byte] | Ptr[?]): PFNGLCOMPILESHADERINCLUDEARBPROC = CFuncPtr.fromPtr(ptr.asInstanceOf[Ptr[Byte]])
    inline def apply(inline o: CFuncPtr4[GLuint, GLsizei, Ptr[Ptr[GLchar]], Ptr[GLint], Unit]): PFNGLCOMPILESHADERINCLUDEARBPROC = o
    extension (v: PFNGLCOMPILESHADERINCLUDEARBPROC)
      inline def value: CFuncPtr4[GLuint, GLsizei, Ptr[Ptr[GLchar]], Ptr[GLint], Unit] = v
      inline def toPtr: Ptr[?] = CFuncPtr.toPtr(v)

  opaque type PFNGLCOMPILESHADERPROC = CFuncPtr1[GLuint, Unit]
  object PFNGLCOMPILESHADERPROC:
    given _tag: Tag[PFNGLCOMPILESHADERPROC] = Tag.materializeCFuncPtr1[GLuint, Unit]
    inline def fromPtr(ptr: Ptr[Byte] | Ptr[?]): PFNGLCOMPILESHADERPROC = CFuncPtr.fromPtr(ptr.asInstanceOf[Ptr[Byte]])
    inline def apply(inline o: CFuncPtr1[GLuint, Unit]): PFNGLCOMPILESHADERPROC = o
    extension (v: PFNGLCOMPILESHADERPROC)
      inline def value: CFuncPtr1[GLuint, Unit] = v
      inline def toPtr: Ptr[?] = CFuncPtr.toPtr(v)

  opaque type PFNGLCOMPRESSEDMULTITEXIMAGE1DEXTPROC = CFuncPtr8[GLenum, GLenum, GLint, GLenum, GLsizei, GLint, GLsizei, Ptr[Byte], Unit]
  object PFNGLCOMPRESSEDMULTITEXIMAGE1DEXTPROC:
    given _tag: Tag[PFNGLCOMPRESSEDMULTITEXIMAGE1DEXTPROC] = Tag.materializeCFuncPtr8[GLenum, GLenum, GLint, GLenum, GLsizei, GLint, GLsizei, Ptr[Byte], Unit]
    inline def fromPtr(ptr: Ptr[Byte] | Ptr[?]): PFNGLCOMPRESSEDMULTITEXIMAGE1DEXTPROC = CFuncPtr.fromPtr(ptr.asInstanceOf[Ptr[Byte]])
    inline def apply(inline o: CFuncPtr8[GLenum, GLenum, GLint, GLenum, GLsizei, GLint, GLsizei, Ptr[Byte], Unit]): PFNGLCOMPRESSEDMULTITEXIMAGE1DEXTPROC = o
    extension (v: PFNGLCOMPRESSEDMULTITEXIMAGE1DEXTPROC)
      inline def value: CFuncPtr8[GLenum, GLenum, GLint, GLenum, GLsizei, GLint, GLsizei, Ptr[Byte], Unit] = v
      inline def toPtr: Ptr[?] = CFuncPtr.toPtr(v)

  opaque type PFNGLCOMPRESSEDMULTITEXIMAGE2DEXTPROC = CFuncPtr9[GLenum, GLenum, GLint, GLenum, GLsizei, GLsizei, GLint, GLsizei, Ptr[Byte], Unit]
  object PFNGLCOMPRESSEDMULTITEXIMAGE2DEXTPROC:
    given _tag: Tag[PFNGLCOMPRESSEDMULTITEXIMAGE2DEXTPROC] = Tag.materializeCFuncPtr9[GLenum, GLenum, GLint, GLenum, GLsizei, GLsizei, GLint, GLsizei, Ptr[Byte], Unit]
    inline def fromPtr(ptr: Ptr[Byte] | Ptr[?]): PFNGLCOMPRESSEDMULTITEXIMAGE2DEXTPROC = CFuncPtr.fromPtr(ptr.asInstanceOf[Ptr[Byte]])
    inline def apply(inline o: CFuncPtr9[GLenum, GLenum, GLint, GLenum, GLsizei, GLsizei, GLint, GLsizei, Ptr[Byte], Unit]): PFNGLCOMPRESSEDMULTITEXIMAGE2DEXTPROC = o
    extension (v: PFNGLCOMPRESSEDMULTITEXIMAGE2DEXTPROC)
      inline def value: CFuncPtr9[GLenum, GLenum, GLint, GLenum, GLsizei, GLsizei, GLint, GLsizei, Ptr[Byte], Unit] = v
      inline def toPtr: Ptr[?] = CFuncPtr.toPtr(v)

  opaque type PFNGLCOMPRESSEDMULTITEXIMAGE3DEXTPROC = CFuncPtr10[GLenum, GLenum, GLint, GLenum, GLsizei, GLsizei, GLsizei, GLint, GLsizei, Ptr[Byte], Unit]
  object PFNGLCOMPRESSEDMULTITEXIMAGE3DEXTPROC:
    given _tag: Tag[PFNGLCOMPRESSEDMULTITEXIMAGE3DEXTPROC] = Tag.materializeCFuncPtr10[GLenum, GLenum, GLint, GLenum, GLsizei, GLsizei, GLsizei, GLint, GLsizei, Ptr[Byte], Unit]
    inline def fromPtr(ptr: Ptr[Byte] | Ptr[?]): PFNGLCOMPRESSEDMULTITEXIMAGE3DEXTPROC = CFuncPtr.fromPtr(ptr.asInstanceOf[Ptr[Byte]])
    inline def apply(inline o: CFuncPtr10[GLenum, GLenum, GLint, GLenum, GLsizei, GLsizei, GLsizei, GLint, GLsizei, Ptr[Byte], Unit]): PFNGLCOMPRESSEDMULTITEXIMAGE3DEXTPROC = o
    extension (v: PFNGLCOMPRESSEDMULTITEXIMAGE3DEXTPROC)
      inline def value: CFuncPtr10[GLenum, GLenum, GLint, GLenum, GLsizei, GLsizei, GLsizei, GLint, GLsizei, Ptr[Byte], Unit] = v
      inline def toPtr: Ptr[?] = CFuncPtr.toPtr(v)

  opaque type PFNGLCOMPRESSEDMULTITEXSUBIMAGE1DEXTPROC = CFuncPtr8[GLenum, GLenum, GLint, GLint, GLsizei, GLenum, GLsizei, Ptr[Byte], Unit]
  object PFNGLCOMPRESSEDMULTITEXSUBIMAGE1DEXTPROC:
    given _tag: Tag[PFNGLCOMPRESSEDMULTITEXSUBIMAGE1DEXTPROC] = Tag.materializeCFuncPtr8[GLenum, GLenum, GLint, GLint, GLsizei, GLenum, GLsizei, Ptr[Byte], Unit]
    inline def fromPtr(ptr: Ptr[Byte] | Ptr[?]): PFNGLCOMPRESSEDMULTITEXSUBIMAGE1DEXTPROC = CFuncPtr.fromPtr(ptr.asInstanceOf[Ptr[Byte]])
    inline def apply(inline o: CFuncPtr8[GLenum, GLenum, GLint, GLint, GLsizei, GLenum, GLsizei, Ptr[Byte], Unit]): PFNGLCOMPRESSEDMULTITEXSUBIMAGE1DEXTPROC = o
    extension (v: PFNGLCOMPRESSEDMULTITEXSUBIMAGE1DEXTPROC)
      inline def value: CFuncPtr8[GLenum, GLenum, GLint, GLint, GLsizei, GLenum, GLsizei, Ptr[Byte], Unit] = v
      inline def toPtr: Ptr[?] = CFuncPtr.toPtr(v)

  opaque type PFNGLCOMPRESSEDMULTITEXSUBIMAGE2DEXTPROC = CFuncPtr10[GLenum, GLenum, GLint, GLint, GLint, GLsizei, GLsizei, GLenum, GLsizei, Ptr[Byte], Unit]
  object PFNGLCOMPRESSEDMULTITEXSUBIMAGE2DEXTPROC:
    given _tag: Tag[PFNGLCOMPRESSEDMULTITEXSUBIMAGE2DEXTPROC] = Tag.materializeCFuncPtr10[GLenum, GLenum, GLint, GLint, GLint, GLsizei, GLsizei, GLenum, GLsizei, Ptr[Byte], Unit]
    inline def fromPtr(ptr: Ptr[Byte] | Ptr[?]): PFNGLCOMPRESSEDMULTITEXSUBIMAGE2DEXTPROC = CFuncPtr.fromPtr(ptr.asInstanceOf[Ptr[Byte]])
    inline def apply(inline o: CFuncPtr10[GLenum, GLenum, GLint, GLint, GLint, GLsizei, GLsizei, GLenum, GLsizei, Ptr[Byte], Unit]): PFNGLCOMPRESSEDMULTITEXSUBIMAGE2DEXTPROC = o
    extension (v: PFNGLCOMPRESSEDMULTITEXSUBIMAGE2DEXTPROC)
      inline def value: CFuncPtr10[GLenum, GLenum, GLint, GLint, GLint, GLsizei, GLsizei, GLenum, GLsizei, Ptr[Byte], Unit] = v
      inline def toPtr: Ptr[?] = CFuncPtr.toPtr(v)

  opaque type PFNGLCOMPRESSEDMULTITEXSUBIMAGE3DEXTPROC = CFuncPtr12[GLenum, GLenum, GLint, GLint, GLint, GLint, GLsizei, GLsizei, GLsizei, GLenum, GLsizei, Ptr[Byte], Unit]
  object PFNGLCOMPRESSEDMULTITEXSUBIMAGE3DEXTPROC:
    given _tag: Tag[PFNGLCOMPRESSEDMULTITEXSUBIMAGE3DEXTPROC] = Tag.materializeCFuncPtr12[GLenum, GLenum, GLint, GLint, GLint, GLint, GLsizei, GLsizei, GLsizei, GLenum, GLsizei, Ptr[Byte], Unit]
    inline def fromPtr(ptr: Ptr[Byte] | Ptr[?]): PFNGLCOMPRESSEDMULTITEXSUBIMAGE3DEXTPROC = CFuncPtr.fromPtr(ptr.asInstanceOf[Ptr[Byte]])
    inline def apply(inline o: CFuncPtr12[GLenum, GLenum, GLint, GLint, GLint, GLint, GLsizei, GLsizei, GLsizei, GLenum, GLsizei, Ptr[Byte], Unit]): PFNGLCOMPRESSEDMULTITEXSUBIMAGE3DEXTPROC = o
    extension (v: PFNGLCOMPRESSEDMULTITEXSUBIMAGE3DEXTPROC)
      inline def value: CFuncPtr12[GLenum, GLenum, GLint, GLint, GLint, GLint, GLsizei, GLsizei, GLsizei, GLenum, GLsizei, Ptr[Byte], Unit] = v
      inline def toPtr: Ptr[?] = CFuncPtr.toPtr(v)

  opaque type PFNGLCOMPRESSEDTEXIMAGE1DARBPROC = CFuncPtr7[GLenum, GLint, GLenum, GLsizei, GLint, GLsizei, Ptr[Byte], Unit]
  object PFNGLCOMPRESSEDTEXIMAGE1DARBPROC:
    given _tag: Tag[PFNGLCOMPRESSEDTEXIMAGE1DARBPROC] = Tag.materializeCFuncPtr7[GLenum, GLint, GLenum, GLsizei, GLint, GLsizei, Ptr[Byte], Unit]
    inline def fromPtr(ptr: Ptr[Byte] | Ptr[?]): PFNGLCOMPRESSEDTEXIMAGE1DARBPROC = CFuncPtr.fromPtr(ptr.asInstanceOf[Ptr[Byte]])
    inline def apply(inline o: CFuncPtr7[GLenum, GLint, GLenum, GLsizei, GLint, GLsizei, Ptr[Byte], Unit]): PFNGLCOMPRESSEDTEXIMAGE1DARBPROC = o
    extension (v: PFNGLCOMPRESSEDTEXIMAGE1DARBPROC)
      inline def value: CFuncPtr7[GLenum, GLint, GLenum, GLsizei, GLint, GLsizei, Ptr[Byte], Unit] = v
      inline def toPtr: Ptr[?] = CFuncPtr.toPtr(v)

  opaque type PFNGLCOMPRESSEDTEXIMAGE1DPROC = CFuncPtr7[GLenum, GLint, GLenum, GLsizei, GLint, GLsizei, Ptr[Byte], Unit]
  object PFNGLCOMPRESSEDTEXIMAGE1DPROC:
    given _tag: Tag[PFNGLCOMPRESSEDTEXIMAGE1DPROC] = Tag.materializeCFuncPtr7[GLenum, GLint, GLenum, GLsizei, GLint, GLsizei, Ptr[Byte], Unit]
    inline def fromPtr(ptr: Ptr[Byte] | Ptr[?]): PFNGLCOMPRESSEDTEXIMAGE1DPROC = CFuncPtr.fromPtr(ptr.asInstanceOf[Ptr[Byte]])
    inline def apply(inline o: CFuncPtr7[GLenum, GLint, GLenum, GLsizei, GLint, GLsizei, Ptr[Byte], Unit]): PFNGLCOMPRESSEDTEXIMAGE1DPROC = o
    extension (v: PFNGLCOMPRESSEDTEXIMAGE1DPROC)
      inline def value: CFuncPtr7[GLenum, GLint, GLenum, GLsizei, GLint, GLsizei, Ptr[Byte], Unit] = v
      inline def toPtr: Ptr[?] = CFuncPtr.toPtr(v)

  opaque type PFNGLCOMPRESSEDTEXIMAGE2DARBPROC = CFuncPtr8[GLenum, GLint, GLenum, GLsizei, GLsizei, GLint, GLsizei, Ptr[Byte], Unit]
  object PFNGLCOMPRESSEDTEXIMAGE2DARBPROC:
    given _tag: Tag[PFNGLCOMPRESSEDTEXIMAGE2DARBPROC] = Tag.materializeCFuncPtr8[GLenum, GLint, GLenum, GLsizei, GLsizei, GLint, GLsizei, Ptr[Byte], Unit]
    inline def fromPtr(ptr: Ptr[Byte] | Ptr[?]): PFNGLCOMPRESSEDTEXIMAGE2DARBPROC = CFuncPtr.fromPtr(ptr.asInstanceOf[Ptr[Byte]])
    inline def apply(inline o: CFuncPtr8[GLenum, GLint, GLenum, GLsizei, GLsizei, GLint, GLsizei, Ptr[Byte], Unit]): PFNGLCOMPRESSEDTEXIMAGE2DARBPROC = o
    extension (v: PFNGLCOMPRESSEDTEXIMAGE2DARBPROC)
      inline def value: CFuncPtr8[GLenum, GLint, GLenum, GLsizei, GLsizei, GLint, GLsizei, Ptr[Byte], Unit] = v
      inline def toPtr: Ptr[?] = CFuncPtr.toPtr(v)

  opaque type PFNGLCOMPRESSEDTEXIMAGE2DPROC = CFuncPtr8[GLenum, GLint, GLenum, GLsizei, GLsizei, GLint, GLsizei, Ptr[Byte], Unit]
  object PFNGLCOMPRESSEDTEXIMAGE2DPROC:
    given _tag: Tag[PFNGLCOMPRESSEDTEXIMAGE2DPROC] = Tag.materializeCFuncPtr8[GLenum, GLint, GLenum, GLsizei, GLsizei, GLint, GLsizei, Ptr[Byte], Unit]
    inline def fromPtr(ptr: Ptr[Byte] | Ptr[?]): PFNGLCOMPRESSEDTEXIMAGE2DPROC = CFuncPtr.fromPtr(ptr.asInstanceOf[Ptr[Byte]])
    inline def apply(inline o: CFuncPtr8[GLenum, GLint, GLenum, GLsizei, GLsizei, GLint, GLsizei, Ptr[Byte], Unit]): PFNGLCOMPRESSEDTEXIMAGE2DPROC = o
    extension (v: PFNGLCOMPRESSEDTEXIMAGE2DPROC)
      inline def value: CFuncPtr8[GLenum, GLint, GLenum, GLsizei, GLsizei, GLint, GLsizei, Ptr[Byte], Unit] = v
      inline def toPtr: Ptr[?] = CFuncPtr.toPtr(v)

  opaque type PFNGLCOMPRESSEDTEXIMAGE3DARBPROC = CFuncPtr9[GLenum, GLint, GLenum, GLsizei, GLsizei, GLsizei, GLint, GLsizei, Ptr[Byte], Unit]
  object PFNGLCOMPRESSEDTEXIMAGE3DARBPROC:
    given _tag: Tag[PFNGLCOMPRESSEDTEXIMAGE3DARBPROC] = Tag.materializeCFuncPtr9[GLenum, GLint, GLenum, GLsizei, GLsizei, GLsizei, GLint, GLsizei, Ptr[Byte], Unit]
    inline def fromPtr(ptr: Ptr[Byte] | Ptr[?]): PFNGLCOMPRESSEDTEXIMAGE3DARBPROC = CFuncPtr.fromPtr(ptr.asInstanceOf[Ptr[Byte]])
    inline def apply(inline o: CFuncPtr9[GLenum, GLint, GLenum, GLsizei, GLsizei, GLsizei, GLint, GLsizei, Ptr[Byte], Unit]): PFNGLCOMPRESSEDTEXIMAGE3DARBPROC = o
    extension (v: PFNGLCOMPRESSEDTEXIMAGE3DARBPROC)
      inline def value: CFuncPtr9[GLenum, GLint, GLenum, GLsizei, GLsizei, GLsizei, GLint, GLsizei, Ptr[Byte], Unit] = v
      inline def toPtr: Ptr[?] = CFuncPtr.toPtr(v)

  opaque type PFNGLCOMPRESSEDTEXIMAGE3DNVPROC = CFuncPtr9[GLenum, GLint, GLenum, GLsizei, GLsizei, GLsizei, GLint, GLsizei, Ptr[Byte], Unit]
  object PFNGLCOMPRESSEDTEXIMAGE3DNVPROC:
    given _tag: Tag[PFNGLCOMPRESSEDTEXIMAGE3DNVPROC] = Tag.materializeCFuncPtr9[GLenum, GLint, GLenum, GLsizei, GLsizei, GLsizei, GLint, GLsizei, Ptr[Byte], Unit]
    inline def fromPtr(ptr: Ptr[Byte] | Ptr[?]): PFNGLCOMPRESSEDTEXIMAGE3DNVPROC = CFuncPtr.fromPtr(ptr.asInstanceOf[Ptr[Byte]])
    inline def apply(inline o: CFuncPtr9[GLenum, GLint, GLenum, GLsizei, GLsizei, GLsizei, GLint, GLsizei, Ptr[Byte], Unit]): PFNGLCOMPRESSEDTEXIMAGE3DNVPROC = o
    extension (v: PFNGLCOMPRESSEDTEXIMAGE3DNVPROC)
      inline def value: CFuncPtr9[GLenum, GLint, GLenum, GLsizei, GLsizei, GLsizei, GLint, GLsizei, Ptr[Byte], Unit] = v
      inline def toPtr: Ptr[?] = CFuncPtr.toPtr(v)

  opaque type PFNGLCOMPRESSEDTEXIMAGE3DOESPROC = CFuncPtr9[GLenum, GLint, GLenum, GLsizei, GLsizei, GLsizei, GLint, GLsizei, Ptr[Byte], Unit]
  object PFNGLCOMPRESSEDTEXIMAGE3DOESPROC:
    given _tag: Tag[PFNGLCOMPRESSEDTEXIMAGE3DOESPROC] = Tag.materializeCFuncPtr9[GLenum, GLint, GLenum, GLsizei, GLsizei, GLsizei, GLint, GLsizei, Ptr[Byte], Unit]
    inline def fromPtr(ptr: Ptr[Byte] | Ptr[?]): PFNGLCOMPRESSEDTEXIMAGE3DOESPROC = CFuncPtr.fromPtr(ptr.asInstanceOf[Ptr[Byte]])
    inline def apply(inline o: CFuncPtr9[GLenum, GLint, GLenum, GLsizei, GLsizei, GLsizei, GLint, GLsizei, Ptr[Byte], Unit]): PFNGLCOMPRESSEDTEXIMAGE3DOESPROC = o
    extension (v: PFNGLCOMPRESSEDTEXIMAGE3DOESPROC)
      inline def value: CFuncPtr9[GLenum, GLint, GLenum, GLsizei, GLsizei, GLsizei, GLint, GLsizei, Ptr[Byte], Unit] = v
      inline def toPtr: Ptr[?] = CFuncPtr.toPtr(v)

  opaque type PFNGLCOMPRESSEDTEXIMAGE3DPROC = CFuncPtr9[GLenum, GLint, GLenum, GLsizei, GLsizei, GLsizei, GLint, GLsizei, Ptr[Byte], Unit]
  object PFNGLCOMPRESSEDTEXIMAGE3DPROC:
    given _tag: Tag[PFNGLCOMPRESSEDTEXIMAGE3DPROC] = Tag.materializeCFuncPtr9[GLenum, GLint, GLenum, GLsizei, GLsizei, GLsizei, GLint, GLsizei, Ptr[Byte], Unit]
    inline def fromPtr(ptr: Ptr[Byte] | Ptr[?]): PFNGLCOMPRESSEDTEXIMAGE3DPROC = CFuncPtr.fromPtr(ptr.asInstanceOf[Ptr[Byte]])
    inline def apply(inline o: CFuncPtr9[GLenum, GLint, GLenum, GLsizei, GLsizei, GLsizei, GLint, GLsizei, Ptr[Byte], Unit]): PFNGLCOMPRESSEDTEXIMAGE3DPROC = o
    extension (v: PFNGLCOMPRESSEDTEXIMAGE3DPROC)
      inline def value: CFuncPtr9[GLenum, GLint, GLenum, GLsizei, GLsizei, GLsizei, GLint, GLsizei, Ptr[Byte], Unit] = v
      inline def toPtr: Ptr[?] = CFuncPtr.toPtr(v)

  opaque type PFNGLCOMPRESSEDTEXSUBIMAGE1DARBPROC = CFuncPtr7[GLenum, GLint, GLint, GLsizei, GLenum, GLsizei, Ptr[Byte], Unit]
  object PFNGLCOMPRESSEDTEXSUBIMAGE1DARBPROC:
    given _tag: Tag[PFNGLCOMPRESSEDTEXSUBIMAGE1DARBPROC] = Tag.materializeCFuncPtr7[GLenum, GLint, GLint, GLsizei, GLenum, GLsizei, Ptr[Byte], Unit]
    inline def fromPtr(ptr: Ptr[Byte] | Ptr[?]): PFNGLCOMPRESSEDTEXSUBIMAGE1DARBPROC = CFuncPtr.fromPtr(ptr.asInstanceOf[Ptr[Byte]])
    inline def apply(inline o: CFuncPtr7[GLenum, GLint, GLint, GLsizei, GLenum, GLsizei, Ptr[Byte], Unit]): PFNGLCOMPRESSEDTEXSUBIMAGE1DARBPROC = o
    extension (v: PFNGLCOMPRESSEDTEXSUBIMAGE1DARBPROC)
      inline def value: CFuncPtr7[GLenum, GLint, GLint, GLsizei, GLenum, GLsizei, Ptr[Byte], Unit] = v
      inline def toPtr: Ptr[?] = CFuncPtr.toPtr(v)

  opaque type PFNGLCOMPRESSEDTEXSUBIMAGE1DPROC = CFuncPtr7[GLenum, GLint, GLint, GLsizei, GLenum, GLsizei, Ptr[Byte], Unit]
  object PFNGLCOMPRESSEDTEXSUBIMAGE1DPROC:
    given _tag: Tag[PFNGLCOMPRESSEDTEXSUBIMAGE1DPROC] = Tag.materializeCFuncPtr7[GLenum, GLint, GLint, GLsizei, GLenum, GLsizei, Ptr[Byte], Unit]
    inline def fromPtr(ptr: Ptr[Byte] | Ptr[?]): PFNGLCOMPRESSEDTEXSUBIMAGE1DPROC = CFuncPtr.fromPtr(ptr.asInstanceOf[Ptr[Byte]])
    inline def apply(inline o: CFuncPtr7[GLenum, GLint, GLint, GLsizei, GLenum, GLsizei, Ptr[Byte], Unit]): PFNGLCOMPRESSEDTEXSUBIMAGE1DPROC = o
    extension (v: PFNGLCOMPRESSEDTEXSUBIMAGE1DPROC)
      inline def value: CFuncPtr7[GLenum, GLint, GLint, GLsizei, GLenum, GLsizei, Ptr[Byte], Unit] = v
      inline def toPtr: Ptr[?] = CFuncPtr.toPtr(v)

  opaque type PFNGLCOMPRESSEDTEXSUBIMAGE2DARBPROC = CFuncPtr9[GLenum, GLint, GLint, GLint, GLsizei, GLsizei, GLenum, GLsizei, Ptr[Byte], Unit]
  object PFNGLCOMPRESSEDTEXSUBIMAGE2DARBPROC:
    given _tag: Tag[PFNGLCOMPRESSEDTEXSUBIMAGE2DARBPROC] = Tag.materializeCFuncPtr9[GLenum, GLint, GLint, GLint, GLsizei, GLsizei, GLenum, GLsizei, Ptr[Byte], Unit]
    inline def fromPtr(ptr: Ptr[Byte] | Ptr[?]): PFNGLCOMPRESSEDTEXSUBIMAGE2DARBPROC = CFuncPtr.fromPtr(ptr.asInstanceOf[Ptr[Byte]])
    inline def apply(inline o: CFuncPtr9[GLenum, GLint, GLint, GLint, GLsizei, GLsizei, GLenum, GLsizei, Ptr[Byte], Unit]): PFNGLCOMPRESSEDTEXSUBIMAGE2DARBPROC = o
    extension (v: PFNGLCOMPRESSEDTEXSUBIMAGE2DARBPROC)
      inline def value: CFuncPtr9[GLenum, GLint, GLint, GLint, GLsizei, GLsizei, GLenum, GLsizei, Ptr[Byte], Unit] = v
      inline def toPtr: Ptr[?] = CFuncPtr.toPtr(v)

  opaque type PFNGLCOMPRESSEDTEXSUBIMAGE2DPROC = CFuncPtr9[GLenum, GLint, GLint, GLint, GLsizei, GLsizei, GLenum, GLsizei, Ptr[Byte], Unit]
  object PFNGLCOMPRESSEDTEXSUBIMAGE2DPROC:
    given _tag: Tag[PFNGLCOMPRESSEDTEXSUBIMAGE2DPROC] = Tag.materializeCFuncPtr9[GLenum, GLint, GLint, GLint, GLsizei, GLsizei, GLenum, GLsizei, Ptr[Byte], Unit]
    inline def fromPtr(ptr: Ptr[Byte] | Ptr[?]): PFNGLCOMPRESSEDTEXSUBIMAGE2DPROC = CFuncPtr.fromPtr(ptr.asInstanceOf[Ptr[Byte]])
    inline def apply(inline o: CFuncPtr9[GLenum, GLint, GLint, GLint, GLsizei, GLsizei, GLenum, GLsizei, Ptr[Byte], Unit]): PFNGLCOMPRESSEDTEXSUBIMAGE2DPROC = o
    extension (v: PFNGLCOMPRESSEDTEXSUBIMAGE2DPROC)
      inline def value: CFuncPtr9[GLenum, GLint, GLint, GLint, GLsizei, GLsizei, GLenum, GLsizei, Ptr[Byte], Unit] = v
      inline def toPtr: Ptr[?] = CFuncPtr.toPtr(v)

  opaque type PFNGLCOMPRESSEDTEXSUBIMAGE3DARBPROC = CFuncPtr11[GLenum, GLint, GLint, GLint, GLint, GLsizei, GLsizei, GLsizei, GLenum, GLsizei, Ptr[Byte], Unit]
  object PFNGLCOMPRESSEDTEXSUBIMAGE3DARBPROC:
    given _tag: Tag[PFNGLCOMPRESSEDTEXSUBIMAGE3DARBPROC] = Tag.materializeCFuncPtr11[GLenum, GLint, GLint, GLint, GLint, GLsizei, GLsizei, GLsizei, GLenum, GLsizei, Ptr[Byte], Unit]
    inline def fromPtr(ptr: Ptr[Byte] | Ptr[?]): PFNGLCOMPRESSEDTEXSUBIMAGE3DARBPROC = CFuncPtr.fromPtr(ptr.asInstanceOf[Ptr[Byte]])
    inline def apply(inline o: CFuncPtr11[GLenum, GLint, GLint, GLint, GLint, GLsizei, GLsizei, GLsizei, GLenum, GLsizei, Ptr[Byte], Unit]): PFNGLCOMPRESSEDTEXSUBIMAGE3DARBPROC = o
    extension (v: PFNGLCOMPRESSEDTEXSUBIMAGE3DARBPROC)
      inline def value: CFuncPtr11[GLenum, GLint, GLint, GLint, GLint, GLsizei, GLsizei, GLsizei, GLenum, GLsizei, Ptr[Byte], Unit] = v
      inline def toPtr: Ptr[?] = CFuncPtr.toPtr(v)

  opaque type PFNGLCOMPRESSEDTEXSUBIMAGE3DNVPROC = CFuncPtr11[GLenum, GLint, GLint, GLint, GLint, GLsizei, GLsizei, GLsizei, GLenum, GLsizei, Ptr[Byte], Unit]
  object PFNGLCOMPRESSEDTEXSUBIMAGE3DNVPROC:
    given _tag: Tag[PFNGLCOMPRESSEDTEXSUBIMAGE3DNVPROC] = Tag.materializeCFuncPtr11[GLenum, GLint, GLint, GLint, GLint, GLsizei, GLsizei, GLsizei, GLenum, GLsizei, Ptr[Byte], Unit]
    inline def fromPtr(ptr: Ptr[Byte] | Ptr[?]): PFNGLCOMPRESSEDTEXSUBIMAGE3DNVPROC = CFuncPtr.fromPtr(ptr.asInstanceOf[Ptr[Byte]])
    inline def apply(inline o: CFuncPtr11[GLenum, GLint, GLint, GLint, GLint, GLsizei, GLsizei, GLsizei, GLenum, GLsizei, Ptr[Byte], Unit]): PFNGLCOMPRESSEDTEXSUBIMAGE3DNVPROC = o
    extension (v: PFNGLCOMPRESSEDTEXSUBIMAGE3DNVPROC)
      inline def value: CFuncPtr11[GLenum, GLint, GLint, GLint, GLint, GLsizei, GLsizei, GLsizei, GLenum, GLsizei, Ptr[Byte], Unit] = v
      inline def toPtr: Ptr[?] = CFuncPtr.toPtr(v)

  opaque type PFNGLCOMPRESSEDTEXSUBIMAGE3DOESPROC = CFuncPtr11[GLenum, GLint, GLint, GLint, GLint, GLsizei, GLsizei, GLsizei, GLenum, GLsizei, Ptr[Byte], Unit]
  object PFNGLCOMPRESSEDTEXSUBIMAGE3DOESPROC:
    given _tag: Tag[PFNGLCOMPRESSEDTEXSUBIMAGE3DOESPROC] = Tag.materializeCFuncPtr11[GLenum, GLint, GLint, GLint, GLint, GLsizei, GLsizei, GLsizei, GLenum, GLsizei, Ptr[Byte], Unit]
    inline def fromPtr(ptr: Ptr[Byte] | Ptr[?]): PFNGLCOMPRESSEDTEXSUBIMAGE3DOESPROC = CFuncPtr.fromPtr(ptr.asInstanceOf[Ptr[Byte]])
    inline def apply(inline o: CFuncPtr11[GLenum, GLint, GLint, GLint, GLint, GLsizei, GLsizei, GLsizei, GLenum, GLsizei, Ptr[Byte], Unit]): PFNGLCOMPRESSEDTEXSUBIMAGE3DOESPROC = o
    extension (v: PFNGLCOMPRESSEDTEXSUBIMAGE3DOESPROC)
      inline def value: CFuncPtr11[GLenum, GLint, GLint, GLint, GLint, GLsizei, GLsizei, GLsizei, GLenum, GLsizei, Ptr[Byte], Unit] = v
      inline def toPtr: Ptr[?] = CFuncPtr.toPtr(v)

  opaque type PFNGLCOMPRESSEDTEXSUBIMAGE3DPROC = CFuncPtr11[GLenum, GLint, GLint, GLint, GLint, GLsizei, GLsizei, GLsizei, GLenum, GLsizei, Ptr[Byte], Unit]
  object PFNGLCOMPRESSEDTEXSUBIMAGE3DPROC:
    given _tag: Tag[PFNGLCOMPRESSEDTEXSUBIMAGE3DPROC] = Tag.materializeCFuncPtr11[GLenum, GLint, GLint, GLint, GLint, GLsizei, GLsizei, GLsizei, GLenum, GLsizei, Ptr[Byte], Unit]
    inline def fromPtr(ptr: Ptr[Byte] | Ptr[?]): PFNGLCOMPRESSEDTEXSUBIMAGE3DPROC = CFuncPtr.fromPtr(ptr.asInstanceOf[Ptr[Byte]])
    inline def apply(inline o: CFuncPtr11[GLenum, GLint, GLint, GLint, GLint, GLsizei, GLsizei, GLsizei, GLenum, GLsizei, Ptr[Byte], Unit]): PFNGLCOMPRESSEDTEXSUBIMAGE3DPROC = o
    extension (v: PFNGLCOMPRESSEDTEXSUBIMAGE3DPROC)
      inline def value: CFuncPtr11[GLenum, GLint, GLint, GLint, GLint, GLsizei, GLsizei, GLsizei, GLenum, GLsizei, Ptr[Byte], Unit] = v
      inline def toPtr: Ptr[?] = CFuncPtr.toPtr(v)

  opaque type PFNGLCOMPRESSEDTEXTUREIMAGE1DEXTPROC = CFuncPtr8[GLuint, GLenum, GLint, GLenum, GLsizei, GLint, GLsizei, Ptr[Byte], Unit]
  object PFNGLCOMPRESSEDTEXTUREIMAGE1DEXTPROC:
    given _tag: Tag[PFNGLCOMPRESSEDTEXTUREIMAGE1DEXTPROC] = Tag.materializeCFuncPtr8[GLuint, GLenum, GLint, GLenum, GLsizei, GLint, GLsizei, Ptr[Byte], Unit]
    inline def fromPtr(ptr: Ptr[Byte] | Ptr[?]): PFNGLCOMPRESSEDTEXTUREIMAGE1DEXTPROC = CFuncPtr.fromPtr(ptr.asInstanceOf[Ptr[Byte]])
    inline def apply(inline o: CFuncPtr8[GLuint, GLenum, GLint, GLenum, GLsizei, GLint, GLsizei, Ptr[Byte], Unit]): PFNGLCOMPRESSEDTEXTUREIMAGE1DEXTPROC = o
    extension (v: PFNGLCOMPRESSEDTEXTUREIMAGE1DEXTPROC)
      inline def value: CFuncPtr8[GLuint, GLenum, GLint, GLenum, GLsizei, GLint, GLsizei, Ptr[Byte], Unit] = v
      inline def toPtr: Ptr[?] = CFuncPtr.toPtr(v)

  opaque type PFNGLCOMPRESSEDTEXTUREIMAGE2DEXTPROC = CFuncPtr9[GLuint, GLenum, GLint, GLenum, GLsizei, GLsizei, GLint, GLsizei, Ptr[Byte], Unit]
  object PFNGLCOMPRESSEDTEXTUREIMAGE2DEXTPROC:
    given _tag: Tag[PFNGLCOMPRESSEDTEXTUREIMAGE2DEXTPROC] = Tag.materializeCFuncPtr9[GLuint, GLenum, GLint, GLenum, GLsizei, GLsizei, GLint, GLsizei, Ptr[Byte], Unit]
    inline def fromPtr(ptr: Ptr[Byte] | Ptr[?]): PFNGLCOMPRESSEDTEXTUREIMAGE2DEXTPROC = CFuncPtr.fromPtr(ptr.asInstanceOf[Ptr[Byte]])
    inline def apply(inline o: CFuncPtr9[GLuint, GLenum, GLint, GLenum, GLsizei, GLsizei, GLint, GLsizei, Ptr[Byte], Unit]): PFNGLCOMPRESSEDTEXTUREIMAGE2DEXTPROC = o
    extension (v: PFNGLCOMPRESSEDTEXTUREIMAGE2DEXTPROC)
      inline def value: CFuncPtr9[GLuint, GLenum, GLint, GLenum, GLsizei, GLsizei, GLint, GLsizei, Ptr[Byte], Unit] = v
      inline def toPtr: Ptr[?] = CFuncPtr.toPtr(v)

  opaque type PFNGLCOMPRESSEDTEXTUREIMAGE3DEXTPROC = CFuncPtr10[GLuint, GLenum, GLint, GLenum, GLsizei, GLsizei, GLsizei, GLint, GLsizei, Ptr[Byte], Unit]
  object PFNGLCOMPRESSEDTEXTUREIMAGE3DEXTPROC:
    given _tag: Tag[PFNGLCOMPRESSEDTEXTUREIMAGE3DEXTPROC] = Tag.materializeCFuncPtr10[GLuint, GLenum, GLint, GLenum, GLsizei, GLsizei, GLsizei, GLint, GLsizei, Ptr[Byte], Unit]
    inline def fromPtr(ptr: Ptr[Byte] | Ptr[?]): PFNGLCOMPRESSEDTEXTUREIMAGE3DEXTPROC = CFuncPtr.fromPtr(ptr.asInstanceOf[Ptr[Byte]])
    inline def apply(inline o: CFuncPtr10[GLuint, GLenum, GLint, GLenum, GLsizei, GLsizei, GLsizei, GLint, GLsizei, Ptr[Byte], Unit]): PFNGLCOMPRESSEDTEXTUREIMAGE3DEXTPROC = o
    extension (v: PFNGLCOMPRESSEDTEXTUREIMAGE3DEXTPROC)
      inline def value: CFuncPtr10[GLuint, GLenum, GLint, GLenum, GLsizei, GLsizei, GLsizei, GLint, GLsizei, Ptr[Byte], Unit] = v
      inline def toPtr: Ptr[?] = CFuncPtr.toPtr(v)

  opaque type PFNGLCOMPRESSEDTEXTURESUBIMAGE1DEXTPROC = CFuncPtr8[GLuint, GLenum, GLint, GLint, GLsizei, GLenum, GLsizei, Ptr[Byte], Unit]
  object PFNGLCOMPRESSEDTEXTURESUBIMAGE1DEXTPROC:
    given _tag: Tag[PFNGLCOMPRESSEDTEXTURESUBIMAGE1DEXTPROC] = Tag.materializeCFuncPtr8[GLuint, GLenum, GLint, GLint, GLsizei, GLenum, GLsizei, Ptr[Byte], Unit]
    inline def fromPtr(ptr: Ptr[Byte] | Ptr[?]): PFNGLCOMPRESSEDTEXTURESUBIMAGE1DEXTPROC = CFuncPtr.fromPtr(ptr.asInstanceOf[Ptr[Byte]])
    inline def apply(inline o: CFuncPtr8[GLuint, GLenum, GLint, GLint, GLsizei, GLenum, GLsizei, Ptr[Byte], Unit]): PFNGLCOMPRESSEDTEXTURESUBIMAGE1DEXTPROC = o
    extension (v: PFNGLCOMPRESSEDTEXTURESUBIMAGE1DEXTPROC)
      inline def value: CFuncPtr8[GLuint, GLenum, GLint, GLint, GLsizei, GLenum, GLsizei, Ptr[Byte], Unit] = v
      inline def toPtr: Ptr[?] = CFuncPtr.toPtr(v)

  opaque type PFNGLCOMPRESSEDTEXTURESUBIMAGE1DPROC = CFuncPtr7[GLuint, GLint, GLint, GLsizei, GLenum, GLsizei, Ptr[Byte], Unit]
  object PFNGLCOMPRESSEDTEXTURESUBIMAGE1DPROC:
    given _tag: Tag[PFNGLCOMPRESSEDTEXTURESUBIMAGE1DPROC] = Tag.materializeCFuncPtr7[GLuint, GLint, GLint, GLsizei, GLenum, GLsizei, Ptr[Byte], Unit]
    inline def fromPtr(ptr: Ptr[Byte] | Ptr[?]): PFNGLCOMPRESSEDTEXTURESUBIMAGE1DPROC = CFuncPtr.fromPtr(ptr.asInstanceOf[Ptr[Byte]])
    inline def apply(inline o: CFuncPtr7[GLuint, GLint, GLint, GLsizei, GLenum, GLsizei, Ptr[Byte], Unit]): PFNGLCOMPRESSEDTEXTURESUBIMAGE1DPROC = o
    extension (v: PFNGLCOMPRESSEDTEXTURESUBIMAGE1DPROC)
      inline def value: CFuncPtr7[GLuint, GLint, GLint, GLsizei, GLenum, GLsizei, Ptr[Byte], Unit] = v
      inline def toPtr: Ptr[?] = CFuncPtr.toPtr(v)

  opaque type PFNGLCOMPRESSEDTEXTURESUBIMAGE2DEXTPROC = CFuncPtr10[GLuint, GLenum, GLint, GLint, GLint, GLsizei, GLsizei, GLenum, GLsizei, Ptr[Byte], Unit]
  object PFNGLCOMPRESSEDTEXTURESUBIMAGE2DEXTPROC:
    given _tag: Tag[PFNGLCOMPRESSEDTEXTURESUBIMAGE2DEXTPROC] = Tag.materializeCFuncPtr10[GLuint, GLenum, GLint, GLint, GLint, GLsizei, GLsizei, GLenum, GLsizei, Ptr[Byte], Unit]
    inline def fromPtr(ptr: Ptr[Byte] | Ptr[?]): PFNGLCOMPRESSEDTEXTURESUBIMAGE2DEXTPROC = CFuncPtr.fromPtr(ptr.asInstanceOf[Ptr[Byte]])
    inline def apply(inline o: CFuncPtr10[GLuint, GLenum, GLint, GLint, GLint, GLsizei, GLsizei, GLenum, GLsizei, Ptr[Byte], Unit]): PFNGLCOMPRESSEDTEXTURESUBIMAGE2DEXTPROC = o
    extension (v: PFNGLCOMPRESSEDTEXTURESUBIMAGE2DEXTPROC)
      inline def value: CFuncPtr10[GLuint, GLenum, GLint, GLint, GLint, GLsizei, GLsizei, GLenum, GLsizei, Ptr[Byte], Unit] = v
      inline def toPtr: Ptr[?] = CFuncPtr.toPtr(v)

  opaque type PFNGLCOMPRESSEDTEXTURESUBIMAGE2DPROC = CFuncPtr9[GLuint, GLint, GLint, GLint, GLsizei, GLsizei, GLenum, GLsizei, Ptr[Byte], Unit]
  object PFNGLCOMPRESSEDTEXTURESUBIMAGE2DPROC:
    given _tag: Tag[PFNGLCOMPRESSEDTEXTURESUBIMAGE2DPROC] = Tag.materializeCFuncPtr9[GLuint, GLint, GLint, GLint, GLsizei, GLsizei, GLenum, GLsizei, Ptr[Byte], Unit]
    inline def fromPtr(ptr: Ptr[Byte] | Ptr[?]): PFNGLCOMPRESSEDTEXTURESUBIMAGE2DPROC = CFuncPtr.fromPtr(ptr.asInstanceOf[Ptr[Byte]])
    inline def apply(inline o: CFuncPtr9[GLuint, GLint, GLint, GLint, GLsizei, GLsizei, GLenum, GLsizei, Ptr[Byte], Unit]): PFNGLCOMPRESSEDTEXTURESUBIMAGE2DPROC = o
    extension (v: PFNGLCOMPRESSEDTEXTURESUBIMAGE2DPROC)
      inline def value: CFuncPtr9[GLuint, GLint, GLint, GLint, GLsizei, GLsizei, GLenum, GLsizei, Ptr[Byte], Unit] = v
      inline def toPtr: Ptr[?] = CFuncPtr.toPtr(v)

  opaque type PFNGLCOMPRESSEDTEXTURESUBIMAGE3DEXTPROC = CFuncPtr12[GLuint, GLenum, GLint, GLint, GLint, GLint, GLsizei, GLsizei, GLsizei, GLenum, GLsizei, Ptr[Byte], Unit]
  object PFNGLCOMPRESSEDTEXTURESUBIMAGE3DEXTPROC:
    given _tag: Tag[PFNGLCOMPRESSEDTEXTURESUBIMAGE3DEXTPROC] = Tag.materializeCFuncPtr12[GLuint, GLenum, GLint, GLint, GLint, GLint, GLsizei, GLsizei, GLsizei, GLenum, GLsizei, Ptr[Byte], Unit]
    inline def fromPtr(ptr: Ptr[Byte] | Ptr[?]): PFNGLCOMPRESSEDTEXTURESUBIMAGE3DEXTPROC = CFuncPtr.fromPtr(ptr.asInstanceOf[Ptr[Byte]])
    inline def apply(inline o: CFuncPtr12[GLuint, GLenum, GLint, GLint, GLint, GLint, GLsizei, GLsizei, GLsizei, GLenum, GLsizei, Ptr[Byte], Unit]): PFNGLCOMPRESSEDTEXTURESUBIMAGE3DEXTPROC = o
    extension (v: PFNGLCOMPRESSEDTEXTURESUBIMAGE3DEXTPROC)
      inline def value: CFuncPtr12[GLuint, GLenum, GLint, GLint, GLint, GLint, GLsizei, GLsizei, GLsizei, GLenum, GLsizei, Ptr[Byte], Unit] = v
      inline def toPtr: Ptr[?] = CFuncPtr.toPtr(v)

  opaque type PFNGLCOMPRESSEDTEXTURESUBIMAGE3DPROC = CFuncPtr11[GLuint, GLint, GLint, GLint, GLint, GLsizei, GLsizei, GLsizei, GLenum, GLsizei, Ptr[Byte], Unit]
  object PFNGLCOMPRESSEDTEXTURESUBIMAGE3DPROC:
    given _tag: Tag[PFNGLCOMPRESSEDTEXTURESUBIMAGE3DPROC] = Tag.materializeCFuncPtr11[GLuint, GLint, GLint, GLint, GLint, GLsizei, GLsizei, GLsizei, GLenum, GLsizei, Ptr[Byte], Unit]
    inline def fromPtr(ptr: Ptr[Byte] | Ptr[?]): PFNGLCOMPRESSEDTEXTURESUBIMAGE3DPROC = CFuncPtr.fromPtr(ptr.asInstanceOf[Ptr[Byte]])
    inline def apply(inline o: CFuncPtr11[GLuint, GLint, GLint, GLint, GLint, GLsizei, GLsizei, GLsizei, GLenum, GLsizei, Ptr[Byte], Unit]): PFNGLCOMPRESSEDTEXTURESUBIMAGE3DPROC = o
    extension (v: PFNGLCOMPRESSEDTEXTURESUBIMAGE3DPROC)
      inline def value: CFuncPtr11[GLuint, GLint, GLint, GLint, GLint, GLsizei, GLsizei, GLsizei, GLenum, GLsizei, Ptr[Byte], Unit] = v
      inline def toPtr: Ptr[?] = CFuncPtr.toPtr(v)

  opaque type PFNGLCONSERVATIVERASTERPARAMETERFNVPROC = CFuncPtr2[GLenum, GLfloat, Unit]
  object PFNGLCONSERVATIVERASTERPARAMETERFNVPROC:
    given _tag: Tag[PFNGLCONSERVATIVERASTERPARAMETERFNVPROC] = Tag.materializeCFuncPtr2[GLenum, GLfloat, Unit]
    inline def fromPtr(ptr: Ptr[Byte] | Ptr[?]): PFNGLCONSERVATIVERASTERPARAMETERFNVPROC = CFuncPtr.fromPtr(ptr.asInstanceOf[Ptr[Byte]])
    inline def apply(inline o: CFuncPtr2[GLenum, GLfloat, Unit]): PFNGLCONSERVATIVERASTERPARAMETERFNVPROC = o
    extension (v: PFNGLCONSERVATIVERASTERPARAMETERFNVPROC)
      inline def value: CFuncPtr2[GLenum, GLfloat, Unit] = v
      inline def toPtr: Ptr[?] = CFuncPtr.toPtr(v)

  opaque type PFNGLCONSERVATIVERASTERPARAMETERINVPROC = CFuncPtr2[GLenum, GLint, Unit]
  object PFNGLCONSERVATIVERASTERPARAMETERINVPROC:
    given _tag: Tag[PFNGLCONSERVATIVERASTERPARAMETERINVPROC] = Tag.materializeCFuncPtr2[GLenum, GLint, Unit]
    inline def fromPtr(ptr: Ptr[Byte] | Ptr[?]): PFNGLCONSERVATIVERASTERPARAMETERINVPROC = CFuncPtr.fromPtr(ptr.asInstanceOf[Ptr[Byte]])
    inline def apply(inline o: CFuncPtr2[GLenum, GLint, Unit]): PFNGLCONSERVATIVERASTERPARAMETERINVPROC = o
    extension (v: PFNGLCONSERVATIVERASTERPARAMETERINVPROC)
      inline def value: CFuncPtr2[GLenum, GLint, Unit] = v
      inline def toPtr: Ptr[?] = CFuncPtr.toPtr(v)

  opaque type PFNGLCONVOLUTIONFILTER1DEXTPROC = CFuncPtr6[GLenum, GLenum, GLsizei, GLenum, GLenum, Ptr[Byte], Unit]
  object PFNGLCONVOLUTIONFILTER1DEXTPROC:
    given _tag: Tag[PFNGLCONVOLUTIONFILTER1DEXTPROC] = Tag.materializeCFuncPtr6[GLenum, GLenum, GLsizei, GLenum, GLenum, Ptr[Byte], Unit]
    inline def fromPtr(ptr: Ptr[Byte] | Ptr[?]): PFNGLCONVOLUTIONFILTER1DEXTPROC = CFuncPtr.fromPtr(ptr.asInstanceOf[Ptr[Byte]])
    inline def apply(inline o: CFuncPtr6[GLenum, GLenum, GLsizei, GLenum, GLenum, Ptr[Byte], Unit]): PFNGLCONVOLUTIONFILTER1DEXTPROC = o
    extension (v: PFNGLCONVOLUTIONFILTER1DEXTPROC)
      inline def value: CFuncPtr6[GLenum, GLenum, GLsizei, GLenum, GLenum, Ptr[Byte], Unit] = v
      inline def toPtr: Ptr[?] = CFuncPtr.toPtr(v)

  opaque type PFNGLCONVOLUTIONFILTER1DPROC = CFuncPtr6[GLenum, GLenum, GLsizei, GLenum, GLenum, Ptr[Byte], Unit]
  object PFNGLCONVOLUTIONFILTER1DPROC:
    given _tag: Tag[PFNGLCONVOLUTIONFILTER1DPROC] = Tag.materializeCFuncPtr6[GLenum, GLenum, GLsizei, GLenum, GLenum, Ptr[Byte], Unit]
    inline def fromPtr(ptr: Ptr[Byte] | Ptr[?]): PFNGLCONVOLUTIONFILTER1DPROC = CFuncPtr.fromPtr(ptr.asInstanceOf[Ptr[Byte]])
    inline def apply(inline o: CFuncPtr6[GLenum, GLenum, GLsizei, GLenum, GLenum, Ptr[Byte], Unit]): PFNGLCONVOLUTIONFILTER1DPROC = o
    extension (v: PFNGLCONVOLUTIONFILTER1DPROC)
      inline def value: CFuncPtr6[GLenum, GLenum, GLsizei, GLenum, GLenum, Ptr[Byte], Unit] = v
      inline def toPtr: Ptr[?] = CFuncPtr.toPtr(v)

  opaque type PFNGLCONVOLUTIONFILTER2DEXTPROC = CFuncPtr7[GLenum, GLenum, GLsizei, GLsizei, GLenum, GLenum, Ptr[Byte], Unit]
  object PFNGLCONVOLUTIONFILTER2DEXTPROC:
    given _tag: Tag[PFNGLCONVOLUTIONFILTER2DEXTPROC] = Tag.materializeCFuncPtr7[GLenum, GLenum, GLsizei, GLsizei, GLenum, GLenum, Ptr[Byte], Unit]
    inline def fromPtr(ptr: Ptr[Byte] | Ptr[?]): PFNGLCONVOLUTIONFILTER2DEXTPROC = CFuncPtr.fromPtr(ptr.asInstanceOf[Ptr[Byte]])
    inline def apply(inline o: CFuncPtr7[GLenum, GLenum, GLsizei, GLsizei, GLenum, GLenum, Ptr[Byte], Unit]): PFNGLCONVOLUTIONFILTER2DEXTPROC = o
    extension (v: PFNGLCONVOLUTIONFILTER2DEXTPROC)
      inline def value: CFuncPtr7[GLenum, GLenum, GLsizei, GLsizei, GLenum, GLenum, Ptr[Byte], Unit] = v
      inline def toPtr: Ptr[?] = CFuncPtr.toPtr(v)

  opaque type PFNGLCONVOLUTIONFILTER2DPROC = CFuncPtr7[GLenum, GLenum, GLsizei, GLsizei, GLenum, GLenum, Ptr[Byte], Unit]
  object PFNGLCONVOLUTIONFILTER2DPROC:
    given _tag: Tag[PFNGLCONVOLUTIONFILTER2DPROC] = Tag.materializeCFuncPtr7[GLenum, GLenum, GLsizei, GLsizei, GLenum, GLenum, Ptr[Byte], Unit]
    inline def fromPtr(ptr: Ptr[Byte] | Ptr[?]): PFNGLCONVOLUTIONFILTER2DPROC = CFuncPtr.fromPtr(ptr.asInstanceOf[Ptr[Byte]])
    inline def apply(inline o: CFuncPtr7[GLenum, GLenum, GLsizei, GLsizei, GLenum, GLenum, Ptr[Byte], Unit]): PFNGLCONVOLUTIONFILTER2DPROC = o
    extension (v: PFNGLCONVOLUTIONFILTER2DPROC)
      inline def value: CFuncPtr7[GLenum, GLenum, GLsizei, GLsizei, GLenum, GLenum, Ptr[Byte], Unit] = v
      inline def toPtr: Ptr[?] = CFuncPtr.toPtr(v)

  opaque type PFNGLCONVOLUTIONPARAMETERFEXTPROC = CFuncPtr3[GLenum, GLenum, GLfloat, Unit]
  object PFNGLCONVOLUTIONPARAMETERFEXTPROC:
    given _tag: Tag[PFNGLCONVOLUTIONPARAMETERFEXTPROC] = Tag.materializeCFuncPtr3[GLenum, GLenum, GLfloat, Unit]
    inline def fromPtr(ptr: Ptr[Byte] | Ptr[?]): PFNGLCONVOLUTIONPARAMETERFEXTPROC = CFuncPtr.fromPtr(ptr.asInstanceOf[Ptr[Byte]])
    inline def apply(inline o: CFuncPtr3[GLenum, GLenum, GLfloat, Unit]): PFNGLCONVOLUTIONPARAMETERFEXTPROC = o
    extension (v: PFNGLCONVOLUTIONPARAMETERFEXTPROC)
      inline def value: CFuncPtr3[GLenum, GLenum, GLfloat, Unit] = v
      inline def toPtr: Ptr[?] = CFuncPtr.toPtr(v)

  opaque type PFNGLCONVOLUTIONPARAMETERFPROC = CFuncPtr3[GLenum, GLenum, GLfloat, Unit]
  object PFNGLCONVOLUTIONPARAMETERFPROC:
    given _tag: Tag[PFNGLCONVOLUTIONPARAMETERFPROC] = Tag.materializeCFuncPtr3[GLenum, GLenum, GLfloat, Unit]
    inline def fromPtr(ptr: Ptr[Byte] | Ptr[?]): PFNGLCONVOLUTIONPARAMETERFPROC = CFuncPtr.fromPtr(ptr.asInstanceOf[Ptr[Byte]])
    inline def apply(inline o: CFuncPtr3[GLenum, GLenum, GLfloat, Unit]): PFNGLCONVOLUTIONPARAMETERFPROC = o
    extension (v: PFNGLCONVOLUTIONPARAMETERFPROC)
      inline def value: CFuncPtr3[GLenum, GLenum, GLfloat, Unit] = v
      inline def toPtr: Ptr[?] = CFuncPtr.toPtr(v)

  opaque type PFNGLCONVOLUTIONPARAMETERFVEXTPROC = CFuncPtr3[GLenum, GLenum, Ptr[GLfloat], Unit]
  object PFNGLCONVOLUTIONPARAMETERFVEXTPROC:
    given _tag: Tag[PFNGLCONVOLUTIONPARAMETERFVEXTPROC] = Tag.materializeCFuncPtr3[GLenum, GLenum, Ptr[GLfloat], Unit]
    inline def fromPtr(ptr: Ptr[Byte] | Ptr[?]): PFNGLCONVOLUTIONPARAMETERFVEXTPROC = CFuncPtr.fromPtr(ptr.asInstanceOf[Ptr[Byte]])
    inline def apply(inline o: CFuncPtr3[GLenum, GLenum, Ptr[GLfloat], Unit]): PFNGLCONVOLUTIONPARAMETERFVEXTPROC = o
    extension (v: PFNGLCONVOLUTIONPARAMETERFVEXTPROC)
      inline def value: CFuncPtr3[GLenum, GLenum, Ptr[GLfloat], Unit] = v
      inline def toPtr: Ptr[?] = CFuncPtr.toPtr(v)

  opaque type PFNGLCONVOLUTIONPARAMETERFVPROC = CFuncPtr3[GLenum, GLenum, Ptr[GLfloat], Unit]
  object PFNGLCONVOLUTIONPARAMETERFVPROC:
    given _tag: Tag[PFNGLCONVOLUTIONPARAMETERFVPROC] = Tag.materializeCFuncPtr3[GLenum, GLenum, Ptr[GLfloat], Unit]
    inline def fromPtr(ptr: Ptr[Byte] | Ptr[?]): PFNGLCONVOLUTIONPARAMETERFVPROC = CFuncPtr.fromPtr(ptr.asInstanceOf[Ptr[Byte]])
    inline def apply(inline o: CFuncPtr3[GLenum, GLenum, Ptr[GLfloat], Unit]): PFNGLCONVOLUTIONPARAMETERFVPROC = o
    extension (v: PFNGLCONVOLUTIONPARAMETERFVPROC)
      inline def value: CFuncPtr3[GLenum, GLenum, Ptr[GLfloat], Unit] = v
      inline def toPtr: Ptr[?] = CFuncPtr.toPtr(v)

  opaque type PFNGLCONVOLUTIONPARAMETERIEXTPROC = CFuncPtr3[GLenum, GLenum, GLint, Unit]
  object PFNGLCONVOLUTIONPARAMETERIEXTPROC:
    given _tag: Tag[PFNGLCONVOLUTIONPARAMETERIEXTPROC] = Tag.materializeCFuncPtr3[GLenum, GLenum, GLint, Unit]
    inline def fromPtr(ptr: Ptr[Byte] | Ptr[?]): PFNGLCONVOLUTIONPARAMETERIEXTPROC = CFuncPtr.fromPtr(ptr.asInstanceOf[Ptr[Byte]])
    inline def apply(inline o: CFuncPtr3[GLenum, GLenum, GLint, Unit]): PFNGLCONVOLUTIONPARAMETERIEXTPROC = o
    extension (v: PFNGLCONVOLUTIONPARAMETERIEXTPROC)
      inline def value: CFuncPtr3[GLenum, GLenum, GLint, Unit] = v
      inline def toPtr: Ptr[?] = CFuncPtr.toPtr(v)

  opaque type PFNGLCONVOLUTIONPARAMETERIPROC = CFuncPtr3[GLenum, GLenum, GLint, Unit]
  object PFNGLCONVOLUTIONPARAMETERIPROC:
    given _tag: Tag[PFNGLCONVOLUTIONPARAMETERIPROC] = Tag.materializeCFuncPtr3[GLenum, GLenum, GLint, Unit]
    inline def fromPtr(ptr: Ptr[Byte] | Ptr[?]): PFNGLCONVOLUTIONPARAMETERIPROC = CFuncPtr.fromPtr(ptr.asInstanceOf[Ptr[Byte]])
    inline def apply(inline o: CFuncPtr3[GLenum, GLenum, GLint, Unit]): PFNGLCONVOLUTIONPARAMETERIPROC = o
    extension (v: PFNGLCONVOLUTIONPARAMETERIPROC)
      inline def value: CFuncPtr3[GLenum, GLenum, GLint, Unit] = v
      inline def toPtr: Ptr[?] = CFuncPtr.toPtr(v)

  opaque type PFNGLCONVOLUTIONPARAMETERIVEXTPROC = CFuncPtr3[GLenum, GLenum, Ptr[GLint], Unit]
  object PFNGLCONVOLUTIONPARAMETERIVEXTPROC:
    given _tag: Tag[PFNGLCONVOLUTIONPARAMETERIVEXTPROC] = Tag.materializeCFuncPtr3[GLenum, GLenum, Ptr[GLint], Unit]
    inline def fromPtr(ptr: Ptr[Byte] | Ptr[?]): PFNGLCONVOLUTIONPARAMETERIVEXTPROC = CFuncPtr.fromPtr(ptr.asInstanceOf[Ptr[Byte]])
    inline def apply(inline o: CFuncPtr3[GLenum, GLenum, Ptr[GLint], Unit]): PFNGLCONVOLUTIONPARAMETERIVEXTPROC = o
    extension (v: PFNGLCONVOLUTIONPARAMETERIVEXTPROC)
      inline def value: CFuncPtr3[GLenum, GLenum, Ptr[GLint], Unit] = v
      inline def toPtr: Ptr[?] = CFuncPtr.toPtr(v)

  opaque type PFNGLCONVOLUTIONPARAMETERIVPROC = CFuncPtr3[GLenum, GLenum, Ptr[GLint], Unit]
  object PFNGLCONVOLUTIONPARAMETERIVPROC:
    given _tag: Tag[PFNGLCONVOLUTIONPARAMETERIVPROC] = Tag.materializeCFuncPtr3[GLenum, GLenum, Ptr[GLint], Unit]
    inline def fromPtr(ptr: Ptr[Byte] | Ptr[?]): PFNGLCONVOLUTIONPARAMETERIVPROC = CFuncPtr.fromPtr(ptr.asInstanceOf[Ptr[Byte]])
    inline def apply(inline o: CFuncPtr3[GLenum, GLenum, Ptr[GLint], Unit]): PFNGLCONVOLUTIONPARAMETERIVPROC = o
    extension (v: PFNGLCONVOLUTIONPARAMETERIVPROC)
      inline def value: CFuncPtr3[GLenum, GLenum, Ptr[GLint], Unit] = v
      inline def toPtr: Ptr[?] = CFuncPtr.toPtr(v)

  opaque type PFNGLCOPYBUFFERSUBDATANVPROC = CFuncPtr5[GLenum, GLenum, GLintptr, GLintptr, GLsizeiptr, Unit]
  object PFNGLCOPYBUFFERSUBDATANVPROC:
    given _tag: Tag[PFNGLCOPYBUFFERSUBDATANVPROC] = Tag.materializeCFuncPtr5[GLenum, GLenum, GLintptr, GLintptr, GLsizeiptr, Unit]
    inline def fromPtr(ptr: Ptr[Byte] | Ptr[?]): PFNGLCOPYBUFFERSUBDATANVPROC = CFuncPtr.fromPtr(ptr.asInstanceOf[Ptr[Byte]])
    inline def apply(inline o: CFuncPtr5[GLenum, GLenum, GLintptr, GLintptr, GLsizeiptr, Unit]): PFNGLCOPYBUFFERSUBDATANVPROC = o
    extension (v: PFNGLCOPYBUFFERSUBDATANVPROC)
      inline def value: CFuncPtr5[GLenum, GLenum, GLintptr, GLintptr, GLsizeiptr, Unit] = v
      inline def toPtr: Ptr[?] = CFuncPtr.toPtr(v)

  opaque type PFNGLCOPYBUFFERSUBDATAPROC = CFuncPtr5[GLenum, GLenum, GLintptr, GLintptr, GLsizeiptr, Unit]
  object PFNGLCOPYBUFFERSUBDATAPROC:
    given _tag: Tag[PFNGLCOPYBUFFERSUBDATAPROC] = Tag.materializeCFuncPtr5[GLenum, GLenum, GLintptr, GLintptr, GLsizeiptr, Unit]
    inline def fromPtr(ptr: Ptr[Byte] | Ptr[?]): PFNGLCOPYBUFFERSUBDATAPROC = CFuncPtr.fromPtr(ptr.asInstanceOf[Ptr[Byte]])
    inline def apply(inline o: CFuncPtr5[GLenum, GLenum, GLintptr, GLintptr, GLsizeiptr, Unit]): PFNGLCOPYBUFFERSUBDATAPROC = o
    extension (v: PFNGLCOPYBUFFERSUBDATAPROC)
      inline def value: CFuncPtr5[GLenum, GLenum, GLintptr, GLintptr, GLsizeiptr, Unit] = v
      inline def toPtr: Ptr[?] = CFuncPtr.toPtr(v)

  opaque type PFNGLCOPYCOLORSUBTABLEEXTPROC = CFuncPtr5[GLenum, GLsizei, GLint, GLint, GLsizei, Unit]
  object PFNGLCOPYCOLORSUBTABLEEXTPROC:
    given _tag: Tag[PFNGLCOPYCOLORSUBTABLEEXTPROC] = Tag.materializeCFuncPtr5[GLenum, GLsizei, GLint, GLint, GLsizei, Unit]
    inline def fromPtr(ptr: Ptr[Byte] | Ptr[?]): PFNGLCOPYCOLORSUBTABLEEXTPROC = CFuncPtr.fromPtr(ptr.asInstanceOf[Ptr[Byte]])
    inline def apply(inline o: CFuncPtr5[GLenum, GLsizei, GLint, GLint, GLsizei, Unit]): PFNGLCOPYCOLORSUBTABLEEXTPROC = o
    extension (v: PFNGLCOPYCOLORSUBTABLEEXTPROC)
      inline def value: CFuncPtr5[GLenum, GLsizei, GLint, GLint, GLsizei, Unit] = v
      inline def toPtr: Ptr[?] = CFuncPtr.toPtr(v)

  opaque type PFNGLCOPYCOLORSUBTABLEPROC = CFuncPtr5[GLenum, GLsizei, GLint, GLint, GLsizei, Unit]
  object PFNGLCOPYCOLORSUBTABLEPROC:
    given _tag: Tag[PFNGLCOPYCOLORSUBTABLEPROC] = Tag.materializeCFuncPtr5[GLenum, GLsizei, GLint, GLint, GLsizei, Unit]
    inline def fromPtr(ptr: Ptr[Byte] | Ptr[?]): PFNGLCOPYCOLORSUBTABLEPROC = CFuncPtr.fromPtr(ptr.asInstanceOf[Ptr[Byte]])
    inline def apply(inline o: CFuncPtr5[GLenum, GLsizei, GLint, GLint, GLsizei, Unit]): PFNGLCOPYCOLORSUBTABLEPROC = o
    extension (v: PFNGLCOPYCOLORSUBTABLEPROC)
      inline def value: CFuncPtr5[GLenum, GLsizei, GLint, GLint, GLsizei, Unit] = v
      inline def toPtr: Ptr[?] = CFuncPtr.toPtr(v)

  opaque type PFNGLCOPYCOLORTABLEPROC = CFuncPtr5[GLenum, GLenum, GLint, GLint, GLsizei, Unit]
  object PFNGLCOPYCOLORTABLEPROC:
    given _tag: Tag[PFNGLCOPYCOLORTABLEPROC] = Tag.materializeCFuncPtr5[GLenum, GLenum, GLint, GLint, GLsizei, Unit]
    inline def fromPtr(ptr: Ptr[Byte] | Ptr[?]): PFNGLCOPYCOLORTABLEPROC = CFuncPtr.fromPtr(ptr.asInstanceOf[Ptr[Byte]])
    inline def apply(inline o: CFuncPtr5[GLenum, GLenum, GLint, GLint, GLsizei, Unit]): PFNGLCOPYCOLORTABLEPROC = o
    extension (v: PFNGLCOPYCOLORTABLEPROC)
      inline def value: CFuncPtr5[GLenum, GLenum, GLint, GLint, GLsizei, Unit] = v
      inline def toPtr: Ptr[?] = CFuncPtr.toPtr(v)

  opaque type PFNGLCOPYCOLORTABLESGIPROC = CFuncPtr5[GLenum, GLenum, GLint, GLint, GLsizei, Unit]
  object PFNGLCOPYCOLORTABLESGIPROC:
    given _tag: Tag[PFNGLCOPYCOLORTABLESGIPROC] = Tag.materializeCFuncPtr5[GLenum, GLenum, GLint, GLint, GLsizei, Unit]
    inline def fromPtr(ptr: Ptr[Byte] | Ptr[?]): PFNGLCOPYCOLORTABLESGIPROC = CFuncPtr.fromPtr(ptr.asInstanceOf[Ptr[Byte]])
    inline def apply(inline o: CFuncPtr5[GLenum, GLenum, GLint, GLint, GLsizei, Unit]): PFNGLCOPYCOLORTABLESGIPROC = o
    extension (v: PFNGLCOPYCOLORTABLESGIPROC)
      inline def value: CFuncPtr5[GLenum, GLenum, GLint, GLint, GLsizei, Unit] = v
      inline def toPtr: Ptr[?] = CFuncPtr.toPtr(v)

  opaque type PFNGLCOPYCONVOLUTIONFILTER1DEXTPROC = CFuncPtr5[GLenum, GLenum, GLint, GLint, GLsizei, Unit]
  object PFNGLCOPYCONVOLUTIONFILTER1DEXTPROC:
    given _tag: Tag[PFNGLCOPYCONVOLUTIONFILTER1DEXTPROC] = Tag.materializeCFuncPtr5[GLenum, GLenum, GLint, GLint, GLsizei, Unit]
    inline def fromPtr(ptr: Ptr[Byte] | Ptr[?]): PFNGLCOPYCONVOLUTIONFILTER1DEXTPROC = CFuncPtr.fromPtr(ptr.asInstanceOf[Ptr[Byte]])
    inline def apply(inline o: CFuncPtr5[GLenum, GLenum, GLint, GLint, GLsizei, Unit]): PFNGLCOPYCONVOLUTIONFILTER1DEXTPROC = o
    extension (v: PFNGLCOPYCONVOLUTIONFILTER1DEXTPROC)
      inline def value: CFuncPtr5[GLenum, GLenum, GLint, GLint, GLsizei, Unit] = v
      inline def toPtr: Ptr[?] = CFuncPtr.toPtr(v)

  opaque type PFNGLCOPYCONVOLUTIONFILTER1DPROC = CFuncPtr5[GLenum, GLenum, GLint, GLint, GLsizei, Unit]
  object PFNGLCOPYCONVOLUTIONFILTER1DPROC:
    given _tag: Tag[PFNGLCOPYCONVOLUTIONFILTER1DPROC] = Tag.materializeCFuncPtr5[GLenum, GLenum, GLint, GLint, GLsizei, Unit]
    inline def fromPtr(ptr: Ptr[Byte] | Ptr[?]): PFNGLCOPYCONVOLUTIONFILTER1DPROC = CFuncPtr.fromPtr(ptr.asInstanceOf[Ptr[Byte]])
    inline def apply(inline o: CFuncPtr5[GLenum, GLenum, GLint, GLint, GLsizei, Unit]): PFNGLCOPYCONVOLUTIONFILTER1DPROC = o
    extension (v: PFNGLCOPYCONVOLUTIONFILTER1DPROC)
      inline def value: CFuncPtr5[GLenum, GLenum, GLint, GLint, GLsizei, Unit] = v
      inline def toPtr: Ptr[?] = CFuncPtr.toPtr(v)

  opaque type PFNGLCOPYCONVOLUTIONFILTER2DEXTPROC = CFuncPtr6[GLenum, GLenum, GLint, GLint, GLsizei, GLsizei, Unit]
  object PFNGLCOPYCONVOLUTIONFILTER2DEXTPROC:
    given _tag: Tag[PFNGLCOPYCONVOLUTIONFILTER2DEXTPROC] = Tag.materializeCFuncPtr6[GLenum, GLenum, GLint, GLint, GLsizei, GLsizei, Unit]
    inline def fromPtr(ptr: Ptr[Byte] | Ptr[?]): PFNGLCOPYCONVOLUTIONFILTER2DEXTPROC = CFuncPtr.fromPtr(ptr.asInstanceOf[Ptr[Byte]])
    inline def apply(inline o: CFuncPtr6[GLenum, GLenum, GLint, GLint, GLsizei, GLsizei, Unit]): PFNGLCOPYCONVOLUTIONFILTER2DEXTPROC = o
    extension (v: PFNGLCOPYCONVOLUTIONFILTER2DEXTPROC)
      inline def value: CFuncPtr6[GLenum, GLenum, GLint, GLint, GLsizei, GLsizei, Unit] = v
      inline def toPtr: Ptr[?] = CFuncPtr.toPtr(v)

  opaque type PFNGLCOPYCONVOLUTIONFILTER2DPROC = CFuncPtr6[GLenum, GLenum, GLint, GLint, GLsizei, GLsizei, Unit]
  object PFNGLCOPYCONVOLUTIONFILTER2DPROC:
    given _tag: Tag[PFNGLCOPYCONVOLUTIONFILTER2DPROC] = Tag.materializeCFuncPtr6[GLenum, GLenum, GLint, GLint, GLsizei, GLsizei, Unit]
    inline def fromPtr(ptr: Ptr[Byte] | Ptr[?]): PFNGLCOPYCONVOLUTIONFILTER2DPROC = CFuncPtr.fromPtr(ptr.asInstanceOf[Ptr[Byte]])
    inline def apply(inline o: CFuncPtr6[GLenum, GLenum, GLint, GLint, GLsizei, GLsizei, Unit]): PFNGLCOPYCONVOLUTIONFILTER2DPROC = o
    extension (v: PFNGLCOPYCONVOLUTIONFILTER2DPROC)
      inline def value: CFuncPtr6[GLenum, GLenum, GLint, GLint, GLsizei, GLsizei, Unit] = v
      inline def toPtr: Ptr[?] = CFuncPtr.toPtr(v)

  opaque type PFNGLCOPYIMAGESUBDATAEXTPROC = CFuncPtr15[GLuint, GLenum, GLint, GLint, GLint, GLint, GLuint, GLenum, GLint, GLint, GLint, GLint, GLsizei, GLsizei, GLsizei, Unit]
  object PFNGLCOPYIMAGESUBDATAEXTPROC:
    given _tag: Tag[PFNGLCOPYIMAGESUBDATAEXTPROC] = Tag.materializeCFuncPtr15[GLuint, GLenum, GLint, GLint, GLint, GLint, GLuint, GLenum, GLint, GLint, GLint, GLint, GLsizei, GLsizei, GLsizei, Unit]
    inline def fromPtr(ptr: Ptr[Byte] | Ptr[?]): PFNGLCOPYIMAGESUBDATAEXTPROC = CFuncPtr.fromPtr(ptr.asInstanceOf[Ptr[Byte]])
    inline def apply(inline o: CFuncPtr15[GLuint, GLenum, GLint, GLint, GLint, GLint, GLuint, GLenum, GLint, GLint, GLint, GLint, GLsizei, GLsizei, GLsizei, Unit]): PFNGLCOPYIMAGESUBDATAEXTPROC = o
    extension (v: PFNGLCOPYIMAGESUBDATAEXTPROC)
      inline def value: CFuncPtr15[GLuint, GLenum, GLint, GLint, GLint, GLint, GLuint, GLenum, GLint, GLint, GLint, GLint, GLsizei, GLsizei, GLsizei, Unit] = v
      inline def toPtr: Ptr[?] = CFuncPtr.toPtr(v)

  opaque type PFNGLCOPYIMAGESUBDATANVPROC = CFuncPtr15[GLuint, GLenum, GLint, GLint, GLint, GLint, GLuint, GLenum, GLint, GLint, GLint, GLint, GLsizei, GLsizei, GLsizei, Unit]
  object PFNGLCOPYIMAGESUBDATANVPROC:
    given _tag: Tag[PFNGLCOPYIMAGESUBDATANVPROC] = Tag.materializeCFuncPtr15[GLuint, GLenum, GLint, GLint, GLint, GLint, GLuint, GLenum, GLint, GLint, GLint, GLint, GLsizei, GLsizei, GLsizei, Unit]
    inline def fromPtr(ptr: Ptr[Byte] | Ptr[?]): PFNGLCOPYIMAGESUBDATANVPROC = CFuncPtr.fromPtr(ptr.asInstanceOf[Ptr[Byte]])
    inline def apply(inline o: CFuncPtr15[GLuint, GLenum, GLint, GLint, GLint, GLint, GLuint, GLenum, GLint, GLint, GLint, GLint, GLsizei, GLsizei, GLsizei, Unit]): PFNGLCOPYIMAGESUBDATANVPROC = o
    extension (v: PFNGLCOPYIMAGESUBDATANVPROC)
      inline def value: CFuncPtr15[GLuint, GLenum, GLint, GLint, GLint, GLint, GLuint, GLenum, GLint, GLint, GLint, GLint, GLsizei, GLsizei, GLsizei, Unit] = v
      inline def toPtr: Ptr[?] = CFuncPtr.toPtr(v)

  opaque type PFNGLCOPYIMAGESUBDATAOESPROC = CFuncPtr15[GLuint, GLenum, GLint, GLint, GLint, GLint, GLuint, GLenum, GLint, GLint, GLint, GLint, GLsizei, GLsizei, GLsizei, Unit]
  object PFNGLCOPYIMAGESUBDATAOESPROC:
    given _tag: Tag[PFNGLCOPYIMAGESUBDATAOESPROC] = Tag.materializeCFuncPtr15[GLuint, GLenum, GLint, GLint, GLint, GLint, GLuint, GLenum, GLint, GLint, GLint, GLint, GLsizei, GLsizei, GLsizei, Unit]
    inline def fromPtr(ptr: Ptr[Byte] | Ptr[?]): PFNGLCOPYIMAGESUBDATAOESPROC = CFuncPtr.fromPtr(ptr.asInstanceOf[Ptr[Byte]])
    inline def apply(inline o: CFuncPtr15[GLuint, GLenum, GLint, GLint, GLint, GLint, GLuint, GLenum, GLint, GLint, GLint, GLint, GLsizei, GLsizei, GLsizei, Unit]): PFNGLCOPYIMAGESUBDATAOESPROC = o
    extension (v: PFNGLCOPYIMAGESUBDATAOESPROC)
      inline def value: CFuncPtr15[GLuint, GLenum, GLint, GLint, GLint, GLint, GLuint, GLenum, GLint, GLint, GLint, GLint, GLsizei, GLsizei, GLsizei, Unit] = v
      inline def toPtr: Ptr[?] = CFuncPtr.toPtr(v)

  opaque type PFNGLCOPYIMAGESUBDATAPROC = CFuncPtr15[GLuint, GLenum, GLint, GLint, GLint, GLint, GLuint, GLenum, GLint, GLint, GLint, GLint, GLsizei, GLsizei, GLsizei, Unit]
  object PFNGLCOPYIMAGESUBDATAPROC:
    given _tag: Tag[PFNGLCOPYIMAGESUBDATAPROC] = Tag.materializeCFuncPtr15[GLuint, GLenum, GLint, GLint, GLint, GLint, GLuint, GLenum, GLint, GLint, GLint, GLint, GLsizei, GLsizei, GLsizei, Unit]
    inline def fromPtr(ptr: Ptr[Byte] | Ptr[?]): PFNGLCOPYIMAGESUBDATAPROC = CFuncPtr.fromPtr(ptr.asInstanceOf[Ptr[Byte]])
    inline def apply(inline o: CFuncPtr15[GLuint, GLenum, GLint, GLint, GLint, GLint, GLuint, GLenum, GLint, GLint, GLint, GLint, GLsizei, GLsizei, GLsizei, Unit]): PFNGLCOPYIMAGESUBDATAPROC = o
    extension (v: PFNGLCOPYIMAGESUBDATAPROC)
      inline def value: CFuncPtr15[GLuint, GLenum, GLint, GLint, GLint, GLint, GLuint, GLenum, GLint, GLint, GLint, GLint, GLsizei, GLsizei, GLsizei, Unit] = v
      inline def toPtr: Ptr[?] = CFuncPtr.toPtr(v)

  opaque type PFNGLCOPYMULTITEXIMAGE1DEXTPROC = CFuncPtr8[GLenum, GLenum, GLint, GLenum, GLint, GLint, GLsizei, GLint, Unit]
  object PFNGLCOPYMULTITEXIMAGE1DEXTPROC:
    given _tag: Tag[PFNGLCOPYMULTITEXIMAGE1DEXTPROC] = Tag.materializeCFuncPtr8[GLenum, GLenum, GLint, GLenum, GLint, GLint, GLsizei, GLint, Unit]
    inline def fromPtr(ptr: Ptr[Byte] | Ptr[?]): PFNGLCOPYMULTITEXIMAGE1DEXTPROC = CFuncPtr.fromPtr(ptr.asInstanceOf[Ptr[Byte]])
    inline def apply(inline o: CFuncPtr8[GLenum, GLenum, GLint, GLenum, GLint, GLint, GLsizei, GLint, Unit]): PFNGLCOPYMULTITEXIMAGE1DEXTPROC = o
    extension (v: PFNGLCOPYMULTITEXIMAGE1DEXTPROC)
      inline def value: CFuncPtr8[GLenum, GLenum, GLint, GLenum, GLint, GLint, GLsizei, GLint, Unit] = v
      inline def toPtr: Ptr[?] = CFuncPtr.toPtr(v)

  opaque type PFNGLCOPYMULTITEXIMAGE2DEXTPROC = CFuncPtr9[GLenum, GLenum, GLint, GLenum, GLint, GLint, GLsizei, GLsizei, GLint, Unit]
  object PFNGLCOPYMULTITEXIMAGE2DEXTPROC:
    given _tag: Tag[PFNGLCOPYMULTITEXIMAGE2DEXTPROC] = Tag.materializeCFuncPtr9[GLenum, GLenum, GLint, GLenum, GLint, GLint, GLsizei, GLsizei, GLint, Unit]
    inline def fromPtr(ptr: Ptr[Byte] | Ptr[?]): PFNGLCOPYMULTITEXIMAGE2DEXTPROC = CFuncPtr.fromPtr(ptr.asInstanceOf[Ptr[Byte]])
    inline def apply(inline o: CFuncPtr9[GLenum, GLenum, GLint, GLenum, GLint, GLint, GLsizei, GLsizei, GLint, Unit]): PFNGLCOPYMULTITEXIMAGE2DEXTPROC = o
    extension (v: PFNGLCOPYMULTITEXIMAGE2DEXTPROC)
      inline def value: CFuncPtr9[GLenum, GLenum, GLint, GLenum, GLint, GLint, GLsizei, GLsizei, GLint, Unit] = v
      inline def toPtr: Ptr[?] = CFuncPtr.toPtr(v)

  opaque type PFNGLCOPYMULTITEXSUBIMAGE1DEXTPROC = CFuncPtr7[GLenum, GLenum, GLint, GLint, GLint, GLint, GLsizei, Unit]
  object PFNGLCOPYMULTITEXSUBIMAGE1DEXTPROC:
    given _tag: Tag[PFNGLCOPYMULTITEXSUBIMAGE1DEXTPROC] = Tag.materializeCFuncPtr7[GLenum, GLenum, GLint, GLint, GLint, GLint, GLsizei, Unit]
    inline def fromPtr(ptr: Ptr[Byte] | Ptr[?]): PFNGLCOPYMULTITEXSUBIMAGE1DEXTPROC = CFuncPtr.fromPtr(ptr.asInstanceOf[Ptr[Byte]])
    inline def apply(inline o: CFuncPtr7[GLenum, GLenum, GLint, GLint, GLint, GLint, GLsizei, Unit]): PFNGLCOPYMULTITEXSUBIMAGE1DEXTPROC = o
    extension (v: PFNGLCOPYMULTITEXSUBIMAGE1DEXTPROC)
      inline def value: CFuncPtr7[GLenum, GLenum, GLint, GLint, GLint, GLint, GLsizei, Unit] = v
      inline def toPtr: Ptr[?] = CFuncPtr.toPtr(v)

  opaque type PFNGLCOPYMULTITEXSUBIMAGE2DEXTPROC = CFuncPtr9[GLenum, GLenum, GLint, GLint, GLint, GLint, GLint, GLsizei, GLsizei, Unit]
  object PFNGLCOPYMULTITEXSUBIMAGE2DEXTPROC:
    given _tag: Tag[PFNGLCOPYMULTITEXSUBIMAGE2DEXTPROC] = Tag.materializeCFuncPtr9[GLenum, GLenum, GLint, GLint, GLint, GLint, GLint, GLsizei, GLsizei, Unit]
    inline def fromPtr(ptr: Ptr[Byte] | Ptr[?]): PFNGLCOPYMULTITEXSUBIMAGE2DEXTPROC = CFuncPtr.fromPtr(ptr.asInstanceOf[Ptr[Byte]])
    inline def apply(inline o: CFuncPtr9[GLenum, GLenum, GLint, GLint, GLint, GLint, GLint, GLsizei, GLsizei, Unit]): PFNGLCOPYMULTITEXSUBIMAGE2DEXTPROC = o
    extension (v: PFNGLCOPYMULTITEXSUBIMAGE2DEXTPROC)
      inline def value: CFuncPtr9[GLenum, GLenum, GLint, GLint, GLint, GLint, GLint, GLsizei, GLsizei, Unit] = v
      inline def toPtr: Ptr[?] = CFuncPtr.toPtr(v)

  opaque type PFNGLCOPYMULTITEXSUBIMAGE3DEXTPROC = CFuncPtr10[GLenum, GLenum, GLint, GLint, GLint, GLint, GLint, GLint, GLsizei, GLsizei, Unit]
  object PFNGLCOPYMULTITEXSUBIMAGE3DEXTPROC:
    given _tag: Tag[PFNGLCOPYMULTITEXSUBIMAGE3DEXTPROC] = Tag.materializeCFuncPtr10[GLenum, GLenum, GLint, GLint, GLint, GLint, GLint, GLint, GLsizei, GLsizei, Unit]
    inline def fromPtr(ptr: Ptr[Byte] | Ptr[?]): PFNGLCOPYMULTITEXSUBIMAGE3DEXTPROC = CFuncPtr.fromPtr(ptr.asInstanceOf[Ptr[Byte]])
    inline def apply(inline o: CFuncPtr10[GLenum, GLenum, GLint, GLint, GLint, GLint, GLint, GLint, GLsizei, GLsizei, Unit]): PFNGLCOPYMULTITEXSUBIMAGE3DEXTPROC = o
    extension (v: PFNGLCOPYMULTITEXSUBIMAGE3DEXTPROC)
      inline def value: CFuncPtr10[GLenum, GLenum, GLint, GLint, GLint, GLint, GLint, GLint, GLsizei, GLsizei, Unit] = v
      inline def toPtr: Ptr[?] = CFuncPtr.toPtr(v)

  opaque type PFNGLCOPYNAMEDBUFFERSUBDATAPROC = CFuncPtr5[GLuint, GLuint, GLintptr, GLintptr, GLsizeiptr, Unit]
  object PFNGLCOPYNAMEDBUFFERSUBDATAPROC:
    given _tag: Tag[PFNGLCOPYNAMEDBUFFERSUBDATAPROC] = Tag.materializeCFuncPtr5[GLuint, GLuint, GLintptr, GLintptr, GLsizeiptr, Unit]
    inline def fromPtr(ptr: Ptr[Byte] | Ptr[?]): PFNGLCOPYNAMEDBUFFERSUBDATAPROC = CFuncPtr.fromPtr(ptr.asInstanceOf[Ptr[Byte]])
    inline def apply(inline o: CFuncPtr5[GLuint, GLuint, GLintptr, GLintptr, GLsizeiptr, Unit]): PFNGLCOPYNAMEDBUFFERSUBDATAPROC = o
    extension (v: PFNGLCOPYNAMEDBUFFERSUBDATAPROC)
      inline def value: CFuncPtr5[GLuint, GLuint, GLintptr, GLintptr, GLsizeiptr, Unit] = v
      inline def toPtr: Ptr[?] = CFuncPtr.toPtr(v)

  opaque type PFNGLCOPYPATHNVPROC = CFuncPtr2[GLuint, GLuint, Unit]
  object PFNGLCOPYPATHNVPROC:
    given _tag: Tag[PFNGLCOPYPATHNVPROC] = Tag.materializeCFuncPtr2[GLuint, GLuint, Unit]
    inline def fromPtr(ptr: Ptr[Byte] | Ptr[?]): PFNGLCOPYPATHNVPROC = CFuncPtr.fromPtr(ptr.asInstanceOf[Ptr[Byte]])
    inline def apply(inline o: CFuncPtr2[GLuint, GLuint, Unit]): PFNGLCOPYPATHNVPROC = o
    extension (v: PFNGLCOPYPATHNVPROC)
      inline def value: CFuncPtr2[GLuint, GLuint, Unit] = v
      inline def toPtr: Ptr[?] = CFuncPtr.toPtr(v)

  opaque type PFNGLCOPYTEXIMAGE1DEXTPROC = CFuncPtr7[GLenum, GLint, GLenum, GLint, GLint, GLsizei, GLint, Unit]
  object PFNGLCOPYTEXIMAGE1DEXTPROC:
    given _tag: Tag[PFNGLCOPYTEXIMAGE1DEXTPROC] = Tag.materializeCFuncPtr7[GLenum, GLint, GLenum, GLint, GLint, GLsizei, GLint, Unit]
    inline def fromPtr(ptr: Ptr[Byte] | Ptr[?]): PFNGLCOPYTEXIMAGE1DEXTPROC = CFuncPtr.fromPtr(ptr.asInstanceOf[Ptr[Byte]])
    inline def apply(inline o: CFuncPtr7[GLenum, GLint, GLenum, GLint, GLint, GLsizei, GLint, Unit]): PFNGLCOPYTEXIMAGE1DEXTPROC = o
    extension (v: PFNGLCOPYTEXIMAGE1DEXTPROC)
      inline def value: CFuncPtr7[GLenum, GLint, GLenum, GLint, GLint, GLsizei, GLint, Unit] = v
      inline def toPtr: Ptr[?] = CFuncPtr.toPtr(v)

  opaque type PFNGLCOPYTEXIMAGE2DEXTPROC = CFuncPtr8[GLenum, GLint, GLenum, GLint, GLint, GLsizei, GLsizei, GLint, Unit]
  object PFNGLCOPYTEXIMAGE2DEXTPROC:
    given _tag: Tag[PFNGLCOPYTEXIMAGE2DEXTPROC] = Tag.materializeCFuncPtr8[GLenum, GLint, GLenum, GLint, GLint, GLsizei, GLsizei, GLint, Unit]
    inline def fromPtr(ptr: Ptr[Byte] | Ptr[?]): PFNGLCOPYTEXIMAGE2DEXTPROC = CFuncPtr.fromPtr(ptr.asInstanceOf[Ptr[Byte]])
    inline def apply(inline o: CFuncPtr8[GLenum, GLint, GLenum, GLint, GLint, GLsizei, GLsizei, GLint, Unit]): PFNGLCOPYTEXIMAGE2DEXTPROC = o
    extension (v: PFNGLCOPYTEXIMAGE2DEXTPROC)
      inline def value: CFuncPtr8[GLenum, GLint, GLenum, GLint, GLint, GLsizei, GLsizei, GLint, Unit] = v
      inline def toPtr: Ptr[?] = CFuncPtr.toPtr(v)

  opaque type PFNGLCOPYTEXSUBIMAGE1DEXTPROC = CFuncPtr6[GLenum, GLint, GLint, GLint, GLint, GLsizei, Unit]
  object PFNGLCOPYTEXSUBIMAGE1DEXTPROC:
    given _tag: Tag[PFNGLCOPYTEXSUBIMAGE1DEXTPROC] = Tag.materializeCFuncPtr6[GLenum, GLint, GLint, GLint, GLint, GLsizei, Unit]
    inline def fromPtr(ptr: Ptr[Byte] | Ptr[?]): PFNGLCOPYTEXSUBIMAGE1DEXTPROC = CFuncPtr.fromPtr(ptr.asInstanceOf[Ptr[Byte]])
    inline def apply(inline o: CFuncPtr6[GLenum, GLint, GLint, GLint, GLint, GLsizei, Unit]): PFNGLCOPYTEXSUBIMAGE1DEXTPROC = o
    extension (v: PFNGLCOPYTEXSUBIMAGE1DEXTPROC)
      inline def value: CFuncPtr6[GLenum, GLint, GLint, GLint, GLint, GLsizei, Unit] = v
      inline def toPtr: Ptr[?] = CFuncPtr.toPtr(v)

  opaque type PFNGLCOPYTEXSUBIMAGE2DEXTPROC = CFuncPtr8[GLenum, GLint, GLint, GLint, GLint, GLint, GLsizei, GLsizei, Unit]
  object PFNGLCOPYTEXSUBIMAGE2DEXTPROC:
    given _tag: Tag[PFNGLCOPYTEXSUBIMAGE2DEXTPROC] = Tag.materializeCFuncPtr8[GLenum, GLint, GLint, GLint, GLint, GLint, GLsizei, GLsizei, Unit]
    inline def fromPtr(ptr: Ptr[Byte] | Ptr[?]): PFNGLCOPYTEXSUBIMAGE2DEXTPROC = CFuncPtr.fromPtr(ptr.asInstanceOf[Ptr[Byte]])
    inline def apply(inline o: CFuncPtr8[GLenum, GLint, GLint, GLint, GLint, GLint, GLsizei, GLsizei, Unit]): PFNGLCOPYTEXSUBIMAGE2DEXTPROC = o
    extension (v: PFNGLCOPYTEXSUBIMAGE2DEXTPROC)
      inline def value: CFuncPtr8[GLenum, GLint, GLint, GLint, GLint, GLint, GLsizei, GLsizei, Unit] = v
      inline def toPtr: Ptr[?] = CFuncPtr.toPtr(v)

  opaque type PFNGLCOPYTEXSUBIMAGE3DEXTPROC = CFuncPtr9[GLenum, GLint, GLint, GLint, GLint, GLint, GLint, GLsizei, GLsizei, Unit]
  object PFNGLCOPYTEXSUBIMAGE3DEXTPROC:
    given _tag: Tag[PFNGLCOPYTEXSUBIMAGE3DEXTPROC] = Tag.materializeCFuncPtr9[GLenum, GLint, GLint, GLint, GLint, GLint, GLint, GLsizei, GLsizei, Unit]
    inline def fromPtr(ptr: Ptr[Byte] | Ptr[?]): PFNGLCOPYTEXSUBIMAGE3DEXTPROC = CFuncPtr.fromPtr(ptr.asInstanceOf[Ptr[Byte]])
    inline def apply(inline o: CFuncPtr9[GLenum, GLint, GLint, GLint, GLint, GLint, GLint, GLsizei, GLsizei, Unit]): PFNGLCOPYTEXSUBIMAGE3DEXTPROC = o
    extension (v: PFNGLCOPYTEXSUBIMAGE3DEXTPROC)
      inline def value: CFuncPtr9[GLenum, GLint, GLint, GLint, GLint, GLint, GLint, GLsizei, GLsizei, Unit] = v
      inline def toPtr: Ptr[?] = CFuncPtr.toPtr(v)

  opaque type PFNGLCOPYTEXSUBIMAGE3DNVPROC = CFuncPtr9[GLenum, GLint, GLint, GLint, GLint, GLint, GLint, GLsizei, GLsizei, Unit]
  object PFNGLCOPYTEXSUBIMAGE3DNVPROC:
    given _tag: Tag[PFNGLCOPYTEXSUBIMAGE3DNVPROC] = Tag.materializeCFuncPtr9[GLenum, GLint, GLint, GLint, GLint, GLint, GLint, GLsizei, GLsizei, Unit]
    inline def fromPtr(ptr: Ptr[Byte] | Ptr[?]): PFNGLCOPYTEXSUBIMAGE3DNVPROC = CFuncPtr.fromPtr(ptr.asInstanceOf[Ptr[Byte]])
    inline def apply(inline o: CFuncPtr9[GLenum, GLint, GLint, GLint, GLint, GLint, GLint, GLsizei, GLsizei, Unit]): PFNGLCOPYTEXSUBIMAGE3DNVPROC = o
    extension (v: PFNGLCOPYTEXSUBIMAGE3DNVPROC)
      inline def value: CFuncPtr9[GLenum, GLint, GLint, GLint, GLint, GLint, GLint, GLsizei, GLsizei, Unit] = v
      inline def toPtr: Ptr[?] = CFuncPtr.toPtr(v)

  opaque type PFNGLCOPYTEXSUBIMAGE3DOESPROC = CFuncPtr9[GLenum, GLint, GLint, GLint, GLint, GLint, GLint, GLsizei, GLsizei, Unit]
  object PFNGLCOPYTEXSUBIMAGE3DOESPROC:
    given _tag: Tag[PFNGLCOPYTEXSUBIMAGE3DOESPROC] = Tag.materializeCFuncPtr9[GLenum, GLint, GLint, GLint, GLint, GLint, GLint, GLsizei, GLsizei, Unit]
    inline def fromPtr(ptr: Ptr[Byte] | Ptr[?]): PFNGLCOPYTEXSUBIMAGE3DOESPROC = CFuncPtr.fromPtr(ptr.asInstanceOf[Ptr[Byte]])
    inline def apply(inline o: CFuncPtr9[GLenum, GLint, GLint, GLint, GLint, GLint, GLint, GLsizei, GLsizei, Unit]): PFNGLCOPYTEXSUBIMAGE3DOESPROC = o
    extension (v: PFNGLCOPYTEXSUBIMAGE3DOESPROC)
      inline def value: CFuncPtr9[GLenum, GLint, GLint, GLint, GLint, GLint, GLint, GLsizei, GLsizei, Unit] = v
      inline def toPtr: Ptr[?] = CFuncPtr.toPtr(v)

  opaque type PFNGLCOPYTEXSUBIMAGE3DPROC = CFuncPtr9[GLenum, GLint, GLint, GLint, GLint, GLint, GLint, GLsizei, GLsizei, Unit]
  object PFNGLCOPYTEXSUBIMAGE3DPROC:
    given _tag: Tag[PFNGLCOPYTEXSUBIMAGE3DPROC] = Tag.materializeCFuncPtr9[GLenum, GLint, GLint, GLint, GLint, GLint, GLint, GLsizei, GLsizei, Unit]
    inline def fromPtr(ptr: Ptr[Byte] | Ptr[?]): PFNGLCOPYTEXSUBIMAGE3DPROC = CFuncPtr.fromPtr(ptr.asInstanceOf[Ptr[Byte]])
    inline def apply(inline o: CFuncPtr9[GLenum, GLint, GLint, GLint, GLint, GLint, GLint, GLsizei, GLsizei, Unit]): PFNGLCOPYTEXSUBIMAGE3DPROC = o
    extension (v: PFNGLCOPYTEXSUBIMAGE3DPROC)
      inline def value: CFuncPtr9[GLenum, GLint, GLint, GLint, GLint, GLint, GLint, GLsizei, GLsizei, Unit] = v
      inline def toPtr: Ptr[?] = CFuncPtr.toPtr(v)

  opaque type PFNGLCOPYTEXTUREIMAGE1DEXTPROC = CFuncPtr8[GLuint, GLenum, GLint, GLenum, GLint, GLint, GLsizei, GLint, Unit]
  object PFNGLCOPYTEXTUREIMAGE1DEXTPROC:
    given _tag: Tag[PFNGLCOPYTEXTUREIMAGE1DEXTPROC] = Tag.materializeCFuncPtr8[GLuint, GLenum, GLint, GLenum, GLint, GLint, GLsizei, GLint, Unit]
    inline def fromPtr(ptr: Ptr[Byte] | Ptr[?]): PFNGLCOPYTEXTUREIMAGE1DEXTPROC = CFuncPtr.fromPtr(ptr.asInstanceOf[Ptr[Byte]])
    inline def apply(inline o: CFuncPtr8[GLuint, GLenum, GLint, GLenum, GLint, GLint, GLsizei, GLint, Unit]): PFNGLCOPYTEXTUREIMAGE1DEXTPROC = o
    extension (v: PFNGLCOPYTEXTUREIMAGE1DEXTPROC)
      inline def value: CFuncPtr8[GLuint, GLenum, GLint, GLenum, GLint, GLint, GLsizei, GLint, Unit] = v
      inline def toPtr: Ptr[?] = CFuncPtr.toPtr(v)

  opaque type PFNGLCOPYTEXTUREIMAGE2DEXTPROC = CFuncPtr9[GLuint, GLenum, GLint, GLenum, GLint, GLint, GLsizei, GLsizei, GLint, Unit]
  object PFNGLCOPYTEXTUREIMAGE2DEXTPROC:
    given _tag: Tag[PFNGLCOPYTEXTUREIMAGE2DEXTPROC] = Tag.materializeCFuncPtr9[GLuint, GLenum, GLint, GLenum, GLint, GLint, GLsizei, GLsizei, GLint, Unit]
    inline def fromPtr(ptr: Ptr[Byte] | Ptr[?]): PFNGLCOPYTEXTUREIMAGE2DEXTPROC = CFuncPtr.fromPtr(ptr.asInstanceOf[Ptr[Byte]])
    inline def apply(inline o: CFuncPtr9[GLuint, GLenum, GLint, GLenum, GLint, GLint, GLsizei, GLsizei, GLint, Unit]): PFNGLCOPYTEXTUREIMAGE2DEXTPROC = o
    extension (v: PFNGLCOPYTEXTUREIMAGE2DEXTPROC)
      inline def value: CFuncPtr9[GLuint, GLenum, GLint, GLenum, GLint, GLint, GLsizei, GLsizei, GLint, Unit] = v
      inline def toPtr: Ptr[?] = CFuncPtr.toPtr(v)

  opaque type PFNGLCOPYTEXTURELEVELSAPPLEPROC = CFuncPtr4[GLuint, GLuint, GLint, GLsizei, Unit]
  object PFNGLCOPYTEXTURELEVELSAPPLEPROC:
    given _tag: Tag[PFNGLCOPYTEXTURELEVELSAPPLEPROC] = Tag.materializeCFuncPtr4[GLuint, GLuint, GLint, GLsizei, Unit]
    inline def fromPtr(ptr: Ptr[Byte] | Ptr[?]): PFNGLCOPYTEXTURELEVELSAPPLEPROC = CFuncPtr.fromPtr(ptr.asInstanceOf[Ptr[Byte]])
    inline def apply(inline o: CFuncPtr4[GLuint, GLuint, GLint, GLsizei, Unit]): PFNGLCOPYTEXTURELEVELSAPPLEPROC = o
    extension (v: PFNGLCOPYTEXTURELEVELSAPPLEPROC)
      inline def value: CFuncPtr4[GLuint, GLuint, GLint, GLsizei, Unit] = v
      inline def toPtr: Ptr[?] = CFuncPtr.toPtr(v)

  opaque type PFNGLCOPYTEXTURESUBIMAGE1DEXTPROC = CFuncPtr7[GLuint, GLenum, GLint, GLint, GLint, GLint, GLsizei, Unit]
  object PFNGLCOPYTEXTURESUBIMAGE1DEXTPROC:
    given _tag: Tag[PFNGLCOPYTEXTURESUBIMAGE1DEXTPROC] = Tag.materializeCFuncPtr7[GLuint, GLenum, GLint, GLint, GLint, GLint, GLsizei, Unit]
    inline def fromPtr(ptr: Ptr[Byte] | Ptr[?]): PFNGLCOPYTEXTURESUBIMAGE1DEXTPROC = CFuncPtr.fromPtr(ptr.asInstanceOf[Ptr[Byte]])
    inline def apply(inline o: CFuncPtr7[GLuint, GLenum, GLint, GLint, GLint, GLint, GLsizei, Unit]): PFNGLCOPYTEXTURESUBIMAGE1DEXTPROC = o
    extension (v: PFNGLCOPYTEXTURESUBIMAGE1DEXTPROC)
      inline def value: CFuncPtr7[GLuint, GLenum, GLint, GLint, GLint, GLint, GLsizei, Unit] = v
      inline def toPtr: Ptr[?] = CFuncPtr.toPtr(v)

  opaque type PFNGLCOPYTEXTURESUBIMAGE1DPROC = CFuncPtr6[GLuint, GLint, GLint, GLint, GLint, GLsizei, Unit]
  object PFNGLCOPYTEXTURESUBIMAGE1DPROC:
    given _tag: Tag[PFNGLCOPYTEXTURESUBIMAGE1DPROC] = Tag.materializeCFuncPtr6[GLuint, GLint, GLint, GLint, GLint, GLsizei, Unit]
    inline def fromPtr(ptr: Ptr[Byte] | Ptr[?]): PFNGLCOPYTEXTURESUBIMAGE1DPROC = CFuncPtr.fromPtr(ptr.asInstanceOf[Ptr[Byte]])
    inline def apply(inline o: CFuncPtr6[GLuint, GLint, GLint, GLint, GLint, GLsizei, Unit]): PFNGLCOPYTEXTURESUBIMAGE1DPROC = o
    extension (v: PFNGLCOPYTEXTURESUBIMAGE1DPROC)
      inline def value: CFuncPtr6[GLuint, GLint, GLint, GLint, GLint, GLsizei, Unit] = v
      inline def toPtr: Ptr[?] = CFuncPtr.toPtr(v)

  opaque type PFNGLCOPYTEXTURESUBIMAGE2DEXTPROC = CFuncPtr9[GLuint, GLenum, GLint, GLint, GLint, GLint, GLint, GLsizei, GLsizei, Unit]
  object PFNGLCOPYTEXTURESUBIMAGE2DEXTPROC:
    given _tag: Tag[PFNGLCOPYTEXTURESUBIMAGE2DEXTPROC] = Tag.materializeCFuncPtr9[GLuint, GLenum, GLint, GLint, GLint, GLint, GLint, GLsizei, GLsizei, Unit]
    inline def fromPtr(ptr: Ptr[Byte] | Ptr[?]): PFNGLCOPYTEXTURESUBIMAGE2DEXTPROC = CFuncPtr.fromPtr(ptr.asInstanceOf[Ptr[Byte]])
    inline def apply(inline o: CFuncPtr9[GLuint, GLenum, GLint, GLint, GLint, GLint, GLint, GLsizei, GLsizei, Unit]): PFNGLCOPYTEXTURESUBIMAGE2DEXTPROC = o
    extension (v: PFNGLCOPYTEXTURESUBIMAGE2DEXTPROC)
      inline def value: CFuncPtr9[GLuint, GLenum, GLint, GLint, GLint, GLint, GLint, GLsizei, GLsizei, Unit] = v
      inline def toPtr: Ptr[?] = CFuncPtr.toPtr(v)

  opaque type PFNGLCOPYTEXTURESUBIMAGE2DPROC = CFuncPtr8[GLuint, GLint, GLint, GLint, GLint, GLint, GLsizei, GLsizei, Unit]
  object PFNGLCOPYTEXTURESUBIMAGE2DPROC:
    given _tag: Tag[PFNGLCOPYTEXTURESUBIMAGE2DPROC] = Tag.materializeCFuncPtr8[GLuint, GLint, GLint, GLint, GLint, GLint, GLsizei, GLsizei, Unit]
    inline def fromPtr(ptr: Ptr[Byte] | Ptr[?]): PFNGLCOPYTEXTURESUBIMAGE2DPROC = CFuncPtr.fromPtr(ptr.asInstanceOf[Ptr[Byte]])
    inline def apply(inline o: CFuncPtr8[GLuint, GLint, GLint, GLint, GLint, GLint, GLsizei, GLsizei, Unit]): PFNGLCOPYTEXTURESUBIMAGE2DPROC = o
    extension (v: PFNGLCOPYTEXTURESUBIMAGE2DPROC)
      inline def value: CFuncPtr8[GLuint, GLint, GLint, GLint, GLint, GLint, GLsizei, GLsizei, Unit] = v
      inline def toPtr: Ptr[?] = CFuncPtr.toPtr(v)

  opaque type PFNGLCOPYTEXTURESUBIMAGE3DEXTPROC = CFuncPtr10[GLuint, GLenum, GLint, GLint, GLint, GLint, GLint, GLint, GLsizei, GLsizei, Unit]
  object PFNGLCOPYTEXTURESUBIMAGE3DEXTPROC:
    given _tag: Tag[PFNGLCOPYTEXTURESUBIMAGE3DEXTPROC] = Tag.materializeCFuncPtr10[GLuint, GLenum, GLint, GLint, GLint, GLint, GLint, GLint, GLsizei, GLsizei, Unit]
    inline def fromPtr(ptr: Ptr[Byte] | Ptr[?]): PFNGLCOPYTEXTURESUBIMAGE3DEXTPROC = CFuncPtr.fromPtr(ptr.asInstanceOf[Ptr[Byte]])
    inline def apply(inline o: CFuncPtr10[GLuint, GLenum, GLint, GLint, GLint, GLint, GLint, GLint, GLsizei, GLsizei, Unit]): PFNGLCOPYTEXTURESUBIMAGE3DEXTPROC = o
    extension (v: PFNGLCOPYTEXTURESUBIMAGE3DEXTPROC)
      inline def value: CFuncPtr10[GLuint, GLenum, GLint, GLint, GLint, GLint, GLint, GLint, GLsizei, GLsizei, Unit] = v
      inline def toPtr: Ptr[?] = CFuncPtr.toPtr(v)

  opaque type PFNGLCOPYTEXTURESUBIMAGE3DPROC = CFuncPtr9[GLuint, GLint, GLint, GLint, GLint, GLint, GLint, GLsizei, GLsizei, Unit]
  object PFNGLCOPYTEXTURESUBIMAGE3DPROC:
    given _tag: Tag[PFNGLCOPYTEXTURESUBIMAGE3DPROC] = Tag.materializeCFuncPtr9[GLuint, GLint, GLint, GLint, GLint, GLint, GLint, GLsizei, GLsizei, Unit]
    inline def fromPtr(ptr: Ptr[Byte] | Ptr[?]): PFNGLCOPYTEXTURESUBIMAGE3DPROC = CFuncPtr.fromPtr(ptr.asInstanceOf[Ptr[Byte]])
    inline def apply(inline o: CFuncPtr9[GLuint, GLint, GLint, GLint, GLint, GLint, GLint, GLsizei, GLsizei, Unit]): PFNGLCOPYTEXTURESUBIMAGE3DPROC = o
    extension (v: PFNGLCOPYTEXTURESUBIMAGE3DPROC)
      inline def value: CFuncPtr9[GLuint, GLint, GLint, GLint, GLint, GLint, GLint, GLsizei, GLsizei, Unit] = v
      inline def toPtr: Ptr[?] = CFuncPtr.toPtr(v)

  opaque type PFNGLCOVERAGEMODULATIONNVPROC = CFuncPtr1[GLenum, Unit]
  object PFNGLCOVERAGEMODULATIONNVPROC:
    given _tag: Tag[PFNGLCOVERAGEMODULATIONNVPROC] = Tag.materializeCFuncPtr1[GLenum, Unit]
    inline def fromPtr(ptr: Ptr[Byte] | Ptr[?]): PFNGLCOVERAGEMODULATIONNVPROC = CFuncPtr.fromPtr(ptr.asInstanceOf[Ptr[Byte]])
    inline def apply(inline o: CFuncPtr1[GLenum, Unit]): PFNGLCOVERAGEMODULATIONNVPROC = o
    extension (v: PFNGLCOVERAGEMODULATIONNVPROC)
      inline def value: CFuncPtr1[GLenum, Unit] = v
      inline def toPtr: Ptr[?] = CFuncPtr.toPtr(v)

  opaque type PFNGLCOVERAGEMODULATIONTABLENVPROC = CFuncPtr2[GLsizei, Ptr[GLfloat], Unit]
  object PFNGLCOVERAGEMODULATIONTABLENVPROC:
    given _tag: Tag[PFNGLCOVERAGEMODULATIONTABLENVPROC] = Tag.materializeCFuncPtr2[GLsizei, Ptr[GLfloat], Unit]
    inline def fromPtr(ptr: Ptr[Byte] | Ptr[?]): PFNGLCOVERAGEMODULATIONTABLENVPROC = CFuncPtr.fromPtr(ptr.asInstanceOf[Ptr[Byte]])
    inline def apply(inline o: CFuncPtr2[GLsizei, Ptr[GLfloat], Unit]): PFNGLCOVERAGEMODULATIONTABLENVPROC = o
    extension (v: PFNGLCOVERAGEMODULATIONTABLENVPROC)
      inline def value: CFuncPtr2[GLsizei, Ptr[GLfloat], Unit] = v
      inline def toPtr: Ptr[?] = CFuncPtr.toPtr(v)

  opaque type PFNGLCOVERFILLPATHINSTANCEDNVPROC = CFuncPtr7[GLsizei, GLenum, Ptr[Byte], GLuint, GLenum, GLenum, Ptr[GLfloat], Unit]
  object PFNGLCOVERFILLPATHINSTANCEDNVPROC:
    given _tag: Tag[PFNGLCOVERFILLPATHINSTANCEDNVPROC] = Tag.materializeCFuncPtr7[GLsizei, GLenum, Ptr[Byte], GLuint, GLenum, GLenum, Ptr[GLfloat], Unit]
    inline def fromPtr(ptr: Ptr[Byte] | Ptr[?]): PFNGLCOVERFILLPATHINSTANCEDNVPROC = CFuncPtr.fromPtr(ptr.asInstanceOf[Ptr[Byte]])
    inline def apply(inline o: CFuncPtr7[GLsizei, GLenum, Ptr[Byte], GLuint, GLenum, GLenum, Ptr[GLfloat], Unit]): PFNGLCOVERFILLPATHINSTANCEDNVPROC = o
    extension (v: PFNGLCOVERFILLPATHINSTANCEDNVPROC)
      inline def value: CFuncPtr7[GLsizei, GLenum, Ptr[Byte], GLuint, GLenum, GLenum, Ptr[GLfloat], Unit] = v
      inline def toPtr: Ptr[?] = CFuncPtr.toPtr(v)

  opaque type PFNGLCOVERFILLPATHNVPROC = CFuncPtr2[GLuint, GLenum, Unit]
  object PFNGLCOVERFILLPATHNVPROC:
    given _tag: Tag[PFNGLCOVERFILLPATHNVPROC] = Tag.materializeCFuncPtr2[GLuint, GLenum, Unit]
    inline def fromPtr(ptr: Ptr[Byte] | Ptr[?]): PFNGLCOVERFILLPATHNVPROC = CFuncPtr.fromPtr(ptr.asInstanceOf[Ptr[Byte]])
    inline def apply(inline o: CFuncPtr2[GLuint, GLenum, Unit]): PFNGLCOVERFILLPATHNVPROC = o
    extension (v: PFNGLCOVERFILLPATHNVPROC)
      inline def value: CFuncPtr2[GLuint, GLenum, Unit] = v
      inline def toPtr: Ptr[?] = CFuncPtr.toPtr(v)

  opaque type PFNGLCOVERSTROKEPATHINSTANCEDNVPROC = CFuncPtr7[GLsizei, GLenum, Ptr[Byte], GLuint, GLenum, GLenum, Ptr[GLfloat], Unit]
  object PFNGLCOVERSTROKEPATHINSTANCEDNVPROC:
    given _tag: Tag[PFNGLCOVERSTROKEPATHINSTANCEDNVPROC] = Tag.materializeCFuncPtr7[GLsizei, GLenum, Ptr[Byte], GLuint, GLenum, GLenum, Ptr[GLfloat], Unit]
    inline def fromPtr(ptr: Ptr[Byte] | Ptr[?]): PFNGLCOVERSTROKEPATHINSTANCEDNVPROC = CFuncPtr.fromPtr(ptr.asInstanceOf[Ptr[Byte]])
    inline def apply(inline o: CFuncPtr7[GLsizei, GLenum, Ptr[Byte], GLuint, GLenum, GLenum, Ptr[GLfloat], Unit]): PFNGLCOVERSTROKEPATHINSTANCEDNVPROC = o
    extension (v: PFNGLCOVERSTROKEPATHINSTANCEDNVPROC)
      inline def value: CFuncPtr7[GLsizei, GLenum, Ptr[Byte], GLuint, GLenum, GLenum, Ptr[GLfloat], Unit] = v
      inline def toPtr: Ptr[?] = CFuncPtr.toPtr(v)

  opaque type PFNGLCOVERSTROKEPATHNVPROC = CFuncPtr2[GLuint, GLenum, Unit]
  object PFNGLCOVERSTROKEPATHNVPROC:
    given _tag: Tag[PFNGLCOVERSTROKEPATHNVPROC] = Tag.materializeCFuncPtr2[GLuint, GLenum, Unit]
    inline def fromPtr(ptr: Ptr[Byte] | Ptr[?]): PFNGLCOVERSTROKEPATHNVPROC = CFuncPtr.fromPtr(ptr.asInstanceOf[Ptr[Byte]])
    inline def apply(inline o: CFuncPtr2[GLuint, GLenum, Unit]): PFNGLCOVERSTROKEPATHNVPROC = o
    extension (v: PFNGLCOVERSTROKEPATHNVPROC)
      inline def value: CFuncPtr2[GLuint, GLenum, Unit] = v
      inline def toPtr: Ptr[?] = CFuncPtr.toPtr(v)

  opaque type PFNGLCREATEARRAYSETEXTPROC = CFuncPtr0[Ptr[Byte]]
  object PFNGLCREATEARRAYSETEXTPROC:
    given _tag: Tag[PFNGLCREATEARRAYSETEXTPROC] = Tag.materializeCFuncPtr0[Ptr[Byte]]
    inline def fromPtr(ptr: Ptr[Byte] | Ptr[?]): PFNGLCREATEARRAYSETEXTPROC = CFuncPtr.fromPtr(ptr.asInstanceOf[Ptr[Byte]])
    inline def apply(inline o: CFuncPtr0[Ptr[Byte]]): PFNGLCREATEARRAYSETEXTPROC = o
    extension (v: PFNGLCREATEARRAYSETEXTPROC)
      inline def value: CFuncPtr0[Ptr[Byte]] = v
      inline def toPtr: Ptr[?] = CFuncPtr.toPtr(v)

  opaque type PFNGLCREATEBUFFERSPROC = CFuncPtr2[GLsizei, Ptr[GLuint], Unit]
  object PFNGLCREATEBUFFERSPROC:
    given _tag: Tag[PFNGLCREATEBUFFERSPROC] = Tag.materializeCFuncPtr2[GLsizei, Ptr[GLuint], Unit]
    inline def fromPtr(ptr: Ptr[Byte] | Ptr[?]): PFNGLCREATEBUFFERSPROC = CFuncPtr.fromPtr(ptr.asInstanceOf[Ptr[Byte]])
    inline def apply(inline o: CFuncPtr2[GLsizei, Ptr[GLuint], Unit]): PFNGLCREATEBUFFERSPROC = o
    extension (v: PFNGLCREATEBUFFERSPROC)
      inline def value: CFuncPtr2[GLsizei, Ptr[GLuint], Unit] = v
      inline def toPtr: Ptr[?] = CFuncPtr.toPtr(v)

  opaque type PFNGLCREATECOMMANDLISTSNVPROC = CFuncPtr2[GLsizei, Ptr[GLuint], Unit]
  object PFNGLCREATECOMMANDLISTSNVPROC:
    given _tag: Tag[PFNGLCREATECOMMANDLISTSNVPROC] = Tag.materializeCFuncPtr2[GLsizei, Ptr[GLuint], Unit]
    inline def fromPtr(ptr: Ptr[Byte] | Ptr[?]): PFNGLCREATECOMMANDLISTSNVPROC = CFuncPtr.fromPtr(ptr.asInstanceOf[Ptr[Byte]])
    inline def apply(inline o: CFuncPtr2[GLsizei, Ptr[GLuint], Unit]): PFNGLCREATECOMMANDLISTSNVPROC = o
    extension (v: PFNGLCREATECOMMANDLISTSNVPROC)
      inline def value: CFuncPtr2[GLsizei, Ptr[GLuint], Unit] = v
      inline def toPtr: Ptr[?] = CFuncPtr.toPtr(v)

  opaque type PFNGLCREATEFRAMEBUFFERSPROC = CFuncPtr2[GLsizei, Ptr[GLuint], Unit]
  object PFNGLCREATEFRAMEBUFFERSPROC:
    given _tag: Tag[PFNGLCREATEFRAMEBUFFERSPROC] = Tag.materializeCFuncPtr2[GLsizei, Ptr[GLuint], Unit]
    inline def fromPtr(ptr: Ptr[Byte] | Ptr[?]): PFNGLCREATEFRAMEBUFFERSPROC = CFuncPtr.fromPtr(ptr.asInstanceOf[Ptr[Byte]])
    inline def apply(inline o: CFuncPtr2[GLsizei, Ptr[GLuint], Unit]): PFNGLCREATEFRAMEBUFFERSPROC = o
    extension (v: PFNGLCREATEFRAMEBUFFERSPROC)
      inline def value: CFuncPtr2[GLsizei, Ptr[GLuint], Unit] = v
      inline def toPtr: Ptr[?] = CFuncPtr.toPtr(v)

  opaque type PFNGLCREATEMEMORYOBJECTSEXTPROC = CFuncPtr2[GLsizei, Ptr[GLuint], Unit]
  object PFNGLCREATEMEMORYOBJECTSEXTPROC:
    given _tag: Tag[PFNGLCREATEMEMORYOBJECTSEXTPROC] = Tag.materializeCFuncPtr2[GLsizei, Ptr[GLuint], Unit]
    inline def fromPtr(ptr: Ptr[Byte] | Ptr[?]): PFNGLCREATEMEMORYOBJECTSEXTPROC = CFuncPtr.fromPtr(ptr.asInstanceOf[Ptr[Byte]])
    inline def apply(inline o: CFuncPtr2[GLsizei, Ptr[GLuint], Unit]): PFNGLCREATEMEMORYOBJECTSEXTPROC = o
    extension (v: PFNGLCREATEMEMORYOBJECTSEXTPROC)
      inline def value: CFuncPtr2[GLsizei, Ptr[GLuint], Unit] = v
      inline def toPtr: Ptr[?] = CFuncPtr.toPtr(v)

  opaque type PFNGLCREATEPERFQUERYINTELPROC = CFuncPtr2[GLuint, Ptr[GLuint], Unit]
  object PFNGLCREATEPERFQUERYINTELPROC:
    given _tag: Tag[PFNGLCREATEPERFQUERYINTELPROC] = Tag.materializeCFuncPtr2[GLuint, Ptr[GLuint], Unit]
    inline def fromPtr(ptr: Ptr[Byte] | Ptr[?]): PFNGLCREATEPERFQUERYINTELPROC = CFuncPtr.fromPtr(ptr.asInstanceOf[Ptr[Byte]])
    inline def apply(inline o: CFuncPtr2[GLuint, Ptr[GLuint], Unit]): PFNGLCREATEPERFQUERYINTELPROC = o
    extension (v: PFNGLCREATEPERFQUERYINTELPROC)
      inline def value: CFuncPtr2[GLuint, Ptr[GLuint], Unit] = v
      inline def toPtr: Ptr[?] = CFuncPtr.toPtr(v)

  opaque type PFNGLCREATEPROGRAMOBJECTARBPROC = CFuncPtr0[GLhandleARB]
  object PFNGLCREATEPROGRAMOBJECTARBPROC:
    given _tag: Tag[PFNGLCREATEPROGRAMOBJECTARBPROC] = Tag.materializeCFuncPtr0[GLhandleARB]
    inline def fromPtr(ptr: Ptr[Byte] | Ptr[?]): PFNGLCREATEPROGRAMOBJECTARBPROC = CFuncPtr.fromPtr(ptr.asInstanceOf[Ptr[Byte]])
    inline def apply(inline o: CFuncPtr0[GLhandleARB]): PFNGLCREATEPROGRAMOBJECTARBPROC = o
    extension (v: PFNGLCREATEPROGRAMOBJECTARBPROC)
      inline def value: CFuncPtr0[GLhandleARB] = v
      inline def toPtr: Ptr[?] = CFuncPtr.toPtr(v)

  opaque type PFNGLCREATEPROGRAMPIPELINESPROC = CFuncPtr2[GLsizei, Ptr[GLuint], Unit]
  object PFNGLCREATEPROGRAMPIPELINESPROC:
    given _tag: Tag[PFNGLCREATEPROGRAMPIPELINESPROC] = Tag.materializeCFuncPtr2[GLsizei, Ptr[GLuint], Unit]
    inline def fromPtr(ptr: Ptr[Byte] | Ptr[?]): PFNGLCREATEPROGRAMPIPELINESPROC = CFuncPtr.fromPtr(ptr.asInstanceOf[Ptr[Byte]])
    inline def apply(inline o: CFuncPtr2[GLsizei, Ptr[GLuint], Unit]): PFNGLCREATEPROGRAMPIPELINESPROC = o
    extension (v: PFNGLCREATEPROGRAMPIPELINESPROC)
      inline def value: CFuncPtr2[GLsizei, Ptr[GLuint], Unit] = v
      inline def toPtr: Ptr[?] = CFuncPtr.toPtr(v)

  opaque type PFNGLCREATEPROGRAMPROC = CFuncPtr0[GLuint]
  object PFNGLCREATEPROGRAMPROC:
    given _tag: Tag[PFNGLCREATEPROGRAMPROC] = Tag.materializeCFuncPtr0[GLuint]
    inline def fromPtr(ptr: Ptr[Byte] | Ptr[?]): PFNGLCREATEPROGRAMPROC = CFuncPtr.fromPtr(ptr.asInstanceOf[Ptr[Byte]])
    inline def apply(inline o: CFuncPtr0[GLuint]): PFNGLCREATEPROGRAMPROC = o
    extension (v: PFNGLCREATEPROGRAMPROC)
      inline def value: CFuncPtr0[GLuint] = v
      inline def toPtr: Ptr[?] = CFuncPtr.toPtr(v)

  opaque type PFNGLCREATEQUERIESPROC = CFuncPtr3[GLenum, GLsizei, Ptr[GLuint], Unit]
  object PFNGLCREATEQUERIESPROC:
    given _tag: Tag[PFNGLCREATEQUERIESPROC] = Tag.materializeCFuncPtr3[GLenum, GLsizei, Ptr[GLuint], Unit]
    inline def fromPtr(ptr: Ptr[Byte] | Ptr[?]): PFNGLCREATEQUERIESPROC = CFuncPtr.fromPtr(ptr.asInstanceOf[Ptr[Byte]])
    inline def apply(inline o: CFuncPtr3[GLenum, GLsizei, Ptr[GLuint], Unit]): PFNGLCREATEQUERIESPROC = o
    extension (v: PFNGLCREATEQUERIESPROC)
      inline def value: CFuncPtr3[GLenum, GLsizei, Ptr[GLuint], Unit] = v
      inline def toPtr: Ptr[?] = CFuncPtr.toPtr(v)

  opaque type PFNGLCREATERENDERBUFFERSPROC = CFuncPtr2[GLsizei, Ptr[GLuint], Unit]
  object PFNGLCREATERENDERBUFFERSPROC:
    given _tag: Tag[PFNGLCREATERENDERBUFFERSPROC] = Tag.materializeCFuncPtr2[GLsizei, Ptr[GLuint], Unit]
    inline def fromPtr(ptr: Ptr[Byte] | Ptr[?]): PFNGLCREATERENDERBUFFERSPROC = CFuncPtr.fromPtr(ptr.asInstanceOf[Ptr[Byte]])
    inline def apply(inline o: CFuncPtr2[GLsizei, Ptr[GLuint], Unit]): PFNGLCREATERENDERBUFFERSPROC = o
    extension (v: PFNGLCREATERENDERBUFFERSPROC)
      inline def value: CFuncPtr2[GLsizei, Ptr[GLuint], Unit] = v
      inline def toPtr: Ptr[?] = CFuncPtr.toPtr(v)

  opaque type PFNGLCREATESAMPLERSPROC = CFuncPtr2[GLsizei, Ptr[GLuint], Unit]
  object PFNGLCREATESAMPLERSPROC:
    given _tag: Tag[PFNGLCREATESAMPLERSPROC] = Tag.materializeCFuncPtr2[GLsizei, Ptr[GLuint], Unit]
    inline def fromPtr(ptr: Ptr[Byte] | Ptr[?]): PFNGLCREATESAMPLERSPROC = CFuncPtr.fromPtr(ptr.asInstanceOf[Ptr[Byte]])
    inline def apply(inline o: CFuncPtr2[GLsizei, Ptr[GLuint], Unit]): PFNGLCREATESAMPLERSPROC = o
    extension (v: PFNGLCREATESAMPLERSPROC)
      inline def value: CFuncPtr2[GLsizei, Ptr[GLuint], Unit] = v
      inline def toPtr: Ptr[?] = CFuncPtr.toPtr(v)

  opaque type PFNGLCREATESHADEROBJECTARBPROC = CFuncPtr1[GLenum, GLhandleARB]
  object PFNGLCREATESHADEROBJECTARBPROC:
    given _tag: Tag[PFNGLCREATESHADEROBJECTARBPROC] = Tag.materializeCFuncPtr1[GLenum, GLhandleARB]
    inline def fromPtr(ptr: Ptr[Byte] | Ptr[?]): PFNGLCREATESHADEROBJECTARBPROC = CFuncPtr.fromPtr(ptr.asInstanceOf[Ptr[Byte]])
    inline def apply(inline o: CFuncPtr1[GLenum, GLhandleARB]): PFNGLCREATESHADEROBJECTARBPROC = o
    extension (v: PFNGLCREATESHADEROBJECTARBPROC)
      inline def value: CFuncPtr1[GLenum, GLhandleARB] = v
      inline def toPtr: Ptr[?] = CFuncPtr.toPtr(v)

  opaque type PFNGLCREATESHADERPROC = CFuncPtr1[GLenum, GLuint]
  object PFNGLCREATESHADERPROC:
    given _tag: Tag[PFNGLCREATESHADERPROC] = Tag.materializeCFuncPtr1[GLenum, GLuint]
    inline def fromPtr(ptr: Ptr[Byte] | Ptr[?]): PFNGLCREATESHADERPROC = CFuncPtr.fromPtr(ptr.asInstanceOf[Ptr[Byte]])
    inline def apply(inline o: CFuncPtr1[GLenum, GLuint]): PFNGLCREATESHADERPROC = o
    extension (v: PFNGLCREATESHADERPROC)
      inline def value: CFuncPtr1[GLenum, GLuint] = v
      inline def toPtr: Ptr[?] = CFuncPtr.toPtr(v)

  opaque type PFNGLCREATESHADERPROGRAMEXTPROC = CFuncPtr2[GLenum, Ptr[GLchar], GLuint]
  object PFNGLCREATESHADERPROGRAMEXTPROC:
    given _tag: Tag[PFNGLCREATESHADERPROGRAMEXTPROC] = Tag.materializeCFuncPtr2[GLenum, Ptr[GLchar], GLuint]
    inline def fromPtr(ptr: Ptr[Byte] | Ptr[?]): PFNGLCREATESHADERPROGRAMEXTPROC = CFuncPtr.fromPtr(ptr.asInstanceOf[Ptr[Byte]])
    inline def apply(inline o: CFuncPtr2[GLenum, Ptr[GLchar], GLuint]): PFNGLCREATESHADERPROGRAMEXTPROC = o
    extension (v: PFNGLCREATESHADERPROGRAMEXTPROC)
      inline def value: CFuncPtr2[GLenum, Ptr[GLchar], GLuint] = v
      inline def toPtr: Ptr[?] = CFuncPtr.toPtr(v)

  opaque type PFNGLCREATESHADERPROGRAMVPROC = CFuncPtr3[GLenum, GLsizei, Ptr[Ptr[GLchar]], GLuint]
  object PFNGLCREATESHADERPROGRAMVPROC:
    given _tag: Tag[PFNGLCREATESHADERPROGRAMVPROC] = Tag.materializeCFuncPtr3[GLenum, GLsizei, Ptr[Ptr[GLchar]], GLuint]
    inline def fromPtr(ptr: Ptr[Byte] | Ptr[?]): PFNGLCREATESHADERPROGRAMVPROC = CFuncPtr.fromPtr(ptr.asInstanceOf[Ptr[Byte]])
    inline def apply(inline o: CFuncPtr3[GLenum, GLsizei, Ptr[Ptr[GLchar]], GLuint]): PFNGLCREATESHADERPROGRAMVPROC = o
    extension (v: PFNGLCREATESHADERPROGRAMVPROC)
      inline def value: CFuncPtr3[GLenum, GLsizei, Ptr[Ptr[GLchar]], GLuint] = v
      inline def toPtr: Ptr[?] = CFuncPtr.toPtr(v)

  opaque type PFNGLCREATESTATESNVPROC = CFuncPtr2[GLsizei, Ptr[GLuint], Unit]
  object PFNGLCREATESTATESNVPROC:
    given _tag: Tag[PFNGLCREATESTATESNVPROC] = Tag.materializeCFuncPtr2[GLsizei, Ptr[GLuint], Unit]
    inline def fromPtr(ptr: Ptr[Byte] | Ptr[?]): PFNGLCREATESTATESNVPROC = CFuncPtr.fromPtr(ptr.asInstanceOf[Ptr[Byte]])
    inline def apply(inline o: CFuncPtr2[GLsizei, Ptr[GLuint], Unit]): PFNGLCREATESTATESNVPROC = o
    extension (v: PFNGLCREATESTATESNVPROC)
      inline def value: CFuncPtr2[GLsizei, Ptr[GLuint], Unit] = v
      inline def toPtr: Ptr[?] = CFuncPtr.toPtr(v)

  opaque type PFNGLCREATESYNCFROMCLEVENTARBPROC = CFuncPtr3[cl_context, cl_event, GLbitfield, GLsync]
  object PFNGLCREATESYNCFROMCLEVENTARBPROC:
    given _tag: Tag[PFNGLCREATESYNCFROMCLEVENTARBPROC] = Tag.materializeCFuncPtr3[cl_context, cl_event, GLbitfield, GLsync]
    inline def fromPtr(ptr: Ptr[Byte] | Ptr[?]): PFNGLCREATESYNCFROMCLEVENTARBPROC = CFuncPtr.fromPtr(ptr.asInstanceOf[Ptr[Byte]])
    inline def apply(inline o: CFuncPtr3[cl_context, cl_event, GLbitfield, GLsync]): PFNGLCREATESYNCFROMCLEVENTARBPROC = o
    extension (v: PFNGLCREATESYNCFROMCLEVENTARBPROC)
      inline def value: CFuncPtr3[cl_context, cl_event, GLbitfield, GLsync] = v
      inline def toPtr: Ptr[?] = CFuncPtr.toPtr(v)

  opaque type PFNGLCREATETEXTURESPROC = CFuncPtr3[GLenum, GLsizei, Ptr[GLuint], Unit]
  object PFNGLCREATETEXTURESPROC:
    given _tag: Tag[PFNGLCREATETEXTURESPROC] = Tag.materializeCFuncPtr3[GLenum, GLsizei, Ptr[GLuint], Unit]
    inline def fromPtr(ptr: Ptr[Byte] | Ptr[?]): PFNGLCREATETEXTURESPROC = CFuncPtr.fromPtr(ptr.asInstanceOf[Ptr[Byte]])
    inline def apply(inline o: CFuncPtr3[GLenum, GLsizei, Ptr[GLuint], Unit]): PFNGLCREATETEXTURESPROC = o
    extension (v: PFNGLCREATETEXTURESPROC)
      inline def value: CFuncPtr3[GLenum, GLsizei, Ptr[GLuint], Unit] = v
      inline def toPtr: Ptr[?] = CFuncPtr.toPtr(v)

  opaque type PFNGLCREATETRANSFORMFEEDBACKSPROC = CFuncPtr2[GLsizei, Ptr[GLuint], Unit]
  object PFNGLCREATETRANSFORMFEEDBACKSPROC:
    given _tag: Tag[PFNGLCREATETRANSFORMFEEDBACKSPROC] = Tag.materializeCFuncPtr2[GLsizei, Ptr[GLuint], Unit]
    inline def fromPtr(ptr: Ptr[Byte] | Ptr[?]): PFNGLCREATETRANSFORMFEEDBACKSPROC = CFuncPtr.fromPtr(ptr.asInstanceOf[Ptr[Byte]])
    inline def apply(inline o: CFuncPtr2[GLsizei, Ptr[GLuint], Unit]): PFNGLCREATETRANSFORMFEEDBACKSPROC = o
    extension (v: PFNGLCREATETRANSFORMFEEDBACKSPROC)
      inline def value: CFuncPtr2[GLsizei, Ptr[GLuint], Unit] = v
      inline def toPtr: Ptr[?] = CFuncPtr.toPtr(v)

  opaque type PFNGLCREATEVERTEXARRAYSPROC = CFuncPtr2[GLsizei, Ptr[GLuint], Unit]
  object PFNGLCREATEVERTEXARRAYSPROC:
    given _tag: Tag[PFNGLCREATEVERTEXARRAYSPROC] = Tag.materializeCFuncPtr2[GLsizei, Ptr[GLuint], Unit]
    inline def fromPtr(ptr: Ptr[Byte] | Ptr[?]): PFNGLCREATEVERTEXARRAYSPROC = CFuncPtr.fromPtr(ptr.asInstanceOf[Ptr[Byte]])
    inline def apply(inline o: CFuncPtr2[GLsizei, Ptr[GLuint], Unit]): PFNGLCREATEVERTEXARRAYSPROC = o
    extension (v: PFNGLCREATEVERTEXARRAYSPROC)
      inline def value: CFuncPtr2[GLsizei, Ptr[GLuint], Unit] = v
      inline def toPtr: Ptr[?] = CFuncPtr.toPtr(v)

  opaque type PFNGLCULLPARAMETERDVEXTPROC = CFuncPtr2[GLenum, Ptr[GLdouble], Unit]
  object PFNGLCULLPARAMETERDVEXTPROC:
    given _tag: Tag[PFNGLCULLPARAMETERDVEXTPROC] = Tag.materializeCFuncPtr2[GLenum, Ptr[GLdouble], Unit]
    inline def fromPtr(ptr: Ptr[Byte] | Ptr[?]): PFNGLCULLPARAMETERDVEXTPROC = CFuncPtr.fromPtr(ptr.asInstanceOf[Ptr[Byte]])
    inline def apply(inline o: CFuncPtr2[GLenum, Ptr[GLdouble], Unit]): PFNGLCULLPARAMETERDVEXTPROC = o
    extension (v: PFNGLCULLPARAMETERDVEXTPROC)
      inline def value: CFuncPtr2[GLenum, Ptr[GLdouble], Unit] = v
      inline def toPtr: Ptr[?] = CFuncPtr.toPtr(v)

  opaque type PFNGLCULLPARAMETERFVEXTPROC = CFuncPtr2[GLenum, Ptr[GLfloat], Unit]
  object PFNGLCULLPARAMETERFVEXTPROC:
    given _tag: Tag[PFNGLCULLPARAMETERFVEXTPROC] = Tag.materializeCFuncPtr2[GLenum, Ptr[GLfloat], Unit]
    inline def fromPtr(ptr: Ptr[Byte] | Ptr[?]): PFNGLCULLPARAMETERFVEXTPROC = CFuncPtr.fromPtr(ptr.asInstanceOf[Ptr[Byte]])
    inline def apply(inline o: CFuncPtr2[GLenum, Ptr[GLfloat], Unit]): PFNGLCULLPARAMETERFVEXTPROC = o
    extension (v: PFNGLCULLPARAMETERFVEXTPROC)
      inline def value: CFuncPtr2[GLenum, Ptr[GLfloat], Unit] = v
      inline def toPtr: Ptr[?] = CFuncPtr.toPtr(v)

  opaque type PFNGLCURRENTPALETTEMATRIXARBPROC = CFuncPtr1[GLint, Unit]
  object PFNGLCURRENTPALETTEMATRIXARBPROC:
    given _tag: Tag[PFNGLCURRENTPALETTEMATRIXARBPROC] = Tag.materializeCFuncPtr1[GLint, Unit]
    inline def fromPtr(ptr: Ptr[Byte] | Ptr[?]): PFNGLCURRENTPALETTEMATRIXARBPROC = CFuncPtr.fromPtr(ptr.asInstanceOf[Ptr[Byte]])
    inline def apply(inline o: CFuncPtr1[GLint, Unit]): PFNGLCURRENTPALETTEMATRIXARBPROC = o
    extension (v: PFNGLCURRENTPALETTEMATRIXARBPROC)
      inline def value: CFuncPtr1[GLint, Unit] = v
      inline def toPtr: Ptr[?] = CFuncPtr.toPtr(v)

  opaque type PFNGLCURRENTPALETTEMATRIXOESPROC = CFuncPtr1[GLuint, Unit]
  object PFNGLCURRENTPALETTEMATRIXOESPROC:
    given _tag: Tag[PFNGLCURRENTPALETTEMATRIXOESPROC] = Tag.materializeCFuncPtr1[GLuint, Unit]
    inline def fromPtr(ptr: Ptr[Byte] | Ptr[?]): PFNGLCURRENTPALETTEMATRIXOESPROC = CFuncPtr.fromPtr(ptr.asInstanceOf[Ptr[Byte]])
    inline def apply(inline o: CFuncPtr1[GLuint, Unit]): PFNGLCURRENTPALETTEMATRIXOESPROC = o
    extension (v: PFNGLCURRENTPALETTEMATRIXOESPROC)
      inline def value: CFuncPtr1[GLuint, Unit] = v
      inline def toPtr: Ptr[?] = CFuncPtr.toPtr(v)

  opaque type PFNGLDATAPIPEPROC = CFuncPtr1[GLenum, GLint]
  object PFNGLDATAPIPEPROC:
    given _tag: Tag[PFNGLDATAPIPEPROC] = Tag.materializeCFuncPtr1[GLenum, GLint]
    inline def fromPtr(ptr: Ptr[Byte] | Ptr[?]): PFNGLDATAPIPEPROC = CFuncPtr.fromPtr(ptr.asInstanceOf[Ptr[Byte]])
    inline def apply(inline o: CFuncPtr1[GLenum, GLint]): PFNGLDATAPIPEPROC = o
    extension (v: PFNGLDATAPIPEPROC)
      inline def value: CFuncPtr1[GLenum, GLint] = v
      inline def toPtr: Ptr[?] = CFuncPtr.toPtr(v)

  opaque type PFNGLDEBUGMESSAGECALLBACKAMDPROC = CFuncPtr2[GLDEBUGPROCAMD, Ptr[Byte], Unit]
  object PFNGLDEBUGMESSAGECALLBACKAMDPROC:
    given _tag: Tag[PFNGLDEBUGMESSAGECALLBACKAMDPROC] = Tag.materializeCFuncPtr2[GLDEBUGPROCAMD, Ptr[Byte], Unit]
    inline def fromPtr(ptr: Ptr[Byte] | Ptr[?]): PFNGLDEBUGMESSAGECALLBACKAMDPROC = CFuncPtr.fromPtr(ptr.asInstanceOf[Ptr[Byte]])
    inline def apply(inline o: CFuncPtr2[GLDEBUGPROCAMD, Ptr[Byte], Unit]): PFNGLDEBUGMESSAGECALLBACKAMDPROC = o
    extension (v: PFNGLDEBUGMESSAGECALLBACKAMDPROC)
      inline def value: CFuncPtr2[GLDEBUGPROCAMD, Ptr[Byte], Unit] = v
      inline def toPtr: Ptr[?] = CFuncPtr.toPtr(v)

  opaque type PFNGLDEBUGMESSAGECALLBACKARBPROC = CFuncPtr2[GLDEBUGPROCARB, Ptr[Byte], Unit]
  object PFNGLDEBUGMESSAGECALLBACKARBPROC:
    given _tag: Tag[PFNGLDEBUGMESSAGECALLBACKARBPROC] = Tag.materializeCFuncPtr2[GLDEBUGPROCARB, Ptr[Byte], Unit]
    inline def fromPtr(ptr: Ptr[Byte] | Ptr[?]): PFNGLDEBUGMESSAGECALLBACKARBPROC = CFuncPtr.fromPtr(ptr.asInstanceOf[Ptr[Byte]])
    inline def apply(inline o: CFuncPtr2[GLDEBUGPROCARB, Ptr[Byte], Unit]): PFNGLDEBUGMESSAGECALLBACKARBPROC = o
    extension (v: PFNGLDEBUGMESSAGECALLBACKARBPROC)
      inline def value: CFuncPtr2[GLDEBUGPROCARB, Ptr[Byte], Unit] = v
      inline def toPtr: Ptr[?] = CFuncPtr.toPtr(v)

  opaque type PFNGLDEBUGMESSAGECALLBACKPROC = CFuncPtr2[GLDEBUGPROC, Ptr[Byte], Unit]
  object PFNGLDEBUGMESSAGECALLBACKPROC:
    given _tag: Tag[PFNGLDEBUGMESSAGECALLBACKPROC] = Tag.materializeCFuncPtr2[GLDEBUGPROC, Ptr[Byte], Unit]
    inline def fromPtr(ptr: Ptr[Byte] | Ptr[?]): PFNGLDEBUGMESSAGECALLBACKPROC = CFuncPtr.fromPtr(ptr.asInstanceOf[Ptr[Byte]])
    inline def apply(inline o: CFuncPtr2[GLDEBUGPROC, Ptr[Byte], Unit]): PFNGLDEBUGMESSAGECALLBACKPROC = o
    extension (v: PFNGLDEBUGMESSAGECALLBACKPROC)
      inline def value: CFuncPtr2[GLDEBUGPROC, Ptr[Byte], Unit] = v
      inline def toPtr: Ptr[?] = CFuncPtr.toPtr(v)

  opaque type PFNGLDEBUGMESSAGECONTROLARBPROC = CFuncPtr6[GLenum, GLenum, GLenum, GLsizei, Ptr[GLuint], GLboolean, Unit]
  object PFNGLDEBUGMESSAGECONTROLARBPROC:
    given _tag: Tag[PFNGLDEBUGMESSAGECONTROLARBPROC] = Tag.materializeCFuncPtr6[GLenum, GLenum, GLenum, GLsizei, Ptr[GLuint], GLboolean, Unit]
    inline def fromPtr(ptr: Ptr[Byte] | Ptr[?]): PFNGLDEBUGMESSAGECONTROLARBPROC = CFuncPtr.fromPtr(ptr.asInstanceOf[Ptr[Byte]])
    inline def apply(inline o: CFuncPtr6[GLenum, GLenum, GLenum, GLsizei, Ptr[GLuint], GLboolean, Unit]): PFNGLDEBUGMESSAGECONTROLARBPROC = o
    extension (v: PFNGLDEBUGMESSAGECONTROLARBPROC)
      inline def value: CFuncPtr6[GLenum, GLenum, GLenum, GLsizei, Ptr[GLuint], GLboolean, Unit] = v
      inline def toPtr: Ptr[?] = CFuncPtr.toPtr(v)

  opaque type PFNGLDEBUGMESSAGECONTROLPROC = CFuncPtr6[GLenum, GLenum, GLenum, GLsizei, Ptr[GLuint], GLboolean, Unit]
  object PFNGLDEBUGMESSAGECONTROLPROC:
    given _tag: Tag[PFNGLDEBUGMESSAGECONTROLPROC] = Tag.materializeCFuncPtr6[GLenum, GLenum, GLenum, GLsizei, Ptr[GLuint], GLboolean, Unit]
    inline def fromPtr(ptr: Ptr[Byte] | Ptr[?]): PFNGLDEBUGMESSAGECONTROLPROC = CFuncPtr.fromPtr(ptr.asInstanceOf[Ptr[Byte]])
    inline def apply(inline o: CFuncPtr6[GLenum, GLenum, GLenum, GLsizei, Ptr[GLuint], GLboolean, Unit]): PFNGLDEBUGMESSAGECONTROLPROC = o
    extension (v: PFNGLDEBUGMESSAGECONTROLPROC)
      inline def value: CFuncPtr6[GLenum, GLenum, GLenum, GLsizei, Ptr[GLuint], GLboolean, Unit] = v
      inline def toPtr: Ptr[?] = CFuncPtr.toPtr(v)

  opaque type PFNGLDEBUGMESSAGEENABLEAMDPROC = CFuncPtr5[GLenum, GLenum, GLsizei, Ptr[GLuint], GLboolean, Unit]
  object PFNGLDEBUGMESSAGEENABLEAMDPROC:
    given _tag: Tag[PFNGLDEBUGMESSAGEENABLEAMDPROC] = Tag.materializeCFuncPtr5[GLenum, GLenum, GLsizei, Ptr[GLuint], GLboolean, Unit]
    inline def fromPtr(ptr: Ptr[Byte] | Ptr[?]): PFNGLDEBUGMESSAGEENABLEAMDPROC = CFuncPtr.fromPtr(ptr.asInstanceOf[Ptr[Byte]])
    inline def apply(inline o: CFuncPtr5[GLenum, GLenum, GLsizei, Ptr[GLuint], GLboolean, Unit]): PFNGLDEBUGMESSAGEENABLEAMDPROC = o
    extension (v: PFNGLDEBUGMESSAGEENABLEAMDPROC)
      inline def value: CFuncPtr5[GLenum, GLenum, GLsizei, Ptr[GLuint], GLboolean, Unit] = v
      inline def toPtr: Ptr[?] = CFuncPtr.toPtr(v)

  opaque type PFNGLDEBUGMESSAGEINSERTAMDPROC = CFuncPtr5[GLenum, GLenum, GLuint, GLsizei, Ptr[GLchar], Unit]
  object PFNGLDEBUGMESSAGEINSERTAMDPROC:
    given _tag: Tag[PFNGLDEBUGMESSAGEINSERTAMDPROC] = Tag.materializeCFuncPtr5[GLenum, GLenum, GLuint, GLsizei, Ptr[GLchar], Unit]
    inline def fromPtr(ptr: Ptr[Byte] | Ptr[?]): PFNGLDEBUGMESSAGEINSERTAMDPROC = CFuncPtr.fromPtr(ptr.asInstanceOf[Ptr[Byte]])
    inline def apply(inline o: CFuncPtr5[GLenum, GLenum, GLuint, GLsizei, Ptr[GLchar], Unit]): PFNGLDEBUGMESSAGEINSERTAMDPROC = o
    extension (v: PFNGLDEBUGMESSAGEINSERTAMDPROC)
      inline def value: CFuncPtr5[GLenum, GLenum, GLuint, GLsizei, Ptr[GLchar], Unit] = v
      inline def toPtr: Ptr[?] = CFuncPtr.toPtr(v)

  opaque type PFNGLDEBUGMESSAGEINSERTARBPROC = CFuncPtr6[GLenum, GLenum, GLuint, GLenum, GLsizei, Ptr[GLchar], Unit]
  object PFNGLDEBUGMESSAGEINSERTARBPROC:
    given _tag: Tag[PFNGLDEBUGMESSAGEINSERTARBPROC] = Tag.materializeCFuncPtr6[GLenum, GLenum, GLuint, GLenum, GLsizei, Ptr[GLchar], Unit]
    inline def fromPtr(ptr: Ptr[Byte] | Ptr[?]): PFNGLDEBUGMESSAGEINSERTARBPROC = CFuncPtr.fromPtr(ptr.asInstanceOf[Ptr[Byte]])
    inline def apply(inline o: CFuncPtr6[GLenum, GLenum, GLuint, GLenum, GLsizei, Ptr[GLchar], Unit]): PFNGLDEBUGMESSAGEINSERTARBPROC = o
    extension (v: PFNGLDEBUGMESSAGEINSERTARBPROC)
      inline def value: CFuncPtr6[GLenum, GLenum, GLuint, GLenum, GLsizei, Ptr[GLchar], Unit] = v
      inline def toPtr: Ptr[?] = CFuncPtr.toPtr(v)

  opaque type PFNGLDEBUGMESSAGEINSERTPROC = CFuncPtr6[GLenum, GLenum, GLuint, GLenum, GLsizei, Ptr[GLchar], Unit]
  object PFNGLDEBUGMESSAGEINSERTPROC:
    given _tag: Tag[PFNGLDEBUGMESSAGEINSERTPROC] = Tag.materializeCFuncPtr6[GLenum, GLenum, GLuint, GLenum, GLsizei, Ptr[GLchar], Unit]
    inline def fromPtr(ptr: Ptr[Byte] | Ptr[?]): PFNGLDEBUGMESSAGEINSERTPROC = CFuncPtr.fromPtr(ptr.asInstanceOf[Ptr[Byte]])
    inline def apply(inline o: CFuncPtr6[GLenum, GLenum, GLuint, GLenum, GLsizei, Ptr[GLchar], Unit]): PFNGLDEBUGMESSAGEINSERTPROC = o
    extension (v: PFNGLDEBUGMESSAGEINSERTPROC)
      inline def value: CFuncPtr6[GLenum, GLenum, GLuint, GLenum, GLsizei, Ptr[GLchar], Unit] = v
      inline def toPtr: Ptr[?] = CFuncPtr.toPtr(v)

  opaque type PFNGLDEFORMSGIXPROC = CFuncPtr1[GLbitfield, Unit]
  object PFNGLDEFORMSGIXPROC:
    given _tag: Tag[PFNGLDEFORMSGIXPROC] = Tag.materializeCFuncPtr1[GLbitfield, Unit]
    inline def fromPtr(ptr: Ptr[Byte] | Ptr[?]): PFNGLDEFORMSGIXPROC = CFuncPtr.fromPtr(ptr.asInstanceOf[Ptr[Byte]])
    inline def apply(inline o: CFuncPtr1[GLbitfield, Unit]): PFNGLDEFORMSGIXPROC = o
    extension (v: PFNGLDEFORMSGIXPROC)
      inline def value: CFuncPtr1[GLbitfield, Unit] = v
      inline def toPtr: Ptr[?] = CFuncPtr.toPtr(v)

  opaque type PFNGLDELETEARRAYSETSEXTPROC = CFuncPtr2[GLsizei, Ptr[Ptr[Byte]], Unit]
  object PFNGLDELETEARRAYSETSEXTPROC:
    given _tag: Tag[PFNGLDELETEARRAYSETSEXTPROC] = Tag.materializeCFuncPtr2[GLsizei, Ptr[Ptr[Byte]], Unit]
    inline def fromPtr(ptr: Ptr[Byte] | Ptr[?]): PFNGLDELETEARRAYSETSEXTPROC = CFuncPtr.fromPtr(ptr.asInstanceOf[Ptr[Byte]])
    inline def apply(inline o: CFuncPtr2[GLsizei, Ptr[Ptr[Byte]], Unit]): PFNGLDELETEARRAYSETSEXTPROC = o
    extension (v: PFNGLDELETEARRAYSETSEXTPROC)
      inline def value: CFuncPtr2[GLsizei, Ptr[Ptr[Byte]], Unit] = v
      inline def toPtr: Ptr[?] = CFuncPtr.toPtr(v)

  opaque type PFNGLDELETEASYNCMARKERSSGIXPROC = CFuncPtr2[GLuint, GLsizei, Unit]
  object PFNGLDELETEASYNCMARKERSSGIXPROC:
    given _tag: Tag[PFNGLDELETEASYNCMARKERSSGIXPROC] = Tag.materializeCFuncPtr2[GLuint, GLsizei, Unit]
    inline def fromPtr(ptr: Ptr[Byte] | Ptr[?]): PFNGLDELETEASYNCMARKERSSGIXPROC = CFuncPtr.fromPtr(ptr.asInstanceOf[Ptr[Byte]])
    inline def apply(inline o: CFuncPtr2[GLuint, GLsizei, Unit]): PFNGLDELETEASYNCMARKERSSGIXPROC = o
    extension (v: PFNGLDELETEASYNCMARKERSSGIXPROC)
      inline def value: CFuncPtr2[GLuint, GLsizei, Unit] = v
      inline def toPtr: Ptr[?] = CFuncPtr.toPtr(v)

  opaque type PFNGLDELETEBUFFERREGIONPROC = CFuncPtr1[GLenum, Unit]
  object PFNGLDELETEBUFFERREGIONPROC:
    given _tag: Tag[PFNGLDELETEBUFFERREGIONPROC] = Tag.materializeCFuncPtr1[GLenum, Unit]
    inline def fromPtr(ptr: Ptr[Byte] | Ptr[?]): PFNGLDELETEBUFFERREGIONPROC = CFuncPtr.fromPtr(ptr.asInstanceOf[Ptr[Byte]])
    inline def apply(inline o: CFuncPtr1[GLenum, Unit]): PFNGLDELETEBUFFERREGIONPROC = o
    extension (v: PFNGLDELETEBUFFERREGIONPROC)
      inline def value: CFuncPtr1[GLenum, Unit] = v
      inline def toPtr: Ptr[?] = CFuncPtr.toPtr(v)

  opaque type PFNGLDELETEBUFFERSARBPROC = CFuncPtr2[GLsizei, Ptr[GLuint], Unit]
  object PFNGLDELETEBUFFERSARBPROC:
    given _tag: Tag[PFNGLDELETEBUFFERSARBPROC] = Tag.materializeCFuncPtr2[GLsizei, Ptr[GLuint], Unit]
    inline def fromPtr(ptr: Ptr[Byte] | Ptr[?]): PFNGLDELETEBUFFERSARBPROC = CFuncPtr.fromPtr(ptr.asInstanceOf[Ptr[Byte]])
    inline def apply(inline o: CFuncPtr2[GLsizei, Ptr[GLuint], Unit]): PFNGLDELETEBUFFERSARBPROC = o
    extension (v: PFNGLDELETEBUFFERSARBPROC)
      inline def value: CFuncPtr2[GLsizei, Ptr[GLuint], Unit] = v
      inline def toPtr: Ptr[?] = CFuncPtr.toPtr(v)

  opaque type PFNGLDELETEBUFFERSPROC = CFuncPtr2[GLsizei, Ptr[GLuint], Unit]
  object PFNGLDELETEBUFFERSPROC:
    given _tag: Tag[PFNGLDELETEBUFFERSPROC] = Tag.materializeCFuncPtr2[GLsizei, Ptr[GLuint], Unit]
    inline def fromPtr(ptr: Ptr[Byte] | Ptr[?]): PFNGLDELETEBUFFERSPROC = CFuncPtr.fromPtr(ptr.asInstanceOf[Ptr[Byte]])
    inline def apply(inline o: CFuncPtr2[GLsizei, Ptr[GLuint], Unit]): PFNGLDELETEBUFFERSPROC = o
    extension (v: PFNGLDELETEBUFFERSPROC)
      inline def value: CFuncPtr2[GLsizei, Ptr[GLuint], Unit] = v
      inline def toPtr: Ptr[?] = CFuncPtr.toPtr(v)

  opaque type PFNGLDELETECOMMANDLISTSNVPROC = CFuncPtr2[GLsizei, Ptr[GLuint], Unit]
  object PFNGLDELETECOMMANDLISTSNVPROC:
    given _tag: Tag[PFNGLDELETECOMMANDLISTSNVPROC] = Tag.materializeCFuncPtr2[GLsizei, Ptr[GLuint], Unit]
    inline def fromPtr(ptr: Ptr[Byte] | Ptr[?]): PFNGLDELETECOMMANDLISTSNVPROC = CFuncPtr.fromPtr(ptr.asInstanceOf[Ptr[Byte]])
    inline def apply(inline o: CFuncPtr2[GLsizei, Ptr[GLuint], Unit]): PFNGLDELETECOMMANDLISTSNVPROC = o
    extension (v: PFNGLDELETECOMMANDLISTSNVPROC)
      inline def value: CFuncPtr2[GLsizei, Ptr[GLuint], Unit] = v
      inline def toPtr: Ptr[?] = CFuncPtr.toPtr(v)

  opaque type PFNGLDELETEFENCESAPPLEPROC = CFuncPtr2[GLsizei, Ptr[GLuint], Unit]
  object PFNGLDELETEFENCESAPPLEPROC:
    given _tag: Tag[PFNGLDELETEFENCESAPPLEPROC] = Tag.materializeCFuncPtr2[GLsizei, Ptr[GLuint], Unit]
    inline def fromPtr(ptr: Ptr[Byte] | Ptr[?]): PFNGLDELETEFENCESAPPLEPROC = CFuncPtr.fromPtr(ptr.asInstanceOf[Ptr[Byte]])
    inline def apply(inline o: CFuncPtr2[GLsizei, Ptr[GLuint], Unit]): PFNGLDELETEFENCESAPPLEPROC = o
    extension (v: PFNGLDELETEFENCESAPPLEPROC)
      inline def value: CFuncPtr2[GLsizei, Ptr[GLuint], Unit] = v
      inline def toPtr: Ptr[?] = CFuncPtr.toPtr(v)

  opaque type PFNGLDELETEFENCESNVPROC = CFuncPtr2[GLsizei, Ptr[GLuint], Unit]
  object PFNGLDELETEFENCESNVPROC:
    given _tag: Tag[PFNGLDELETEFENCESNVPROC] = Tag.materializeCFuncPtr2[GLsizei, Ptr[GLuint], Unit]
    inline def fromPtr(ptr: Ptr[Byte] | Ptr[?]): PFNGLDELETEFENCESNVPROC = CFuncPtr.fromPtr(ptr.asInstanceOf[Ptr[Byte]])
    inline def apply(inline o: CFuncPtr2[GLsizei, Ptr[GLuint], Unit]): PFNGLDELETEFENCESNVPROC = o
    extension (v: PFNGLDELETEFENCESNVPROC)
      inline def value: CFuncPtr2[GLsizei, Ptr[GLuint], Unit] = v
      inline def toPtr: Ptr[?] = CFuncPtr.toPtr(v)

  opaque type PFNGLDELETEFRAGMENTSHADERATIPROC = CFuncPtr1[GLuint, Unit]
  object PFNGLDELETEFRAGMENTSHADERATIPROC:
    given _tag: Tag[PFNGLDELETEFRAGMENTSHADERATIPROC] = Tag.materializeCFuncPtr1[GLuint, Unit]
    inline def fromPtr(ptr: Ptr[Byte] | Ptr[?]): PFNGLDELETEFRAGMENTSHADERATIPROC = CFuncPtr.fromPtr(ptr.asInstanceOf[Ptr[Byte]])
    inline def apply(inline o: CFuncPtr1[GLuint, Unit]): PFNGLDELETEFRAGMENTSHADERATIPROC = o
    extension (v: PFNGLDELETEFRAGMENTSHADERATIPROC)
      inline def value: CFuncPtr1[GLuint, Unit] = v
      inline def toPtr: Ptr[?] = CFuncPtr.toPtr(v)

  opaque type PFNGLDELETEFRAMEBUFFERSEXTPROC = CFuncPtr2[GLsizei, Ptr[GLuint], Unit]
  object PFNGLDELETEFRAMEBUFFERSEXTPROC:
    given _tag: Tag[PFNGLDELETEFRAMEBUFFERSEXTPROC] = Tag.materializeCFuncPtr2[GLsizei, Ptr[GLuint], Unit]
    inline def fromPtr(ptr: Ptr[Byte] | Ptr[?]): PFNGLDELETEFRAMEBUFFERSEXTPROC = CFuncPtr.fromPtr(ptr.asInstanceOf[Ptr[Byte]])
    inline def apply(inline o: CFuncPtr2[GLsizei, Ptr[GLuint], Unit]): PFNGLDELETEFRAMEBUFFERSEXTPROC = o
    extension (v: PFNGLDELETEFRAMEBUFFERSEXTPROC)
      inline def value: CFuncPtr2[GLsizei, Ptr[GLuint], Unit] = v
      inline def toPtr: Ptr[?] = CFuncPtr.toPtr(v)

  opaque type PFNGLDELETEFRAMEBUFFERSOESPROC = CFuncPtr2[GLsizei, Ptr[GLuint], Unit]
  object PFNGLDELETEFRAMEBUFFERSOESPROC:
    given _tag: Tag[PFNGLDELETEFRAMEBUFFERSOESPROC] = Tag.materializeCFuncPtr2[GLsizei, Ptr[GLuint], Unit]
    inline def fromPtr(ptr: Ptr[Byte] | Ptr[?]): PFNGLDELETEFRAMEBUFFERSOESPROC = CFuncPtr.fromPtr(ptr.asInstanceOf[Ptr[Byte]])
    inline def apply(inline o: CFuncPtr2[GLsizei, Ptr[GLuint], Unit]): PFNGLDELETEFRAMEBUFFERSOESPROC = o
    extension (v: PFNGLDELETEFRAMEBUFFERSOESPROC)
      inline def value: CFuncPtr2[GLsizei, Ptr[GLuint], Unit] = v
      inline def toPtr: Ptr[?] = CFuncPtr.toPtr(v)

  opaque type PFNGLDELETEFRAMEBUFFERSPROC = CFuncPtr2[GLsizei, Ptr[GLuint], Unit]
  object PFNGLDELETEFRAMEBUFFERSPROC:
    given _tag: Tag[PFNGLDELETEFRAMEBUFFERSPROC] = Tag.materializeCFuncPtr2[GLsizei, Ptr[GLuint], Unit]
    inline def fromPtr(ptr: Ptr[Byte] | Ptr[?]): PFNGLDELETEFRAMEBUFFERSPROC = CFuncPtr.fromPtr(ptr.asInstanceOf[Ptr[Byte]])
    inline def apply(inline o: CFuncPtr2[GLsizei, Ptr[GLuint], Unit]): PFNGLDELETEFRAMEBUFFERSPROC = o
    extension (v: PFNGLDELETEFRAMEBUFFERSPROC)
      inline def value: CFuncPtr2[GLsizei, Ptr[GLuint], Unit] = v
      inline def toPtr: Ptr[?] = CFuncPtr.toPtr(v)

  opaque type PFNGLDELETEMEMORYOBJECTSEXTPROC = CFuncPtr2[GLsizei, Ptr[GLuint], Unit]
  object PFNGLDELETEMEMORYOBJECTSEXTPROC:
    given _tag: Tag[PFNGLDELETEMEMORYOBJECTSEXTPROC] = Tag.materializeCFuncPtr2[GLsizei, Ptr[GLuint], Unit]
    inline def fromPtr(ptr: Ptr[Byte] | Ptr[?]): PFNGLDELETEMEMORYOBJECTSEXTPROC = CFuncPtr.fromPtr(ptr.asInstanceOf[Ptr[Byte]])
    inline def apply(inline o: CFuncPtr2[GLsizei, Ptr[GLuint], Unit]): PFNGLDELETEMEMORYOBJECTSEXTPROC = o
    extension (v: PFNGLDELETEMEMORYOBJECTSEXTPROC)
      inline def value: CFuncPtr2[GLsizei, Ptr[GLuint], Unit] = v
      inline def toPtr: Ptr[?] = CFuncPtr.toPtr(v)

  opaque type PFNGLDELETEMPEGPREDICTORSSGIXPROC = CFuncPtr2[GLsizei, Ptr[GLuint], Unit]
  object PFNGLDELETEMPEGPREDICTORSSGIXPROC:
    given _tag: Tag[PFNGLDELETEMPEGPREDICTORSSGIXPROC] = Tag.materializeCFuncPtr2[GLsizei, Ptr[GLuint], Unit]
    inline def fromPtr(ptr: Ptr[Byte] | Ptr[?]): PFNGLDELETEMPEGPREDICTORSSGIXPROC = CFuncPtr.fromPtr(ptr.asInstanceOf[Ptr[Byte]])
    inline def apply(inline o: CFuncPtr2[GLsizei, Ptr[GLuint], Unit]): PFNGLDELETEMPEGPREDICTORSSGIXPROC = o
    extension (v: PFNGLDELETEMPEGPREDICTORSSGIXPROC)
      inline def value: CFuncPtr2[GLsizei, Ptr[GLuint], Unit] = v
      inline def toPtr: Ptr[?] = CFuncPtr.toPtr(v)

  opaque type PFNGLDELETENAMEDSTRINGARBPROC = CFuncPtr2[GLint, Ptr[GLchar], Unit]
  object PFNGLDELETENAMEDSTRINGARBPROC:
    given _tag: Tag[PFNGLDELETENAMEDSTRINGARBPROC] = Tag.materializeCFuncPtr2[GLint, Ptr[GLchar], Unit]
    inline def fromPtr(ptr: Ptr[Byte] | Ptr[?]): PFNGLDELETENAMEDSTRINGARBPROC = CFuncPtr.fromPtr(ptr.asInstanceOf[Ptr[Byte]])
    inline def apply(inline o: CFuncPtr2[GLint, Ptr[GLchar], Unit]): PFNGLDELETENAMEDSTRINGARBPROC = o
    extension (v: PFNGLDELETENAMEDSTRINGARBPROC)
      inline def value: CFuncPtr2[GLint, Ptr[GLchar], Unit] = v
      inline def toPtr: Ptr[?] = CFuncPtr.toPtr(v)

  opaque type PFNGLDELETENAMESAMDPROC = CFuncPtr3[GLenum, GLuint, Ptr[GLuint], Unit]
  object PFNGLDELETENAMESAMDPROC:
    given _tag: Tag[PFNGLDELETENAMESAMDPROC] = Tag.materializeCFuncPtr3[GLenum, GLuint, Ptr[GLuint], Unit]
    inline def fromPtr(ptr: Ptr[Byte] | Ptr[?]): PFNGLDELETENAMESAMDPROC = CFuncPtr.fromPtr(ptr.asInstanceOf[Ptr[Byte]])
    inline def apply(inline o: CFuncPtr3[GLenum, GLuint, Ptr[GLuint], Unit]): PFNGLDELETENAMESAMDPROC = o
    extension (v: PFNGLDELETENAMESAMDPROC)
      inline def value: CFuncPtr3[GLenum, GLuint, Ptr[GLuint], Unit] = v
      inline def toPtr: Ptr[?] = CFuncPtr.toPtr(v)

  opaque type PFNGLDELETEOBJECTARBPROC = CFuncPtr1[GLhandleARB, Unit]
  object PFNGLDELETEOBJECTARBPROC:
    given _tag: Tag[PFNGLDELETEOBJECTARBPROC] = Tag.materializeCFuncPtr1[GLhandleARB, Unit]
    inline def fromPtr(ptr: Ptr[Byte] | Ptr[?]): PFNGLDELETEOBJECTARBPROC = CFuncPtr.fromPtr(ptr.asInstanceOf[Ptr[Byte]])
    inline def apply(inline o: CFuncPtr1[GLhandleARB, Unit]): PFNGLDELETEOBJECTARBPROC = o
    extension (v: PFNGLDELETEOBJECTARBPROC)
      inline def value: CFuncPtr1[GLhandleARB, Unit] = v
      inline def toPtr: Ptr[?] = CFuncPtr.toPtr(v)

  opaque type PFNGLDELETEOCCLUSIONQUERIESNVPROC = CFuncPtr2[GLsizei, Ptr[GLuint], Unit]
  object PFNGLDELETEOCCLUSIONQUERIESNVPROC:
    given _tag: Tag[PFNGLDELETEOCCLUSIONQUERIESNVPROC] = Tag.materializeCFuncPtr2[GLsizei, Ptr[GLuint], Unit]
    inline def fromPtr(ptr: Ptr[Byte] | Ptr[?]): PFNGLDELETEOCCLUSIONQUERIESNVPROC = CFuncPtr.fromPtr(ptr.asInstanceOf[Ptr[Byte]])
    inline def apply(inline o: CFuncPtr2[GLsizei, Ptr[GLuint], Unit]): PFNGLDELETEOCCLUSIONQUERIESNVPROC = o
    extension (v: PFNGLDELETEOCCLUSIONQUERIESNVPROC)
      inline def value: CFuncPtr2[GLsizei, Ptr[GLuint], Unit] = v
      inline def toPtr: Ptr[?] = CFuncPtr.toPtr(v)

  opaque type PFNGLDELETEPATHSNVPROC = CFuncPtr2[GLuint, GLsizei, Unit]
  object PFNGLDELETEPATHSNVPROC:
    given _tag: Tag[PFNGLDELETEPATHSNVPROC] = Tag.materializeCFuncPtr2[GLuint, GLsizei, Unit]
    inline def fromPtr(ptr: Ptr[Byte] | Ptr[?]): PFNGLDELETEPATHSNVPROC = CFuncPtr.fromPtr(ptr.asInstanceOf[Ptr[Byte]])
    inline def apply(inline o: CFuncPtr2[GLuint, GLsizei, Unit]): PFNGLDELETEPATHSNVPROC = o
    extension (v: PFNGLDELETEPATHSNVPROC)
      inline def value: CFuncPtr2[GLuint, GLsizei, Unit] = v
      inline def toPtr: Ptr[?] = CFuncPtr.toPtr(v)

  opaque type PFNGLDELETEPERFMONITORSAMDPROC = CFuncPtr2[GLsizei, Ptr[GLuint], Unit]
  object PFNGLDELETEPERFMONITORSAMDPROC:
    given _tag: Tag[PFNGLDELETEPERFMONITORSAMDPROC] = Tag.materializeCFuncPtr2[GLsizei, Ptr[GLuint], Unit]
    inline def fromPtr(ptr: Ptr[Byte] | Ptr[?]): PFNGLDELETEPERFMONITORSAMDPROC = CFuncPtr.fromPtr(ptr.asInstanceOf[Ptr[Byte]])
    inline def apply(inline o: CFuncPtr2[GLsizei, Ptr[GLuint], Unit]): PFNGLDELETEPERFMONITORSAMDPROC = o
    extension (v: PFNGLDELETEPERFMONITORSAMDPROC)
      inline def value: CFuncPtr2[GLsizei, Ptr[GLuint], Unit] = v
      inline def toPtr: Ptr[?] = CFuncPtr.toPtr(v)

  opaque type PFNGLDELETEPERFQUERYINTELPROC = CFuncPtr1[GLuint, Unit]
  object PFNGLDELETEPERFQUERYINTELPROC:
    given _tag: Tag[PFNGLDELETEPERFQUERYINTELPROC] = Tag.materializeCFuncPtr1[GLuint, Unit]
    inline def fromPtr(ptr: Ptr[Byte] | Ptr[?]): PFNGLDELETEPERFQUERYINTELPROC = CFuncPtr.fromPtr(ptr.asInstanceOf[Ptr[Byte]])
    inline def apply(inline o: CFuncPtr1[GLuint, Unit]): PFNGLDELETEPERFQUERYINTELPROC = o
    extension (v: PFNGLDELETEPERFQUERYINTELPROC)
      inline def value: CFuncPtr1[GLuint, Unit] = v
      inline def toPtr: Ptr[?] = CFuncPtr.toPtr(v)

  opaque type PFNGLDELETEPROGRAMPIPELINESPROC = CFuncPtr2[GLsizei, Ptr[GLuint], Unit]
  object PFNGLDELETEPROGRAMPIPELINESPROC:
    given _tag: Tag[PFNGLDELETEPROGRAMPIPELINESPROC] = Tag.materializeCFuncPtr2[GLsizei, Ptr[GLuint], Unit]
    inline def fromPtr(ptr: Ptr[Byte] | Ptr[?]): PFNGLDELETEPROGRAMPIPELINESPROC = CFuncPtr.fromPtr(ptr.asInstanceOf[Ptr[Byte]])
    inline def apply(inline o: CFuncPtr2[GLsizei, Ptr[GLuint], Unit]): PFNGLDELETEPROGRAMPIPELINESPROC = o
    extension (v: PFNGLDELETEPROGRAMPIPELINESPROC)
      inline def value: CFuncPtr2[GLsizei, Ptr[GLuint], Unit] = v
      inline def toPtr: Ptr[?] = CFuncPtr.toPtr(v)

  opaque type PFNGLDELETEPROGRAMPROC = CFuncPtr1[GLuint, Unit]
  object PFNGLDELETEPROGRAMPROC:
    given _tag: Tag[PFNGLDELETEPROGRAMPROC] = Tag.materializeCFuncPtr1[GLuint, Unit]
    inline def fromPtr(ptr: Ptr[Byte] | Ptr[?]): PFNGLDELETEPROGRAMPROC = CFuncPtr.fromPtr(ptr.asInstanceOf[Ptr[Byte]])
    inline def apply(inline o: CFuncPtr1[GLuint, Unit]): PFNGLDELETEPROGRAMPROC = o
    extension (v: PFNGLDELETEPROGRAMPROC)
      inline def value: CFuncPtr1[GLuint, Unit] = v
      inline def toPtr: Ptr[?] = CFuncPtr.toPtr(v)

  opaque type PFNGLDELETEPROGRAMSARBPROC = CFuncPtr2[GLsizei, Ptr[GLuint], Unit]
  object PFNGLDELETEPROGRAMSARBPROC:
    given _tag: Tag[PFNGLDELETEPROGRAMSARBPROC] = Tag.materializeCFuncPtr2[GLsizei, Ptr[GLuint], Unit]
    inline def fromPtr(ptr: Ptr[Byte] | Ptr[?]): PFNGLDELETEPROGRAMSARBPROC = CFuncPtr.fromPtr(ptr.asInstanceOf[Ptr[Byte]])
    inline def apply(inline o: CFuncPtr2[GLsizei, Ptr[GLuint], Unit]): PFNGLDELETEPROGRAMSARBPROC = o
    extension (v: PFNGLDELETEPROGRAMSARBPROC)
      inline def value: CFuncPtr2[GLsizei, Ptr[GLuint], Unit] = v
      inline def toPtr: Ptr[?] = CFuncPtr.toPtr(v)

  opaque type PFNGLDELETEPROGRAMSNVPROC = CFuncPtr2[GLsizei, Ptr[GLuint], Unit]
  object PFNGLDELETEPROGRAMSNVPROC:
    given _tag: Tag[PFNGLDELETEPROGRAMSNVPROC] = Tag.materializeCFuncPtr2[GLsizei, Ptr[GLuint], Unit]
    inline def fromPtr(ptr: Ptr[Byte] | Ptr[?]): PFNGLDELETEPROGRAMSNVPROC = CFuncPtr.fromPtr(ptr.asInstanceOf[Ptr[Byte]])
    inline def apply(inline o: CFuncPtr2[GLsizei, Ptr[GLuint], Unit]): PFNGLDELETEPROGRAMSNVPROC = o
    extension (v: PFNGLDELETEPROGRAMSNVPROC)
      inline def value: CFuncPtr2[GLsizei, Ptr[GLuint], Unit] = v
      inline def toPtr: Ptr[?] = CFuncPtr.toPtr(v)

  opaque type PFNGLDELETEQUERIESANGLEPROC = CFuncPtr2[GLsizei, Ptr[GLuint], Unit]
  object PFNGLDELETEQUERIESANGLEPROC:
    given _tag: Tag[PFNGLDELETEQUERIESANGLEPROC] = Tag.materializeCFuncPtr2[GLsizei, Ptr[GLuint], Unit]
    inline def fromPtr(ptr: Ptr[Byte] | Ptr[?]): PFNGLDELETEQUERIESANGLEPROC = CFuncPtr.fromPtr(ptr.asInstanceOf[Ptr[Byte]])
    inline def apply(inline o: CFuncPtr2[GLsizei, Ptr[GLuint], Unit]): PFNGLDELETEQUERIESANGLEPROC = o
    extension (v: PFNGLDELETEQUERIESANGLEPROC)
      inline def value: CFuncPtr2[GLsizei, Ptr[GLuint], Unit] = v
      inline def toPtr: Ptr[?] = CFuncPtr.toPtr(v)

  opaque type PFNGLDELETEQUERIESARBPROC = CFuncPtr2[GLsizei, Ptr[GLuint], Unit]
  object PFNGLDELETEQUERIESARBPROC:
    given _tag: Tag[PFNGLDELETEQUERIESARBPROC] = Tag.materializeCFuncPtr2[GLsizei, Ptr[GLuint], Unit]
    inline def fromPtr(ptr: Ptr[Byte] | Ptr[?]): PFNGLDELETEQUERIESARBPROC = CFuncPtr.fromPtr(ptr.asInstanceOf[Ptr[Byte]])
    inline def apply(inline o: CFuncPtr2[GLsizei, Ptr[GLuint], Unit]): PFNGLDELETEQUERIESARBPROC = o
    extension (v: PFNGLDELETEQUERIESARBPROC)
      inline def value: CFuncPtr2[GLsizei, Ptr[GLuint], Unit] = v
      inline def toPtr: Ptr[?] = CFuncPtr.toPtr(v)

  opaque type PFNGLDELETEQUERIESEXTPROC = CFuncPtr2[GLsizei, Ptr[GLuint], Unit]
  object PFNGLDELETEQUERIESEXTPROC:
    given _tag: Tag[PFNGLDELETEQUERIESEXTPROC] = Tag.materializeCFuncPtr2[GLsizei, Ptr[GLuint], Unit]
    inline def fromPtr(ptr: Ptr[Byte] | Ptr[?]): PFNGLDELETEQUERIESEXTPROC = CFuncPtr.fromPtr(ptr.asInstanceOf[Ptr[Byte]])
    inline def apply(inline o: CFuncPtr2[GLsizei, Ptr[GLuint], Unit]): PFNGLDELETEQUERIESEXTPROC = o
    extension (v: PFNGLDELETEQUERIESEXTPROC)
      inline def value: CFuncPtr2[GLsizei, Ptr[GLuint], Unit] = v
      inline def toPtr: Ptr[?] = CFuncPtr.toPtr(v)

  opaque type PFNGLDELETEQUERIESPROC = CFuncPtr2[GLsizei, Ptr[GLuint], Unit]
  object PFNGLDELETEQUERIESPROC:
    given _tag: Tag[PFNGLDELETEQUERIESPROC] = Tag.materializeCFuncPtr2[GLsizei, Ptr[GLuint], Unit]
    inline def fromPtr(ptr: Ptr[Byte] | Ptr[?]): PFNGLDELETEQUERIESPROC = CFuncPtr.fromPtr(ptr.asInstanceOf[Ptr[Byte]])
    inline def apply(inline o: CFuncPtr2[GLsizei, Ptr[GLuint], Unit]): PFNGLDELETEQUERIESPROC = o
    extension (v: PFNGLDELETEQUERIESPROC)
      inline def value: CFuncPtr2[GLsizei, Ptr[GLuint], Unit] = v
      inline def toPtr: Ptr[?] = CFuncPtr.toPtr(v)

  opaque type PFNGLDELETERENDERBUFFERSEXTPROC = CFuncPtr2[GLsizei, Ptr[GLuint], Unit]
  object PFNGLDELETERENDERBUFFERSEXTPROC:
    given _tag: Tag[PFNGLDELETERENDERBUFFERSEXTPROC] = Tag.materializeCFuncPtr2[GLsizei, Ptr[GLuint], Unit]
    inline def fromPtr(ptr: Ptr[Byte] | Ptr[?]): PFNGLDELETERENDERBUFFERSEXTPROC = CFuncPtr.fromPtr(ptr.asInstanceOf[Ptr[Byte]])
    inline def apply(inline o: CFuncPtr2[GLsizei, Ptr[GLuint], Unit]): PFNGLDELETERENDERBUFFERSEXTPROC = o
    extension (v: PFNGLDELETERENDERBUFFERSEXTPROC)
      inline def value: CFuncPtr2[GLsizei, Ptr[GLuint], Unit] = v
      inline def toPtr: Ptr[?] = CFuncPtr.toPtr(v)

  opaque type PFNGLDELETERENDERBUFFERSOESPROC = CFuncPtr2[GLsizei, Ptr[GLuint], Unit]
  object PFNGLDELETERENDERBUFFERSOESPROC:
    given _tag: Tag[PFNGLDELETERENDERBUFFERSOESPROC] = Tag.materializeCFuncPtr2[GLsizei, Ptr[GLuint], Unit]
    inline def fromPtr(ptr: Ptr[Byte] | Ptr[?]): PFNGLDELETERENDERBUFFERSOESPROC = CFuncPtr.fromPtr(ptr.asInstanceOf[Ptr[Byte]])
    inline def apply(inline o: CFuncPtr2[GLsizei, Ptr[GLuint], Unit]): PFNGLDELETERENDERBUFFERSOESPROC = o
    extension (v: PFNGLDELETERENDERBUFFERSOESPROC)
      inline def value: CFuncPtr2[GLsizei, Ptr[GLuint], Unit] = v
      inline def toPtr: Ptr[?] = CFuncPtr.toPtr(v)

  opaque type PFNGLDELETERENDERBUFFERSPROC = CFuncPtr2[GLsizei, Ptr[GLuint], Unit]
  object PFNGLDELETERENDERBUFFERSPROC:
    given _tag: Tag[PFNGLDELETERENDERBUFFERSPROC] = Tag.materializeCFuncPtr2[GLsizei, Ptr[GLuint], Unit]
    inline def fromPtr(ptr: Ptr[Byte] | Ptr[?]): PFNGLDELETERENDERBUFFERSPROC = CFuncPtr.fromPtr(ptr.asInstanceOf[Ptr[Byte]])
    inline def apply(inline o: CFuncPtr2[GLsizei, Ptr[GLuint], Unit]): PFNGLDELETERENDERBUFFERSPROC = o
    extension (v: PFNGLDELETERENDERBUFFERSPROC)
      inline def value: CFuncPtr2[GLsizei, Ptr[GLuint], Unit] = v
      inline def toPtr: Ptr[?] = CFuncPtr.toPtr(v)

  opaque type PFNGLDELETESAMPLERSPROC = CFuncPtr2[GLsizei, Ptr[GLuint], Unit]
  object PFNGLDELETESAMPLERSPROC:
    given _tag: Tag[PFNGLDELETESAMPLERSPROC] = Tag.materializeCFuncPtr2[GLsizei, Ptr[GLuint], Unit]
    inline def fromPtr(ptr: Ptr[Byte] | Ptr[?]): PFNGLDELETESAMPLERSPROC = CFuncPtr.fromPtr(ptr.asInstanceOf[Ptr[Byte]])
    inline def apply(inline o: CFuncPtr2[GLsizei, Ptr[GLuint], Unit]): PFNGLDELETESAMPLERSPROC = o
    extension (v: PFNGLDELETESAMPLERSPROC)
      inline def value: CFuncPtr2[GLsizei, Ptr[GLuint], Unit] = v
      inline def toPtr: Ptr[?] = CFuncPtr.toPtr(v)

  opaque type PFNGLDELETESEMAPHORESEXTPROC = CFuncPtr2[GLsizei, Ptr[GLuint], Unit]
  object PFNGLDELETESEMAPHORESEXTPROC:
    given _tag: Tag[PFNGLDELETESEMAPHORESEXTPROC] = Tag.materializeCFuncPtr2[GLsizei, Ptr[GLuint], Unit]
    inline def fromPtr(ptr: Ptr[Byte] | Ptr[?]): PFNGLDELETESEMAPHORESEXTPROC = CFuncPtr.fromPtr(ptr.asInstanceOf[Ptr[Byte]])
    inline def apply(inline o: CFuncPtr2[GLsizei, Ptr[GLuint], Unit]): PFNGLDELETESEMAPHORESEXTPROC = o
    extension (v: PFNGLDELETESEMAPHORESEXTPROC)
      inline def value: CFuncPtr2[GLsizei, Ptr[GLuint], Unit] = v
      inline def toPtr: Ptr[?] = CFuncPtr.toPtr(v)

  opaque type PFNGLDELETESHADERPROC = CFuncPtr1[GLuint, Unit]
  object PFNGLDELETESHADERPROC:
    given _tag: Tag[PFNGLDELETESHADERPROC] = Tag.materializeCFuncPtr1[GLuint, Unit]
    inline def fromPtr(ptr: Ptr[Byte] | Ptr[?]): PFNGLDELETESHADERPROC = CFuncPtr.fromPtr(ptr.asInstanceOf[Ptr[Byte]])
    inline def apply(inline o: CFuncPtr1[GLuint, Unit]): PFNGLDELETESHADERPROC = o
    extension (v: PFNGLDELETESHADERPROC)
      inline def value: CFuncPtr1[GLuint, Unit] = v
      inline def toPtr: Ptr[?] = CFuncPtr.toPtr(v)

  opaque type PFNGLDELETESTATESNVPROC = CFuncPtr2[GLsizei, Ptr[GLuint], Unit]
  object PFNGLDELETESTATESNVPROC:
    given _tag: Tag[PFNGLDELETESTATESNVPROC] = Tag.materializeCFuncPtr2[GLsizei, Ptr[GLuint], Unit]
    inline def fromPtr(ptr: Ptr[Byte] | Ptr[?]): PFNGLDELETESTATESNVPROC = CFuncPtr.fromPtr(ptr.asInstanceOf[Ptr[Byte]])
    inline def apply(inline o: CFuncPtr2[GLsizei, Ptr[GLuint], Unit]): PFNGLDELETESTATESNVPROC = o
    extension (v: PFNGLDELETESTATESNVPROC)
      inline def value: CFuncPtr2[GLsizei, Ptr[GLuint], Unit] = v
      inline def toPtr: Ptr[?] = CFuncPtr.toPtr(v)

  opaque type PFNGLDELETESYNCAPPLEPROC = CFuncPtr1[GLsync, Unit]
  object PFNGLDELETESYNCAPPLEPROC:
    given _tag: Tag[PFNGLDELETESYNCAPPLEPROC] = Tag.materializeCFuncPtr1[GLsync, Unit]
    inline def fromPtr(ptr: Ptr[Byte] | Ptr[?]): PFNGLDELETESYNCAPPLEPROC = CFuncPtr.fromPtr(ptr.asInstanceOf[Ptr[Byte]])
    inline def apply(inline o: CFuncPtr1[GLsync, Unit]): PFNGLDELETESYNCAPPLEPROC = o
    extension (v: PFNGLDELETESYNCAPPLEPROC)
      inline def value: CFuncPtr1[GLsync, Unit] = v
      inline def toPtr: Ptr[?] = CFuncPtr.toPtr(v)

  opaque type PFNGLDELETESYNCPROC = CFuncPtr1[GLsync, Unit]
  object PFNGLDELETESYNCPROC:
    given _tag: Tag[PFNGLDELETESYNCPROC] = Tag.materializeCFuncPtr1[GLsync, Unit]
    inline def fromPtr(ptr: Ptr[Byte] | Ptr[?]): PFNGLDELETESYNCPROC = CFuncPtr.fromPtr(ptr.asInstanceOf[Ptr[Byte]])
    inline def apply(inline o: CFuncPtr1[GLsync, Unit]): PFNGLDELETESYNCPROC = o
    extension (v: PFNGLDELETESYNCPROC)
      inline def value: CFuncPtr1[GLsync, Unit] = v
      inline def toPtr: Ptr[?] = CFuncPtr.toPtr(v)

  opaque type PFNGLDELETETEXTURESEXTPROC = CFuncPtr2[GLsizei, Ptr[GLuint], Unit]
  object PFNGLDELETETEXTURESEXTPROC:
    given _tag: Tag[PFNGLDELETETEXTURESEXTPROC] = Tag.materializeCFuncPtr2[GLsizei, Ptr[GLuint], Unit]
    inline def fromPtr(ptr: Ptr[Byte] | Ptr[?]): PFNGLDELETETEXTURESEXTPROC = CFuncPtr.fromPtr(ptr.asInstanceOf[Ptr[Byte]])
    inline def apply(inline o: CFuncPtr2[GLsizei, Ptr[GLuint], Unit]): PFNGLDELETETEXTURESEXTPROC = o
    extension (v: PFNGLDELETETEXTURESEXTPROC)
      inline def value: CFuncPtr2[GLsizei, Ptr[GLuint], Unit] = v
      inline def toPtr: Ptr[?] = CFuncPtr.toPtr(v)

  opaque type PFNGLDELETETRANSFORMFEEDBACKSNVPROC = CFuncPtr2[GLsizei, Ptr[GLuint], Unit]
  object PFNGLDELETETRANSFORMFEEDBACKSNVPROC:
    given _tag: Tag[PFNGLDELETETRANSFORMFEEDBACKSNVPROC] = Tag.materializeCFuncPtr2[GLsizei, Ptr[GLuint], Unit]
    inline def fromPtr(ptr: Ptr[Byte] | Ptr[?]): PFNGLDELETETRANSFORMFEEDBACKSNVPROC = CFuncPtr.fromPtr(ptr.asInstanceOf[Ptr[Byte]])
    inline def apply(inline o: CFuncPtr2[GLsizei, Ptr[GLuint], Unit]): PFNGLDELETETRANSFORMFEEDBACKSNVPROC = o
    extension (v: PFNGLDELETETRANSFORMFEEDBACKSNVPROC)
      inline def value: CFuncPtr2[GLsizei, Ptr[GLuint], Unit] = v
      inline def toPtr: Ptr[?] = CFuncPtr.toPtr(v)

  opaque type PFNGLDELETETRANSFORMFEEDBACKSPROC = CFuncPtr2[GLsizei, Ptr[GLuint], Unit]
  object PFNGLDELETETRANSFORMFEEDBACKSPROC:
    given _tag: Tag[PFNGLDELETETRANSFORMFEEDBACKSPROC] = Tag.materializeCFuncPtr2[GLsizei, Ptr[GLuint], Unit]
    inline def fromPtr(ptr: Ptr[Byte] | Ptr[?]): PFNGLDELETETRANSFORMFEEDBACKSPROC = CFuncPtr.fromPtr(ptr.asInstanceOf[Ptr[Byte]])
    inline def apply(inline o: CFuncPtr2[GLsizei, Ptr[GLuint], Unit]): PFNGLDELETETRANSFORMFEEDBACKSPROC = o
    extension (v: PFNGLDELETETRANSFORMFEEDBACKSPROC)
      inline def value: CFuncPtr2[GLsizei, Ptr[GLuint], Unit] = v
      inline def toPtr: Ptr[?] = CFuncPtr.toPtr(v)

  opaque type PFNGLDELETEVERTEXARRAYSAPPLEPROC = CFuncPtr2[GLsizei, Ptr[GLuint], Unit]
  object PFNGLDELETEVERTEXARRAYSAPPLEPROC:
    given _tag: Tag[PFNGLDELETEVERTEXARRAYSAPPLEPROC] = Tag.materializeCFuncPtr2[GLsizei, Ptr[GLuint], Unit]
    inline def fromPtr(ptr: Ptr[Byte] | Ptr[?]): PFNGLDELETEVERTEXARRAYSAPPLEPROC = CFuncPtr.fromPtr(ptr.asInstanceOf[Ptr[Byte]])
    inline def apply(inline o: CFuncPtr2[GLsizei, Ptr[GLuint], Unit]): PFNGLDELETEVERTEXARRAYSAPPLEPROC = o
    extension (v: PFNGLDELETEVERTEXARRAYSAPPLEPROC)
      inline def value: CFuncPtr2[GLsizei, Ptr[GLuint], Unit] = v
      inline def toPtr: Ptr[?] = CFuncPtr.toPtr(v)

  opaque type PFNGLDELETEVERTEXARRAYSOESPROC = CFuncPtr2[GLsizei, Ptr[GLuint], Unit]
  object PFNGLDELETEVERTEXARRAYSOESPROC:
    given _tag: Tag[PFNGLDELETEVERTEXARRAYSOESPROC] = Tag.materializeCFuncPtr2[GLsizei, Ptr[GLuint], Unit]
    inline def fromPtr(ptr: Ptr[Byte] | Ptr[?]): PFNGLDELETEVERTEXARRAYSOESPROC = CFuncPtr.fromPtr(ptr.asInstanceOf[Ptr[Byte]])
    inline def apply(inline o: CFuncPtr2[GLsizei, Ptr[GLuint], Unit]): PFNGLDELETEVERTEXARRAYSOESPROC = o
    extension (v: PFNGLDELETEVERTEXARRAYSOESPROC)
      inline def value: CFuncPtr2[GLsizei, Ptr[GLuint], Unit] = v
      inline def toPtr: Ptr[?] = CFuncPtr.toPtr(v)

  opaque type PFNGLDELETEVERTEXARRAYSPROC = CFuncPtr2[GLsizei, Ptr[GLuint], Unit]
  object PFNGLDELETEVERTEXARRAYSPROC:
    given _tag: Tag[PFNGLDELETEVERTEXARRAYSPROC] = Tag.materializeCFuncPtr2[GLsizei, Ptr[GLuint], Unit]
    inline def fromPtr(ptr: Ptr[Byte] | Ptr[?]): PFNGLDELETEVERTEXARRAYSPROC = CFuncPtr.fromPtr(ptr.asInstanceOf[Ptr[Byte]])
    inline def apply(inline o: CFuncPtr2[GLsizei, Ptr[GLuint], Unit]): PFNGLDELETEVERTEXARRAYSPROC = o
    extension (v: PFNGLDELETEVERTEXARRAYSPROC)
      inline def value: CFuncPtr2[GLsizei, Ptr[GLuint], Unit] = v
      inline def toPtr: Ptr[?] = CFuncPtr.toPtr(v)

  opaque type PFNGLDELETEVERTEXARRAYSSGIXPROC = CFuncPtr2[GLsizei, Ptr[GLuint], Unit]
  object PFNGLDELETEVERTEXARRAYSSGIXPROC:
    given _tag: Tag[PFNGLDELETEVERTEXARRAYSSGIXPROC] = Tag.materializeCFuncPtr2[GLsizei, Ptr[GLuint], Unit]
    inline def fromPtr(ptr: Ptr[Byte] | Ptr[?]): PFNGLDELETEVERTEXARRAYSSGIXPROC = CFuncPtr.fromPtr(ptr.asInstanceOf[Ptr[Byte]])
    inline def apply(inline o: CFuncPtr2[GLsizei, Ptr[GLuint], Unit]): PFNGLDELETEVERTEXARRAYSSGIXPROC = o
    extension (v: PFNGLDELETEVERTEXARRAYSSGIXPROC)
      inline def value: CFuncPtr2[GLsizei, Ptr[GLuint], Unit] = v
      inline def toPtr: Ptr[?] = CFuncPtr.toPtr(v)

  opaque type PFNGLDELETEVERTEXSHADEREXTPROC = CFuncPtr1[GLuint, Unit]
  object PFNGLDELETEVERTEXSHADEREXTPROC:
    given _tag: Tag[PFNGLDELETEVERTEXSHADEREXTPROC] = Tag.materializeCFuncPtr1[GLuint, Unit]
    inline def fromPtr(ptr: Ptr[Byte] | Ptr[?]): PFNGLDELETEVERTEXSHADEREXTPROC = CFuncPtr.fromPtr(ptr.asInstanceOf[Ptr[Byte]])
    inline def apply(inline o: CFuncPtr1[GLuint, Unit]): PFNGLDELETEVERTEXSHADEREXTPROC = o
    extension (v: PFNGLDELETEVERTEXSHADEREXTPROC)
      inline def value: CFuncPtr1[GLuint, Unit] = v
      inline def toPtr: Ptr[?] = CFuncPtr.toPtr(v)

  opaque type PFNGLDEPTHBOUNDSDNVPROC = CFuncPtr2[GLdouble, GLdouble, Unit]
  object PFNGLDEPTHBOUNDSDNVPROC:
    given _tag: Tag[PFNGLDEPTHBOUNDSDNVPROC] = Tag.materializeCFuncPtr2[GLdouble, GLdouble, Unit]
    inline def fromPtr(ptr: Ptr[Byte] | Ptr[?]): PFNGLDEPTHBOUNDSDNVPROC = CFuncPtr.fromPtr(ptr.asInstanceOf[Ptr[Byte]])
    inline def apply(inline o: CFuncPtr2[GLdouble, GLdouble, Unit]): PFNGLDEPTHBOUNDSDNVPROC = o
    extension (v: PFNGLDEPTHBOUNDSDNVPROC)
      inline def value: CFuncPtr2[GLdouble, GLdouble, Unit] = v
      inline def toPtr: Ptr[?] = CFuncPtr.toPtr(v)

  opaque type PFNGLDEPTHBOUNDSEXTPROC = CFuncPtr2[GLclampd, GLclampd, Unit]
  object PFNGLDEPTHBOUNDSEXTPROC:
    given _tag: Tag[PFNGLDEPTHBOUNDSEXTPROC] = Tag.materializeCFuncPtr2[GLclampd, GLclampd, Unit]
    inline def fromPtr(ptr: Ptr[Byte] | Ptr[?]): PFNGLDEPTHBOUNDSEXTPROC = CFuncPtr.fromPtr(ptr.asInstanceOf[Ptr[Byte]])
    inline def apply(inline o: CFuncPtr2[GLclampd, GLclampd, Unit]): PFNGLDEPTHBOUNDSEXTPROC = o
    extension (v: PFNGLDEPTHBOUNDSEXTPROC)
      inline def value: CFuncPtr2[GLclampd, GLclampd, Unit] = v
      inline def toPtr: Ptr[?] = CFuncPtr.toPtr(v)

  opaque type PFNGLDEPTHRANGEARRAYFVNVPROC = CFuncPtr3[GLuint, GLsizei, Ptr[GLfloat], Unit]
  object PFNGLDEPTHRANGEARRAYFVNVPROC:
    given _tag: Tag[PFNGLDEPTHRANGEARRAYFVNVPROC] = Tag.materializeCFuncPtr3[GLuint, GLsizei, Ptr[GLfloat], Unit]
    inline def fromPtr(ptr: Ptr[Byte] | Ptr[?]): PFNGLDEPTHRANGEARRAYFVNVPROC = CFuncPtr.fromPtr(ptr.asInstanceOf[Ptr[Byte]])
    inline def apply(inline o: CFuncPtr3[GLuint, GLsizei, Ptr[GLfloat], Unit]): PFNGLDEPTHRANGEARRAYFVNVPROC = o
    extension (v: PFNGLDEPTHRANGEARRAYFVNVPROC)
      inline def value: CFuncPtr3[GLuint, GLsizei, Ptr[GLfloat], Unit] = v
      inline def toPtr: Ptr[?] = CFuncPtr.toPtr(v)

  opaque type PFNGLDEPTHRANGEARRAYVPROC = CFuncPtr3[GLuint, GLsizei, Ptr[GLclampd], Unit]
  object PFNGLDEPTHRANGEARRAYVPROC:
    given _tag: Tag[PFNGLDEPTHRANGEARRAYVPROC] = Tag.materializeCFuncPtr3[GLuint, GLsizei, Ptr[GLclampd], Unit]
    inline def fromPtr(ptr: Ptr[Byte] | Ptr[?]): PFNGLDEPTHRANGEARRAYVPROC = CFuncPtr.fromPtr(ptr.asInstanceOf[Ptr[Byte]])
    inline def apply(inline o: CFuncPtr3[GLuint, GLsizei, Ptr[GLclampd], Unit]): PFNGLDEPTHRANGEARRAYVPROC = o
    extension (v: PFNGLDEPTHRANGEARRAYVPROC)
      inline def value: CFuncPtr3[GLuint, GLsizei, Ptr[GLclampd], Unit] = v
      inline def toPtr: Ptr[?] = CFuncPtr.toPtr(v)

  opaque type PFNGLDEPTHRANGEDNVPROC = CFuncPtr2[GLdouble, GLdouble, Unit]
  object PFNGLDEPTHRANGEDNVPROC:
    given _tag: Tag[PFNGLDEPTHRANGEDNVPROC] = Tag.materializeCFuncPtr2[GLdouble, GLdouble, Unit]
    inline def fromPtr(ptr: Ptr[Byte] | Ptr[?]): PFNGLDEPTHRANGEDNVPROC = CFuncPtr.fromPtr(ptr.asInstanceOf[Ptr[Byte]])
    inline def apply(inline o: CFuncPtr2[GLdouble, GLdouble, Unit]): PFNGLDEPTHRANGEDNVPROC = o
    extension (v: PFNGLDEPTHRANGEDNVPROC)
      inline def value: CFuncPtr2[GLdouble, GLdouble, Unit] = v
      inline def toPtr: Ptr[?] = CFuncPtr.toPtr(v)

  opaque type PFNGLDEPTHRANGEFOESPROC = CFuncPtr2[GLclampf, GLclampf, Unit]
  object PFNGLDEPTHRANGEFOESPROC:
    given _tag: Tag[PFNGLDEPTHRANGEFOESPROC] = Tag.materializeCFuncPtr2[GLclampf, GLclampf, Unit]
    inline def fromPtr(ptr: Ptr[Byte] | Ptr[?]): PFNGLDEPTHRANGEFOESPROC = CFuncPtr.fromPtr(ptr.asInstanceOf[Ptr[Byte]])
    inline def apply(inline o: CFuncPtr2[GLclampf, GLclampf, Unit]): PFNGLDEPTHRANGEFOESPROC = o
    extension (v: PFNGLDEPTHRANGEFOESPROC)
      inline def value: CFuncPtr2[GLclampf, GLclampf, Unit] = v
      inline def toPtr: Ptr[?] = CFuncPtr.toPtr(v)

  opaque type PFNGLDEPTHRANGEFPROC = CFuncPtr2[GLclampf, GLclampf, Unit]
  object PFNGLDEPTHRANGEFPROC:
    given _tag: Tag[PFNGLDEPTHRANGEFPROC] = Tag.materializeCFuncPtr2[GLclampf, GLclampf, Unit]
    inline def fromPtr(ptr: Ptr[Byte] | Ptr[?]): PFNGLDEPTHRANGEFPROC = CFuncPtr.fromPtr(ptr.asInstanceOf[Ptr[Byte]])
    inline def apply(inline o: CFuncPtr2[GLclampf, GLclampf, Unit]): PFNGLDEPTHRANGEFPROC = o
    extension (v: PFNGLDEPTHRANGEFPROC)
      inline def value: CFuncPtr2[GLclampf, GLclampf, Unit] = v
      inline def toPtr: Ptr[?] = CFuncPtr.toPtr(v)

  opaque type PFNGLDEPTHRANGEINDEXEDFNVPROC = CFuncPtr3[GLuint, GLfloat, GLfloat, Unit]
  object PFNGLDEPTHRANGEINDEXEDFNVPROC:
    given _tag: Tag[PFNGLDEPTHRANGEINDEXEDFNVPROC] = Tag.materializeCFuncPtr3[GLuint, GLfloat, GLfloat, Unit]
    inline def fromPtr(ptr: Ptr[Byte] | Ptr[?]): PFNGLDEPTHRANGEINDEXEDFNVPROC = CFuncPtr.fromPtr(ptr.asInstanceOf[Ptr[Byte]])
    inline def apply(inline o: CFuncPtr3[GLuint, GLfloat, GLfloat, Unit]): PFNGLDEPTHRANGEINDEXEDFNVPROC = o
    extension (v: PFNGLDEPTHRANGEINDEXEDFNVPROC)
      inline def value: CFuncPtr3[GLuint, GLfloat, GLfloat, Unit] = v
      inline def toPtr: Ptr[?] = CFuncPtr.toPtr(v)

  opaque type PFNGLDEPTHRANGEINDEXEDPROC = CFuncPtr3[GLuint, GLclampd, GLclampd, Unit]
  object PFNGLDEPTHRANGEINDEXEDPROC:
    given _tag: Tag[PFNGLDEPTHRANGEINDEXEDPROC] = Tag.materializeCFuncPtr3[GLuint, GLclampd, GLclampd, Unit]
    inline def fromPtr(ptr: Ptr[Byte] | Ptr[?]): PFNGLDEPTHRANGEINDEXEDPROC = CFuncPtr.fromPtr(ptr.asInstanceOf[Ptr[Byte]])
    inline def apply(inline o: CFuncPtr3[GLuint, GLclampd, GLclampd, Unit]): PFNGLDEPTHRANGEINDEXEDPROC = o
    extension (v: PFNGLDEPTHRANGEINDEXEDPROC)
      inline def value: CFuncPtr3[GLuint, GLclampd, GLclampd, Unit] = v
      inline def toPtr: Ptr[?] = CFuncPtr.toPtr(v)

  opaque type PFNGLDEPTHRANGEXPROC = CFuncPtr2[GLclampx, GLclampx, Unit]
  object PFNGLDEPTHRANGEXPROC:
    given _tag: Tag[PFNGLDEPTHRANGEXPROC] = Tag.materializeCFuncPtr2[GLclampx, GLclampx, Unit]
    inline def fromPtr(ptr: Ptr[Byte] | Ptr[?]): PFNGLDEPTHRANGEXPROC = CFuncPtr.fromPtr(ptr.asInstanceOf[Ptr[Byte]])
    inline def apply(inline o: CFuncPtr2[GLclampx, GLclampx, Unit]): PFNGLDEPTHRANGEXPROC = o
    extension (v: PFNGLDEPTHRANGEXPROC)
      inline def value: CFuncPtr2[GLclampx, GLclampx, Unit] = v
      inline def toPtr: Ptr[?] = CFuncPtr.toPtr(v)

  opaque type PFNGLDETACHOBJECTARBPROC = CFuncPtr2[GLhandleARB, GLhandleARB, Unit]
  object PFNGLDETACHOBJECTARBPROC:
    given _tag: Tag[PFNGLDETACHOBJECTARBPROC] = Tag.materializeCFuncPtr2[GLhandleARB, GLhandleARB, Unit]
    inline def fromPtr(ptr: Ptr[Byte] | Ptr[?]): PFNGLDETACHOBJECTARBPROC = CFuncPtr.fromPtr(ptr.asInstanceOf[Ptr[Byte]])
    inline def apply(inline o: CFuncPtr2[GLhandleARB, GLhandleARB, Unit]): PFNGLDETACHOBJECTARBPROC = o
    extension (v: PFNGLDETACHOBJECTARBPROC)
      inline def value: CFuncPtr2[GLhandleARB, GLhandleARB, Unit] = v
      inline def toPtr: Ptr[?] = CFuncPtr.toPtr(v)

  opaque type PFNGLDETACHSHADERPROC = CFuncPtr2[GLuint, GLuint, Unit]
  object PFNGLDETACHSHADERPROC:
    given _tag: Tag[PFNGLDETACHSHADERPROC] = Tag.materializeCFuncPtr2[GLuint, GLuint, Unit]
    inline def fromPtr(ptr: Ptr[Byte] | Ptr[?]): PFNGLDETACHSHADERPROC = CFuncPtr.fromPtr(ptr.asInstanceOf[Ptr[Byte]])
    inline def apply(inline o: CFuncPtr2[GLuint, GLuint, Unit]): PFNGLDETACHSHADERPROC = o
    extension (v: PFNGLDETACHSHADERPROC)
      inline def value: CFuncPtr2[GLuint, GLuint, Unit] = v
      inline def toPtr: Ptr[?] = CFuncPtr.toPtr(v)

  opaque type PFNGLDETAILTEXFUNCSGISPROC = CFuncPtr3[GLenum, GLsizei, Ptr[GLfloat], Unit]
  object PFNGLDETAILTEXFUNCSGISPROC:
    given _tag: Tag[PFNGLDETAILTEXFUNCSGISPROC] = Tag.materializeCFuncPtr3[GLenum, GLsizei, Ptr[GLfloat], Unit]
    inline def fromPtr(ptr: Ptr[Byte] | Ptr[?]): PFNGLDETAILTEXFUNCSGISPROC = CFuncPtr.fromPtr(ptr.asInstanceOf[Ptr[Byte]])
    inline def apply(inline o: CFuncPtr3[GLenum, GLsizei, Ptr[GLfloat], Unit]): PFNGLDETAILTEXFUNCSGISPROC = o
    extension (v: PFNGLDETAILTEXFUNCSGISPROC)
      inline def value: CFuncPtr3[GLenum, GLsizei, Ptr[GLfloat], Unit] = v
      inline def toPtr: Ptr[?] = CFuncPtr.toPtr(v)

  opaque type PFNGLDISABLECLIENTSTATEIEXTPROC = CFuncPtr2[GLenum, GLuint, Unit]
  object PFNGLDISABLECLIENTSTATEIEXTPROC:
    given _tag: Tag[PFNGLDISABLECLIENTSTATEIEXTPROC] = Tag.materializeCFuncPtr2[GLenum, GLuint, Unit]
    inline def fromPtr(ptr: Ptr[Byte] | Ptr[?]): PFNGLDISABLECLIENTSTATEIEXTPROC = CFuncPtr.fromPtr(ptr.asInstanceOf[Ptr[Byte]])
    inline def apply(inline o: CFuncPtr2[GLenum, GLuint, Unit]): PFNGLDISABLECLIENTSTATEIEXTPROC = o
    extension (v: PFNGLDISABLECLIENTSTATEIEXTPROC)
      inline def value: CFuncPtr2[GLenum, GLuint, Unit] = v
      inline def toPtr: Ptr[?] = CFuncPtr.toPtr(v)

  opaque type PFNGLDISABLECLIENTSTATEINDEXEDEXTPROC = CFuncPtr2[GLenum, GLuint, Unit]
  object PFNGLDISABLECLIENTSTATEINDEXEDEXTPROC:
    given _tag: Tag[PFNGLDISABLECLIENTSTATEINDEXEDEXTPROC] = Tag.materializeCFuncPtr2[GLenum, GLuint, Unit]
    inline def fromPtr(ptr: Ptr[Byte] | Ptr[?]): PFNGLDISABLECLIENTSTATEINDEXEDEXTPROC = CFuncPtr.fromPtr(ptr.asInstanceOf[Ptr[Byte]])
    inline def apply(inline o: CFuncPtr2[GLenum, GLuint, Unit]): PFNGLDISABLECLIENTSTATEINDEXEDEXTPROC = o
    extension (v: PFNGLDISABLECLIENTSTATEINDEXEDEXTPROC)
      inline def value: CFuncPtr2[GLenum, GLuint, Unit] = v
      inline def toPtr: Ptr[?] = CFuncPtr.toPtr(v)

  opaque type PFNGLDISABLEDRIVERCONTROLQCOMPROC = CFuncPtr1[GLuint, Unit]
  object PFNGLDISABLEDRIVERCONTROLQCOMPROC:
    given _tag: Tag[PFNGLDISABLEDRIVERCONTROLQCOMPROC] = Tag.materializeCFuncPtr1[GLuint, Unit]
    inline def fromPtr(ptr: Ptr[Byte] | Ptr[?]): PFNGLDISABLEDRIVERCONTROLQCOMPROC = CFuncPtr.fromPtr(ptr.asInstanceOf[Ptr[Byte]])
    inline def apply(inline o: CFuncPtr1[GLuint, Unit]): PFNGLDISABLEDRIVERCONTROLQCOMPROC = o
    extension (v: PFNGLDISABLEDRIVERCONTROLQCOMPROC)
      inline def value: CFuncPtr1[GLuint, Unit] = v
      inline def toPtr: Ptr[?] = CFuncPtr.toPtr(v)

  opaque type PFNGLDISABLEIEXTPROC = CFuncPtr2[GLenum, GLuint, Unit]
  object PFNGLDISABLEIEXTPROC:
    given _tag: Tag[PFNGLDISABLEIEXTPROC] = Tag.materializeCFuncPtr2[GLenum, GLuint, Unit]
    inline def fromPtr(ptr: Ptr[Byte] | Ptr[?]): PFNGLDISABLEIEXTPROC = CFuncPtr.fromPtr(ptr.asInstanceOf[Ptr[Byte]])
    inline def apply(inline o: CFuncPtr2[GLenum, GLuint, Unit]): PFNGLDISABLEIEXTPROC = o
    extension (v: PFNGLDISABLEIEXTPROC)
      inline def value: CFuncPtr2[GLenum, GLuint, Unit] = v
      inline def toPtr: Ptr[?] = CFuncPtr.toPtr(v)

  opaque type PFNGLDISABLEINDEXEDEXTPROC = CFuncPtr2[GLenum, GLuint, Unit]
  object PFNGLDISABLEINDEXEDEXTPROC:
    given _tag: Tag[PFNGLDISABLEINDEXEDEXTPROC] = Tag.materializeCFuncPtr2[GLenum, GLuint, Unit]
    inline def fromPtr(ptr: Ptr[Byte] | Ptr[?]): PFNGLDISABLEINDEXEDEXTPROC = CFuncPtr.fromPtr(ptr.asInstanceOf[Ptr[Byte]])
    inline def apply(inline o: CFuncPtr2[GLenum, GLuint, Unit]): PFNGLDISABLEINDEXEDEXTPROC = o
    extension (v: PFNGLDISABLEINDEXEDEXTPROC)
      inline def value: CFuncPtr2[GLenum, GLuint, Unit] = v
      inline def toPtr: Ptr[?] = CFuncPtr.toPtr(v)

  opaque type PFNGLDISABLEINVPROC = CFuncPtr2[GLenum, GLuint, Unit]
  object PFNGLDISABLEINVPROC:
    given _tag: Tag[PFNGLDISABLEINVPROC] = Tag.materializeCFuncPtr2[GLenum, GLuint, Unit]
    inline def fromPtr(ptr: Ptr[Byte] | Ptr[?]): PFNGLDISABLEINVPROC = CFuncPtr.fromPtr(ptr.asInstanceOf[Ptr[Byte]])
    inline def apply(inline o: CFuncPtr2[GLenum, GLuint, Unit]): PFNGLDISABLEINVPROC = o
    extension (v: PFNGLDISABLEINVPROC)
      inline def value: CFuncPtr2[GLenum, GLuint, Unit] = v
      inline def toPtr: Ptr[?] = CFuncPtr.toPtr(v)

  opaque type PFNGLDISABLEIOESPROC = CFuncPtr2[GLenum, GLuint, Unit]
  object PFNGLDISABLEIOESPROC:
    given _tag: Tag[PFNGLDISABLEIOESPROC] = Tag.materializeCFuncPtr2[GLenum, GLuint, Unit]
    inline def fromPtr(ptr: Ptr[Byte] | Ptr[?]): PFNGLDISABLEIOESPROC = CFuncPtr.fromPtr(ptr.asInstanceOf[Ptr[Byte]])
    inline def apply(inline o: CFuncPtr2[GLenum, GLuint, Unit]): PFNGLDISABLEIOESPROC = o
    extension (v: PFNGLDISABLEIOESPROC)
      inline def value: CFuncPtr2[GLenum, GLuint, Unit] = v
      inline def toPtr: Ptr[?] = CFuncPtr.toPtr(v)

  opaque type PFNGLDISABLEIPROC = CFuncPtr2[GLenum, GLuint, Unit]
  object PFNGLDISABLEIPROC:
    given _tag: Tag[PFNGLDISABLEIPROC] = Tag.materializeCFuncPtr2[GLenum, GLuint, Unit]
    inline def fromPtr(ptr: Ptr[Byte] | Ptr[?]): PFNGLDISABLEIPROC = CFuncPtr.fromPtr(ptr.asInstanceOf[Ptr[Byte]])
    inline def apply(inline o: CFuncPtr2[GLenum, GLuint, Unit]): PFNGLDISABLEIPROC = o
    extension (v: PFNGLDISABLEIPROC)
      inline def value: CFuncPtr2[GLenum, GLuint, Unit] = v
      inline def toPtr: Ptr[?] = CFuncPtr.toPtr(v)

  opaque type PFNGLDISABLEVARIANTCLIENTSTATEEXTPROC = CFuncPtr1[GLuint, Unit]
  object PFNGLDISABLEVARIANTCLIENTSTATEEXTPROC:
    given _tag: Tag[PFNGLDISABLEVARIANTCLIENTSTATEEXTPROC] = Tag.materializeCFuncPtr1[GLuint, Unit]
    inline def fromPtr(ptr: Ptr[Byte] | Ptr[?]): PFNGLDISABLEVARIANTCLIENTSTATEEXTPROC = CFuncPtr.fromPtr(ptr.asInstanceOf[Ptr[Byte]])
    inline def apply(inline o: CFuncPtr1[GLuint, Unit]): PFNGLDISABLEVARIANTCLIENTSTATEEXTPROC = o
    extension (v: PFNGLDISABLEVARIANTCLIENTSTATEEXTPROC)
      inline def value: CFuncPtr1[GLuint, Unit] = v
      inline def toPtr: Ptr[?] = CFuncPtr.toPtr(v)

  opaque type PFNGLDISABLEVERTEXARRAYATTRIBEXTPROC = CFuncPtr2[GLuint, GLuint, Unit]
  object PFNGLDISABLEVERTEXARRAYATTRIBEXTPROC:
    given _tag: Tag[PFNGLDISABLEVERTEXARRAYATTRIBEXTPROC] = Tag.materializeCFuncPtr2[GLuint, GLuint, Unit]
    inline def fromPtr(ptr: Ptr[Byte] | Ptr[?]): PFNGLDISABLEVERTEXARRAYATTRIBEXTPROC = CFuncPtr.fromPtr(ptr.asInstanceOf[Ptr[Byte]])
    inline def apply(inline o: CFuncPtr2[GLuint, GLuint, Unit]): PFNGLDISABLEVERTEXARRAYATTRIBEXTPROC = o
    extension (v: PFNGLDISABLEVERTEXARRAYATTRIBEXTPROC)
      inline def value: CFuncPtr2[GLuint, GLuint, Unit] = v
      inline def toPtr: Ptr[?] = CFuncPtr.toPtr(v)

  opaque type PFNGLDISABLEVERTEXARRAYATTRIBPROC = CFuncPtr2[GLuint, GLuint, Unit]
  object PFNGLDISABLEVERTEXARRAYATTRIBPROC:
    given _tag: Tag[PFNGLDISABLEVERTEXARRAYATTRIBPROC] = Tag.materializeCFuncPtr2[GLuint, GLuint, Unit]
    inline def fromPtr(ptr: Ptr[Byte] | Ptr[?]): PFNGLDISABLEVERTEXARRAYATTRIBPROC = CFuncPtr.fromPtr(ptr.asInstanceOf[Ptr[Byte]])
    inline def apply(inline o: CFuncPtr2[GLuint, GLuint, Unit]): PFNGLDISABLEVERTEXARRAYATTRIBPROC = o
    extension (v: PFNGLDISABLEVERTEXARRAYATTRIBPROC)
      inline def value: CFuncPtr2[GLuint, GLuint, Unit] = v
      inline def toPtr: Ptr[?] = CFuncPtr.toPtr(v)

  opaque type PFNGLDISABLEVERTEXARRAYEXTPROC = CFuncPtr2[GLuint, GLenum, Unit]
  object PFNGLDISABLEVERTEXARRAYEXTPROC:
    given _tag: Tag[PFNGLDISABLEVERTEXARRAYEXTPROC] = Tag.materializeCFuncPtr2[GLuint, GLenum, Unit]
    inline def fromPtr(ptr: Ptr[Byte] | Ptr[?]): PFNGLDISABLEVERTEXARRAYEXTPROC = CFuncPtr.fromPtr(ptr.asInstanceOf[Ptr[Byte]])
    inline def apply(inline o: CFuncPtr2[GLuint, GLenum, Unit]): PFNGLDISABLEVERTEXARRAYEXTPROC = o
    extension (v: PFNGLDISABLEVERTEXARRAYEXTPROC)
      inline def value: CFuncPtr2[GLuint, GLenum, Unit] = v
      inline def toPtr: Ptr[?] = CFuncPtr.toPtr(v)

  opaque type PFNGLDISABLEVERTEXATTRIBAPPLEPROC = CFuncPtr2[GLuint, GLenum, Unit]
  object PFNGLDISABLEVERTEXATTRIBAPPLEPROC:
    given _tag: Tag[PFNGLDISABLEVERTEXATTRIBAPPLEPROC] = Tag.materializeCFuncPtr2[GLuint, GLenum, Unit]
    inline def fromPtr(ptr: Ptr[Byte] | Ptr[?]): PFNGLDISABLEVERTEXATTRIBAPPLEPROC = CFuncPtr.fromPtr(ptr.asInstanceOf[Ptr[Byte]])
    inline def apply(inline o: CFuncPtr2[GLuint, GLenum, Unit]): PFNGLDISABLEVERTEXATTRIBAPPLEPROC = o
    extension (v: PFNGLDISABLEVERTEXATTRIBAPPLEPROC)
      inline def value: CFuncPtr2[GLuint, GLenum, Unit] = v
      inline def toPtr: Ptr[?] = CFuncPtr.toPtr(v)

  opaque type PFNGLDISABLEVERTEXATTRIBARRAYARBPROC = CFuncPtr1[GLuint, Unit]
  object PFNGLDISABLEVERTEXATTRIBARRAYARBPROC:
    given _tag: Tag[PFNGLDISABLEVERTEXATTRIBARRAYARBPROC] = Tag.materializeCFuncPtr1[GLuint, Unit]
    inline def fromPtr(ptr: Ptr[Byte] | Ptr[?]): PFNGLDISABLEVERTEXATTRIBARRAYARBPROC = CFuncPtr.fromPtr(ptr.asInstanceOf[Ptr[Byte]])
    inline def apply(inline o: CFuncPtr1[GLuint, Unit]): PFNGLDISABLEVERTEXATTRIBARRAYARBPROC = o
    extension (v: PFNGLDISABLEVERTEXATTRIBARRAYARBPROC)
      inline def value: CFuncPtr1[GLuint, Unit] = v
      inline def toPtr: Ptr[?] = CFuncPtr.toPtr(v)

  opaque type PFNGLDISABLEVERTEXATTRIBARRAYPROC = CFuncPtr1[GLuint, Unit]
  object PFNGLDISABLEVERTEXATTRIBARRAYPROC:
    given _tag: Tag[PFNGLDISABLEVERTEXATTRIBARRAYPROC] = Tag.materializeCFuncPtr1[GLuint, Unit]
    inline def fromPtr(ptr: Ptr[Byte] | Ptr[?]): PFNGLDISABLEVERTEXATTRIBARRAYPROC = CFuncPtr.fromPtr(ptr.asInstanceOf[Ptr[Byte]])
    inline def apply(inline o: CFuncPtr1[GLuint, Unit]): PFNGLDISABLEVERTEXATTRIBARRAYPROC = o
    extension (v: PFNGLDISABLEVERTEXATTRIBARRAYPROC)
      inline def value: CFuncPtr1[GLuint, Unit] = v
      inline def toPtr: Ptr[?] = CFuncPtr.toPtr(v)

  opaque type PFNGLDISCARDFRAMEBUFFEREXTPROC = CFuncPtr3[GLenum, GLsizei, Ptr[GLenum], Unit]
  object PFNGLDISCARDFRAMEBUFFEREXTPROC:
    given _tag: Tag[PFNGLDISCARDFRAMEBUFFEREXTPROC] = Tag.materializeCFuncPtr3[GLenum, GLsizei, Ptr[GLenum], Unit]
    inline def fromPtr(ptr: Ptr[Byte] | Ptr[?]): PFNGLDISCARDFRAMEBUFFEREXTPROC = CFuncPtr.fromPtr(ptr.asInstanceOf[Ptr[Byte]])
    inline def apply(inline o: CFuncPtr3[GLenum, GLsizei, Ptr[GLenum], Unit]): PFNGLDISCARDFRAMEBUFFEREXTPROC = o
    extension (v: PFNGLDISCARDFRAMEBUFFEREXTPROC)
      inline def value: CFuncPtr3[GLenum, GLsizei, Ptr[GLenum], Unit] = v
      inline def toPtr: Ptr[?] = CFuncPtr.toPtr(v)

  opaque type PFNGLDISPATCHCOMPUTEGROUPSIZEARBPROC = CFuncPtr6[GLuint, GLuint, GLuint, GLuint, GLuint, GLuint, Unit]
  object PFNGLDISPATCHCOMPUTEGROUPSIZEARBPROC:
    given _tag: Tag[PFNGLDISPATCHCOMPUTEGROUPSIZEARBPROC] = Tag.materializeCFuncPtr6[GLuint, GLuint, GLuint, GLuint, GLuint, GLuint, Unit]
    inline def fromPtr(ptr: Ptr[Byte] | Ptr[?]): PFNGLDISPATCHCOMPUTEGROUPSIZEARBPROC = CFuncPtr.fromPtr(ptr.asInstanceOf[Ptr[Byte]])
    inline def apply(inline o: CFuncPtr6[GLuint, GLuint, GLuint, GLuint, GLuint, GLuint, Unit]): PFNGLDISPATCHCOMPUTEGROUPSIZEARBPROC = o
    extension (v: PFNGLDISPATCHCOMPUTEGROUPSIZEARBPROC)
      inline def value: CFuncPtr6[GLuint, GLuint, GLuint, GLuint, GLuint, GLuint, Unit] = v
      inline def toPtr: Ptr[?] = CFuncPtr.toPtr(v)

  opaque type PFNGLDISPATCHCOMPUTEINDIRECTPROC = CFuncPtr1[GLintptr, Unit]
  object PFNGLDISPATCHCOMPUTEINDIRECTPROC:
    given _tag: Tag[PFNGLDISPATCHCOMPUTEINDIRECTPROC] = Tag.materializeCFuncPtr1[GLintptr, Unit]
    inline def fromPtr(ptr: Ptr[Byte] | Ptr[?]): PFNGLDISPATCHCOMPUTEINDIRECTPROC = CFuncPtr.fromPtr(ptr.asInstanceOf[Ptr[Byte]])
    inline def apply(inline o: CFuncPtr1[GLintptr, Unit]): PFNGLDISPATCHCOMPUTEINDIRECTPROC = o
    extension (v: PFNGLDISPATCHCOMPUTEINDIRECTPROC)
      inline def value: CFuncPtr1[GLintptr, Unit] = v
      inline def toPtr: Ptr[?] = CFuncPtr.toPtr(v)

  opaque type PFNGLDISPATCHCOMPUTEPROC = CFuncPtr3[GLuint, GLuint, GLuint, Unit]
  object PFNGLDISPATCHCOMPUTEPROC:
    given _tag: Tag[PFNGLDISPATCHCOMPUTEPROC] = Tag.materializeCFuncPtr3[GLuint, GLuint, GLuint, Unit]
    inline def fromPtr(ptr: Ptr[Byte] | Ptr[?]): PFNGLDISPATCHCOMPUTEPROC = CFuncPtr.fromPtr(ptr.asInstanceOf[Ptr[Byte]])
    inline def apply(inline o: CFuncPtr3[GLuint, GLuint, GLuint, Unit]): PFNGLDISPATCHCOMPUTEPROC = o
    extension (v: PFNGLDISPATCHCOMPUTEPROC)
      inline def value: CFuncPtr3[GLuint, GLuint, GLuint, Unit] = v
      inline def toPtr: Ptr[?] = CFuncPtr.toPtr(v)

  opaque type PFNGLDRAWARRAYSEXTPROC = CFuncPtr3[GLenum, GLint, GLsizei, Unit]
  object PFNGLDRAWARRAYSEXTPROC:
    given _tag: Tag[PFNGLDRAWARRAYSEXTPROC] = Tag.materializeCFuncPtr3[GLenum, GLint, GLsizei, Unit]
    inline def fromPtr(ptr: Ptr[Byte] | Ptr[?]): PFNGLDRAWARRAYSEXTPROC = CFuncPtr.fromPtr(ptr.asInstanceOf[Ptr[Byte]])
    inline def apply(inline o: CFuncPtr3[GLenum, GLint, GLsizei, Unit]): PFNGLDRAWARRAYSEXTPROC = o
    extension (v: PFNGLDRAWARRAYSEXTPROC)
      inline def value: CFuncPtr3[GLenum, GLint, GLsizei, Unit] = v
      inline def toPtr: Ptr[?] = CFuncPtr.toPtr(v)

  opaque type PFNGLDRAWARRAYSINDIRECTPROC = CFuncPtr2[GLenum, Ptr[Byte], Unit]
  object PFNGLDRAWARRAYSINDIRECTPROC:
    given _tag: Tag[PFNGLDRAWARRAYSINDIRECTPROC] = Tag.materializeCFuncPtr2[GLenum, Ptr[Byte], Unit]
    inline def fromPtr(ptr: Ptr[Byte] | Ptr[?]): PFNGLDRAWARRAYSINDIRECTPROC = CFuncPtr.fromPtr(ptr.asInstanceOf[Ptr[Byte]])
    inline def apply(inline o: CFuncPtr2[GLenum, Ptr[Byte], Unit]): PFNGLDRAWARRAYSINDIRECTPROC = o
    extension (v: PFNGLDRAWARRAYSINDIRECTPROC)
      inline def value: CFuncPtr2[GLenum, Ptr[Byte], Unit] = v
      inline def toPtr: Ptr[?] = CFuncPtr.toPtr(v)

  opaque type PFNGLDRAWARRAYSINSTANCEDANGLEPROC = CFuncPtr4[GLenum, GLint, GLsizei, GLsizei, Unit]
  object PFNGLDRAWARRAYSINSTANCEDANGLEPROC:
    given _tag: Tag[PFNGLDRAWARRAYSINSTANCEDANGLEPROC] = Tag.materializeCFuncPtr4[GLenum, GLint, GLsizei, GLsizei, Unit]
    inline def fromPtr(ptr: Ptr[Byte] | Ptr[?]): PFNGLDRAWARRAYSINSTANCEDANGLEPROC = CFuncPtr.fromPtr(ptr.asInstanceOf[Ptr[Byte]])
    inline def apply(inline o: CFuncPtr4[GLenum, GLint, GLsizei, GLsizei, Unit]): PFNGLDRAWARRAYSINSTANCEDANGLEPROC = o
    extension (v: PFNGLDRAWARRAYSINSTANCEDANGLEPROC)
      inline def value: CFuncPtr4[GLenum, GLint, GLsizei, GLsizei, Unit] = v
      inline def toPtr: Ptr[?] = CFuncPtr.toPtr(v)

  opaque type PFNGLDRAWARRAYSINSTANCEDARBPROC = CFuncPtr4[GLenum, GLint, GLsizei, GLsizei, Unit]
  object PFNGLDRAWARRAYSINSTANCEDARBPROC:
    given _tag: Tag[PFNGLDRAWARRAYSINSTANCEDARBPROC] = Tag.materializeCFuncPtr4[GLenum, GLint, GLsizei, GLsizei, Unit]
    inline def fromPtr(ptr: Ptr[Byte] | Ptr[?]): PFNGLDRAWARRAYSINSTANCEDARBPROC = CFuncPtr.fromPtr(ptr.asInstanceOf[Ptr[Byte]])
    inline def apply(inline o: CFuncPtr4[GLenum, GLint, GLsizei, GLsizei, Unit]): PFNGLDRAWARRAYSINSTANCEDARBPROC = o
    extension (v: PFNGLDRAWARRAYSINSTANCEDARBPROC)
      inline def value: CFuncPtr4[GLenum, GLint, GLsizei, GLsizei, Unit] = v
      inline def toPtr: Ptr[?] = CFuncPtr.toPtr(v)

  opaque type PFNGLDRAWARRAYSINSTANCEDBASEINSTANCEEXTPROC = CFuncPtr5[GLenum, GLint, GLsizei, GLsizei, GLuint, Unit]
  object PFNGLDRAWARRAYSINSTANCEDBASEINSTANCEEXTPROC:
    given _tag: Tag[PFNGLDRAWARRAYSINSTANCEDBASEINSTANCEEXTPROC] = Tag.materializeCFuncPtr5[GLenum, GLint, GLsizei, GLsizei, GLuint, Unit]
    inline def fromPtr(ptr: Ptr[Byte] | Ptr[?]): PFNGLDRAWARRAYSINSTANCEDBASEINSTANCEEXTPROC = CFuncPtr.fromPtr(ptr.asInstanceOf[Ptr[Byte]])
    inline def apply(inline o: CFuncPtr5[GLenum, GLint, GLsizei, GLsizei, GLuint, Unit]): PFNGLDRAWARRAYSINSTANCEDBASEINSTANCEEXTPROC = o
    extension (v: PFNGLDRAWARRAYSINSTANCEDBASEINSTANCEEXTPROC)
      inline def value: CFuncPtr5[GLenum, GLint, GLsizei, GLsizei, GLuint, Unit] = v
      inline def toPtr: Ptr[?] = CFuncPtr.toPtr(v)

  opaque type PFNGLDRAWARRAYSINSTANCEDBASEINSTANCEPROC = CFuncPtr5[GLenum, GLint, GLsizei, GLsizei, GLuint, Unit]
  object PFNGLDRAWARRAYSINSTANCEDBASEINSTANCEPROC:
    given _tag: Tag[PFNGLDRAWARRAYSINSTANCEDBASEINSTANCEPROC] = Tag.materializeCFuncPtr5[GLenum, GLint, GLsizei, GLsizei, GLuint, Unit]
    inline def fromPtr(ptr: Ptr[Byte] | Ptr[?]): PFNGLDRAWARRAYSINSTANCEDBASEINSTANCEPROC = CFuncPtr.fromPtr(ptr.asInstanceOf[Ptr[Byte]])
    inline def apply(inline o: CFuncPtr5[GLenum, GLint, GLsizei, GLsizei, GLuint, Unit]): PFNGLDRAWARRAYSINSTANCEDBASEINSTANCEPROC = o
    extension (v: PFNGLDRAWARRAYSINSTANCEDBASEINSTANCEPROC)
      inline def value: CFuncPtr5[GLenum, GLint, GLsizei, GLsizei, GLuint, Unit] = v
      inline def toPtr: Ptr[?] = CFuncPtr.toPtr(v)

  opaque type PFNGLDRAWARRAYSINSTANCEDEXTPROC = CFuncPtr4[GLenum, GLint, GLsizei, GLsizei, Unit]
  object PFNGLDRAWARRAYSINSTANCEDEXTPROC:
    given _tag: Tag[PFNGLDRAWARRAYSINSTANCEDEXTPROC] = Tag.materializeCFuncPtr4[GLenum, GLint, GLsizei, GLsizei, Unit]
    inline def fromPtr(ptr: Ptr[Byte] | Ptr[?]): PFNGLDRAWARRAYSINSTANCEDEXTPROC = CFuncPtr.fromPtr(ptr.asInstanceOf[Ptr[Byte]])
    inline def apply(inline o: CFuncPtr4[GLenum, GLint, GLsizei, GLsizei, Unit]): PFNGLDRAWARRAYSINSTANCEDEXTPROC = o
    extension (v: PFNGLDRAWARRAYSINSTANCEDEXTPROC)
      inline def value: CFuncPtr4[GLenum, GLint, GLsizei, GLsizei, Unit] = v
      inline def toPtr: Ptr[?] = CFuncPtr.toPtr(v)

  opaque type PFNGLDRAWARRAYSINSTANCEDNVPROC = CFuncPtr4[GLenum, GLint, GLsizei, GLsizei, Unit]
  object PFNGLDRAWARRAYSINSTANCEDNVPROC:
    given _tag: Tag[PFNGLDRAWARRAYSINSTANCEDNVPROC] = Tag.materializeCFuncPtr4[GLenum, GLint, GLsizei, GLsizei, Unit]
    inline def fromPtr(ptr: Ptr[Byte] | Ptr[?]): PFNGLDRAWARRAYSINSTANCEDNVPROC = CFuncPtr.fromPtr(ptr.asInstanceOf[Ptr[Byte]])
    inline def apply(inline o: CFuncPtr4[GLenum, GLint, GLsizei, GLsizei, Unit]): PFNGLDRAWARRAYSINSTANCEDNVPROC = o
    extension (v: PFNGLDRAWARRAYSINSTANCEDNVPROC)
      inline def value: CFuncPtr4[GLenum, GLint, GLsizei, GLsizei, Unit] = v
      inline def toPtr: Ptr[?] = CFuncPtr.toPtr(v)

  opaque type PFNGLDRAWARRAYSINSTANCEDPROC = CFuncPtr4[GLenum, GLint, GLsizei, GLsizei, Unit]
  object PFNGLDRAWARRAYSINSTANCEDPROC:
    given _tag: Tag[PFNGLDRAWARRAYSINSTANCEDPROC] = Tag.materializeCFuncPtr4[GLenum, GLint, GLsizei, GLsizei, Unit]
    inline def fromPtr(ptr: Ptr[Byte] | Ptr[?]): PFNGLDRAWARRAYSINSTANCEDPROC = CFuncPtr.fromPtr(ptr.asInstanceOf[Ptr[Byte]])
    inline def apply(inline o: CFuncPtr4[GLenum, GLint, GLsizei, GLsizei, Unit]): PFNGLDRAWARRAYSINSTANCEDPROC = o
    extension (v: PFNGLDRAWARRAYSINSTANCEDPROC)
      inline def value: CFuncPtr4[GLenum, GLint, GLsizei, GLsizei, Unit] = v
      inline def toPtr: Ptr[?] = CFuncPtr.toPtr(v)

  opaque type PFNGLDRAWBUFFERREGIONPROC = CFuncPtr7[GLuint, GLint, GLint, GLsizei, GLsizei, GLint, GLint, Unit]
  object PFNGLDRAWBUFFERREGIONPROC:
    given _tag: Tag[PFNGLDRAWBUFFERREGIONPROC] = Tag.materializeCFuncPtr7[GLuint, GLint, GLint, GLsizei, GLsizei, GLint, GLint, Unit]
    inline def fromPtr(ptr: Ptr[Byte] | Ptr[?]): PFNGLDRAWBUFFERREGIONPROC = CFuncPtr.fromPtr(ptr.asInstanceOf[Ptr[Byte]])
    inline def apply(inline o: CFuncPtr7[GLuint, GLint, GLint, GLsizei, GLsizei, GLint, GLint, Unit]): PFNGLDRAWBUFFERREGIONPROC = o
    extension (v: PFNGLDRAWBUFFERREGIONPROC)
      inline def value: CFuncPtr7[GLuint, GLint, GLint, GLsizei, GLsizei, GLint, GLint, Unit] = v
      inline def toPtr: Ptr[?] = CFuncPtr.toPtr(v)

  opaque type PFNGLDRAWBUFFERSARBPROC = CFuncPtr2[GLsizei, Ptr[GLenum], Unit]
  object PFNGLDRAWBUFFERSARBPROC:
    given _tag: Tag[PFNGLDRAWBUFFERSARBPROC] = Tag.materializeCFuncPtr2[GLsizei, Ptr[GLenum], Unit]
    inline def fromPtr(ptr: Ptr[Byte] | Ptr[?]): PFNGLDRAWBUFFERSARBPROC = CFuncPtr.fromPtr(ptr.asInstanceOf[Ptr[Byte]])
    inline def apply(inline o: CFuncPtr2[GLsizei, Ptr[GLenum], Unit]): PFNGLDRAWBUFFERSARBPROC = o
    extension (v: PFNGLDRAWBUFFERSARBPROC)
      inline def value: CFuncPtr2[GLsizei, Ptr[GLenum], Unit] = v
      inline def toPtr: Ptr[?] = CFuncPtr.toPtr(v)

  opaque type PFNGLDRAWBUFFERSATIPROC = CFuncPtr2[GLsizei, Ptr[GLenum], Unit]
  object PFNGLDRAWBUFFERSATIPROC:
    given _tag: Tag[PFNGLDRAWBUFFERSATIPROC] = Tag.materializeCFuncPtr2[GLsizei, Ptr[GLenum], Unit]
    inline def fromPtr(ptr: Ptr[Byte] | Ptr[?]): PFNGLDRAWBUFFERSATIPROC = CFuncPtr.fromPtr(ptr.asInstanceOf[Ptr[Byte]])
    inline def apply(inline o: CFuncPtr2[GLsizei, Ptr[GLenum], Unit]): PFNGLDRAWBUFFERSATIPROC = o
    extension (v: PFNGLDRAWBUFFERSATIPROC)
      inline def value: CFuncPtr2[GLsizei, Ptr[GLenum], Unit] = v
      inline def toPtr: Ptr[?] = CFuncPtr.toPtr(v)

  opaque type PFNGLDRAWBUFFERSEXTPROC = CFuncPtr2[GLsizei, Ptr[GLenum], Unit]
  object PFNGLDRAWBUFFERSEXTPROC:
    given _tag: Tag[PFNGLDRAWBUFFERSEXTPROC] = Tag.materializeCFuncPtr2[GLsizei, Ptr[GLenum], Unit]
    inline def fromPtr(ptr: Ptr[Byte] | Ptr[?]): PFNGLDRAWBUFFERSEXTPROC = CFuncPtr.fromPtr(ptr.asInstanceOf[Ptr[Byte]])
    inline def apply(inline o: CFuncPtr2[GLsizei, Ptr[GLenum], Unit]): PFNGLDRAWBUFFERSEXTPROC = o
    extension (v: PFNGLDRAWBUFFERSEXTPROC)
      inline def value: CFuncPtr2[GLsizei, Ptr[GLenum], Unit] = v
      inline def toPtr: Ptr[?] = CFuncPtr.toPtr(v)

  opaque type PFNGLDRAWBUFFERSINDEXEDEXTPROC = CFuncPtr3[GLint, Ptr[GLenum], Ptr[GLint], Unit]
  object PFNGLDRAWBUFFERSINDEXEDEXTPROC:
    given _tag: Tag[PFNGLDRAWBUFFERSINDEXEDEXTPROC] = Tag.materializeCFuncPtr3[GLint, Ptr[GLenum], Ptr[GLint], Unit]
    inline def fromPtr(ptr: Ptr[Byte] | Ptr[?]): PFNGLDRAWBUFFERSINDEXEDEXTPROC = CFuncPtr.fromPtr(ptr.asInstanceOf[Ptr[Byte]])
    inline def apply(inline o: CFuncPtr3[GLint, Ptr[GLenum], Ptr[GLint], Unit]): PFNGLDRAWBUFFERSINDEXEDEXTPROC = o
    extension (v: PFNGLDRAWBUFFERSINDEXEDEXTPROC)
      inline def value: CFuncPtr3[GLint, Ptr[GLenum], Ptr[GLint], Unit] = v
      inline def toPtr: Ptr[?] = CFuncPtr.toPtr(v)

  opaque type PFNGLDRAWBUFFERSNVPROC = CFuncPtr2[GLsizei, Ptr[GLenum], Unit]
  object PFNGLDRAWBUFFERSNVPROC:
    given _tag: Tag[PFNGLDRAWBUFFERSNVPROC] = Tag.materializeCFuncPtr2[GLsizei, Ptr[GLenum], Unit]
    inline def fromPtr(ptr: Ptr[Byte] | Ptr[?]): PFNGLDRAWBUFFERSNVPROC = CFuncPtr.fromPtr(ptr.asInstanceOf[Ptr[Byte]])
    inline def apply(inline o: CFuncPtr2[GLsizei, Ptr[GLenum], Unit]): PFNGLDRAWBUFFERSNVPROC = o
    extension (v: PFNGLDRAWBUFFERSNVPROC)
      inline def value: CFuncPtr2[GLsizei, Ptr[GLenum], Unit] = v
      inline def toPtr: Ptr[?] = CFuncPtr.toPtr(v)

  opaque type PFNGLDRAWBUFFERSPROC = CFuncPtr2[GLsizei, Ptr[GLenum], Unit]
  object PFNGLDRAWBUFFERSPROC:
    given _tag: Tag[PFNGLDRAWBUFFERSPROC] = Tag.materializeCFuncPtr2[GLsizei, Ptr[GLenum], Unit]
    inline def fromPtr(ptr: Ptr[Byte] | Ptr[?]): PFNGLDRAWBUFFERSPROC = CFuncPtr.fromPtr(ptr.asInstanceOf[Ptr[Byte]])
    inline def apply(inline o: CFuncPtr2[GLsizei, Ptr[GLenum], Unit]): PFNGLDRAWBUFFERSPROC = o
    extension (v: PFNGLDRAWBUFFERSPROC)
      inline def value: CFuncPtr2[GLsizei, Ptr[GLenum], Unit] = v
      inline def toPtr: Ptr[?] = CFuncPtr.toPtr(v)

  opaque type PFNGLDRAWCOMMANDSADDRESSNVPROC = CFuncPtr4[GLenum, Ptr[GLuint64], Ptr[GLsizei], GLuint, Unit]
  object PFNGLDRAWCOMMANDSADDRESSNVPROC:
    given _tag: Tag[PFNGLDRAWCOMMANDSADDRESSNVPROC] = Tag.materializeCFuncPtr4[GLenum, Ptr[GLuint64], Ptr[GLsizei], GLuint, Unit]
    inline def fromPtr(ptr: Ptr[Byte] | Ptr[?]): PFNGLDRAWCOMMANDSADDRESSNVPROC = CFuncPtr.fromPtr(ptr.asInstanceOf[Ptr[Byte]])
    inline def apply(inline o: CFuncPtr4[GLenum, Ptr[GLuint64], Ptr[GLsizei], GLuint, Unit]): PFNGLDRAWCOMMANDSADDRESSNVPROC = o
    extension (v: PFNGLDRAWCOMMANDSADDRESSNVPROC)
      inline def value: CFuncPtr4[GLenum, Ptr[GLuint64], Ptr[GLsizei], GLuint, Unit] = v
      inline def toPtr: Ptr[?] = CFuncPtr.toPtr(v)

  opaque type PFNGLDRAWCOMMANDSNVPROC = CFuncPtr5[GLenum, GLuint, Ptr[GLintptr], Ptr[GLsizei], GLuint, Unit]
  object PFNGLDRAWCOMMANDSNVPROC:
    given _tag: Tag[PFNGLDRAWCOMMANDSNVPROC] = Tag.materializeCFuncPtr5[GLenum, GLuint, Ptr[GLintptr], Ptr[GLsizei], GLuint, Unit]
    inline def fromPtr(ptr: Ptr[Byte] | Ptr[?]): PFNGLDRAWCOMMANDSNVPROC = CFuncPtr.fromPtr(ptr.asInstanceOf[Ptr[Byte]])
    inline def apply(inline o: CFuncPtr5[GLenum, GLuint, Ptr[GLintptr], Ptr[GLsizei], GLuint, Unit]): PFNGLDRAWCOMMANDSNVPROC = o
    extension (v: PFNGLDRAWCOMMANDSNVPROC)
      inline def value: CFuncPtr5[GLenum, GLuint, Ptr[GLintptr], Ptr[GLsizei], GLuint, Unit] = v
      inline def toPtr: Ptr[?] = CFuncPtr.toPtr(v)

  opaque type PFNGLDRAWCOMMANDSSTATESADDRESSNVPROC = CFuncPtr5[Ptr[GLuint64], Ptr[GLsizei], Ptr[GLuint], Ptr[GLuint], GLuint, Unit]
  object PFNGLDRAWCOMMANDSSTATESADDRESSNVPROC:
    given _tag: Tag[PFNGLDRAWCOMMANDSSTATESADDRESSNVPROC] = Tag.materializeCFuncPtr5[Ptr[GLuint64], Ptr[GLsizei], Ptr[GLuint], Ptr[GLuint], GLuint, Unit]
    inline def fromPtr(ptr: Ptr[Byte] | Ptr[?]): PFNGLDRAWCOMMANDSSTATESADDRESSNVPROC = CFuncPtr.fromPtr(ptr.asInstanceOf[Ptr[Byte]])
    inline def apply(inline o: CFuncPtr5[Ptr[GLuint64], Ptr[GLsizei], Ptr[GLuint], Ptr[GLuint], GLuint, Unit]): PFNGLDRAWCOMMANDSSTATESADDRESSNVPROC = o
    extension (v: PFNGLDRAWCOMMANDSSTATESADDRESSNVPROC)
      inline def value: CFuncPtr5[Ptr[GLuint64], Ptr[GLsizei], Ptr[GLuint], Ptr[GLuint], GLuint, Unit] = v
      inline def toPtr: Ptr[?] = CFuncPtr.toPtr(v)

  opaque type PFNGLDRAWCOMMANDSSTATESNVPROC = CFuncPtr6[GLuint, Ptr[GLintptr], Ptr[GLsizei], Ptr[GLuint], Ptr[GLuint], GLuint, Unit]
  object PFNGLDRAWCOMMANDSSTATESNVPROC:
    given _tag: Tag[PFNGLDRAWCOMMANDSSTATESNVPROC] = Tag.materializeCFuncPtr6[GLuint, Ptr[GLintptr], Ptr[GLsizei], Ptr[GLuint], Ptr[GLuint], GLuint, Unit]
    inline def fromPtr(ptr: Ptr[Byte] | Ptr[?]): PFNGLDRAWCOMMANDSSTATESNVPROC = CFuncPtr.fromPtr(ptr.asInstanceOf[Ptr[Byte]])
    inline def apply(inline o: CFuncPtr6[GLuint, Ptr[GLintptr], Ptr[GLsizei], Ptr[GLuint], Ptr[GLuint], GLuint, Unit]): PFNGLDRAWCOMMANDSSTATESNVPROC = o
    extension (v: PFNGLDRAWCOMMANDSSTATESNVPROC)
      inline def value: CFuncPtr6[GLuint, Ptr[GLintptr], Ptr[GLsizei], Ptr[GLuint], Ptr[GLuint], GLuint, Unit] = v
      inline def toPtr: Ptr[?] = CFuncPtr.toPtr(v)

  opaque type PFNGLDRAWELEMENTARRAYAPPLEPROC = CFuncPtr3[GLenum, GLint, GLsizei, Unit]
  object PFNGLDRAWELEMENTARRAYAPPLEPROC:
    given _tag: Tag[PFNGLDRAWELEMENTARRAYAPPLEPROC] = Tag.materializeCFuncPtr3[GLenum, GLint, GLsizei, Unit]
    inline def fromPtr(ptr: Ptr[Byte] | Ptr[?]): PFNGLDRAWELEMENTARRAYAPPLEPROC = CFuncPtr.fromPtr(ptr.asInstanceOf[Ptr[Byte]])
    inline def apply(inline o: CFuncPtr3[GLenum, GLint, GLsizei, Unit]): PFNGLDRAWELEMENTARRAYAPPLEPROC = o
    extension (v: PFNGLDRAWELEMENTARRAYAPPLEPROC)
      inline def value: CFuncPtr3[GLenum, GLint, GLsizei, Unit] = v
      inline def toPtr: Ptr[?] = CFuncPtr.toPtr(v)

  opaque type PFNGLDRAWELEMENTARRAYATIPROC = CFuncPtr2[GLenum, GLsizei, Unit]
  object PFNGLDRAWELEMENTARRAYATIPROC:
    given _tag: Tag[PFNGLDRAWELEMENTARRAYATIPROC] = Tag.materializeCFuncPtr2[GLenum, GLsizei, Unit]
    inline def fromPtr(ptr: Ptr[Byte] | Ptr[?]): PFNGLDRAWELEMENTARRAYATIPROC = CFuncPtr.fromPtr(ptr.asInstanceOf[Ptr[Byte]])
    inline def apply(inline o: CFuncPtr2[GLenum, GLsizei, Unit]): PFNGLDRAWELEMENTARRAYATIPROC = o
    extension (v: PFNGLDRAWELEMENTARRAYATIPROC)
      inline def value: CFuncPtr2[GLenum, GLsizei, Unit] = v
      inline def toPtr: Ptr[?] = CFuncPtr.toPtr(v)

  opaque type PFNGLDRAWELEMENTSBASEVERTEXEXTPROC = CFuncPtr5[GLenum, GLsizei, GLenum, Ptr[Byte], GLint, Unit]
  object PFNGLDRAWELEMENTSBASEVERTEXEXTPROC:
    given _tag: Tag[PFNGLDRAWELEMENTSBASEVERTEXEXTPROC] = Tag.materializeCFuncPtr5[GLenum, GLsizei, GLenum, Ptr[Byte], GLint, Unit]
    inline def fromPtr(ptr: Ptr[Byte] | Ptr[?]): PFNGLDRAWELEMENTSBASEVERTEXEXTPROC = CFuncPtr.fromPtr(ptr.asInstanceOf[Ptr[Byte]])
    inline def apply(inline o: CFuncPtr5[GLenum, GLsizei, GLenum, Ptr[Byte], GLint, Unit]): PFNGLDRAWELEMENTSBASEVERTEXEXTPROC = o
    extension (v: PFNGLDRAWELEMENTSBASEVERTEXEXTPROC)
      inline def value: CFuncPtr5[GLenum, GLsizei, GLenum, Ptr[Byte], GLint, Unit] = v
      inline def toPtr: Ptr[?] = CFuncPtr.toPtr(v)

  opaque type PFNGLDRAWELEMENTSBASEVERTEXPROC = CFuncPtr5[GLenum, GLsizei, GLenum, Ptr[Byte], GLint, Unit]
  object PFNGLDRAWELEMENTSBASEVERTEXPROC:
    given _tag: Tag[PFNGLDRAWELEMENTSBASEVERTEXPROC] = Tag.materializeCFuncPtr5[GLenum, GLsizei, GLenum, Ptr[Byte], GLint, Unit]
    inline def fromPtr(ptr: Ptr[Byte] | Ptr[?]): PFNGLDRAWELEMENTSBASEVERTEXPROC = CFuncPtr.fromPtr(ptr.asInstanceOf[Ptr[Byte]])
    inline def apply(inline o: CFuncPtr5[GLenum, GLsizei, GLenum, Ptr[Byte], GLint, Unit]): PFNGLDRAWELEMENTSBASEVERTEXPROC = o
    extension (v: PFNGLDRAWELEMENTSBASEVERTEXPROC)
      inline def value: CFuncPtr5[GLenum, GLsizei, GLenum, Ptr[Byte], GLint, Unit] = v
      inline def toPtr: Ptr[?] = CFuncPtr.toPtr(v)

  opaque type PFNGLDRAWELEMENTSINDIRECTPROC = CFuncPtr3[GLenum, GLenum, Ptr[Byte], Unit]
  object PFNGLDRAWELEMENTSINDIRECTPROC:
    given _tag: Tag[PFNGLDRAWELEMENTSINDIRECTPROC] = Tag.materializeCFuncPtr3[GLenum, GLenum, Ptr[Byte], Unit]
    inline def fromPtr(ptr: Ptr[Byte] | Ptr[?]): PFNGLDRAWELEMENTSINDIRECTPROC = CFuncPtr.fromPtr(ptr.asInstanceOf[Ptr[Byte]])
    inline def apply(inline o: CFuncPtr3[GLenum, GLenum, Ptr[Byte], Unit]): PFNGLDRAWELEMENTSINDIRECTPROC = o
    extension (v: PFNGLDRAWELEMENTSINDIRECTPROC)
      inline def value: CFuncPtr3[GLenum, GLenum, Ptr[Byte], Unit] = v
      inline def toPtr: Ptr[?] = CFuncPtr.toPtr(v)

  opaque type PFNGLDRAWELEMENTSINSTANCEDANGLEPROC = CFuncPtr5[GLenum, GLsizei, GLenum, Ptr[Byte], GLsizei, Unit]
  object PFNGLDRAWELEMENTSINSTANCEDANGLEPROC:
    given _tag: Tag[PFNGLDRAWELEMENTSINSTANCEDANGLEPROC] = Tag.materializeCFuncPtr5[GLenum, GLsizei, GLenum, Ptr[Byte], GLsizei, Unit]
    inline def fromPtr(ptr: Ptr[Byte] | Ptr[?]): PFNGLDRAWELEMENTSINSTANCEDANGLEPROC = CFuncPtr.fromPtr(ptr.asInstanceOf[Ptr[Byte]])
    inline def apply(inline o: CFuncPtr5[GLenum, GLsizei, GLenum, Ptr[Byte], GLsizei, Unit]): PFNGLDRAWELEMENTSINSTANCEDANGLEPROC = o
    extension (v: PFNGLDRAWELEMENTSINSTANCEDANGLEPROC)
      inline def value: CFuncPtr5[GLenum, GLsizei, GLenum, Ptr[Byte], GLsizei, Unit] = v
      inline def toPtr: Ptr[?] = CFuncPtr.toPtr(v)

  opaque type PFNGLDRAWELEMENTSINSTANCEDARBPROC = CFuncPtr5[GLenum, GLsizei, GLenum, Ptr[Byte], GLsizei, Unit]
  object PFNGLDRAWELEMENTSINSTANCEDARBPROC:
    given _tag: Tag[PFNGLDRAWELEMENTSINSTANCEDARBPROC] = Tag.materializeCFuncPtr5[GLenum, GLsizei, GLenum, Ptr[Byte], GLsizei, Unit]
    inline def fromPtr(ptr: Ptr[Byte] | Ptr[?]): PFNGLDRAWELEMENTSINSTANCEDARBPROC = CFuncPtr.fromPtr(ptr.asInstanceOf[Ptr[Byte]])
    inline def apply(inline o: CFuncPtr5[GLenum, GLsizei, GLenum, Ptr[Byte], GLsizei, Unit]): PFNGLDRAWELEMENTSINSTANCEDARBPROC = o
    extension (v: PFNGLDRAWELEMENTSINSTANCEDARBPROC)
      inline def value: CFuncPtr5[GLenum, GLsizei, GLenum, Ptr[Byte], GLsizei, Unit] = v
      inline def toPtr: Ptr[?] = CFuncPtr.toPtr(v)

  opaque type PFNGLDRAWELEMENTSINSTANCEDBASEINSTANCEEXTPROC = CFuncPtr6[GLenum, GLsizei, GLenum, Ptr[Byte], GLsizei, GLuint, Unit]
  object PFNGLDRAWELEMENTSINSTANCEDBASEINSTANCEEXTPROC:
    given _tag: Tag[PFNGLDRAWELEMENTSINSTANCEDBASEINSTANCEEXTPROC] = Tag.materializeCFuncPtr6[GLenum, GLsizei, GLenum, Ptr[Byte], GLsizei, GLuint, Unit]
    inline def fromPtr(ptr: Ptr[Byte] | Ptr[?]): PFNGLDRAWELEMENTSINSTANCEDBASEINSTANCEEXTPROC = CFuncPtr.fromPtr(ptr.asInstanceOf[Ptr[Byte]])
    inline def apply(inline o: CFuncPtr6[GLenum, GLsizei, GLenum, Ptr[Byte], GLsizei, GLuint, Unit]): PFNGLDRAWELEMENTSINSTANCEDBASEINSTANCEEXTPROC = o
    extension (v: PFNGLDRAWELEMENTSINSTANCEDBASEINSTANCEEXTPROC)
      inline def value: CFuncPtr6[GLenum, GLsizei, GLenum, Ptr[Byte], GLsizei, GLuint, Unit] = v
      inline def toPtr: Ptr[?] = CFuncPtr.toPtr(v)

  opaque type PFNGLDRAWELEMENTSINSTANCEDBASEINSTANCEPROC = CFuncPtr6[GLenum, GLsizei, GLenum, Ptr[Byte], GLsizei, GLuint, Unit]
  object PFNGLDRAWELEMENTSINSTANCEDBASEINSTANCEPROC:
    given _tag: Tag[PFNGLDRAWELEMENTSINSTANCEDBASEINSTANCEPROC] = Tag.materializeCFuncPtr6[GLenum, GLsizei, GLenum, Ptr[Byte], GLsizei, GLuint, Unit]
    inline def fromPtr(ptr: Ptr[Byte] | Ptr[?]): PFNGLDRAWELEMENTSINSTANCEDBASEINSTANCEPROC = CFuncPtr.fromPtr(ptr.asInstanceOf[Ptr[Byte]])
    inline def apply(inline o: CFuncPtr6[GLenum, GLsizei, GLenum, Ptr[Byte], GLsizei, GLuint, Unit]): PFNGLDRAWELEMENTSINSTANCEDBASEINSTANCEPROC = o
    extension (v: PFNGLDRAWELEMENTSINSTANCEDBASEINSTANCEPROC)
      inline def value: CFuncPtr6[GLenum, GLsizei, GLenum, Ptr[Byte], GLsizei, GLuint, Unit] = v
      inline def toPtr: Ptr[?] = CFuncPtr.toPtr(v)

  opaque type PFNGLDRAWELEMENTSINSTANCEDBASEVERTEXBASEINSTANCEEXTPROC = CFuncPtr7[GLenum, GLsizei, GLenum, Ptr[Byte], GLsizei, GLint, GLuint, Unit]
  object PFNGLDRAWELEMENTSINSTANCEDBASEVERTEXBASEINSTANCEEXTPROC:
    given _tag: Tag[PFNGLDRAWELEMENTSINSTANCEDBASEVERTEXBASEINSTANCEEXTPROC] = Tag.materializeCFuncPtr7[GLenum, GLsizei, GLenum, Ptr[Byte], GLsizei, GLint, GLuint, Unit]
    inline def fromPtr(ptr: Ptr[Byte] | Ptr[?]): PFNGLDRAWELEMENTSINSTANCEDBASEVERTEXBASEINSTANCEEXTPROC = CFuncPtr.fromPtr(ptr.asInstanceOf[Ptr[Byte]])
    inline def apply(inline o: CFuncPtr7[GLenum, GLsizei, GLenum, Ptr[Byte], GLsizei, GLint, GLuint, Unit]): PFNGLDRAWELEMENTSINSTANCEDBASEVERTEXBASEINSTANCEEXTPROC = o
    extension (v: PFNGLDRAWELEMENTSINSTANCEDBASEVERTEXBASEINSTANCEEXTPROC)
      inline def value: CFuncPtr7[GLenum, GLsizei, GLenum, Ptr[Byte], GLsizei, GLint, GLuint, Unit] = v
      inline def toPtr: Ptr[?] = CFuncPtr.toPtr(v)

  opaque type PFNGLDRAWELEMENTSINSTANCEDBASEVERTEXBASEINSTANCEPROC = CFuncPtr7[GLenum, GLsizei, GLenum, Ptr[Byte], GLsizei, GLint, GLuint, Unit]
  object PFNGLDRAWELEMENTSINSTANCEDBASEVERTEXBASEINSTANCEPROC:
    given _tag: Tag[PFNGLDRAWELEMENTSINSTANCEDBASEVERTEXBASEINSTANCEPROC] = Tag.materializeCFuncPtr7[GLenum, GLsizei, GLenum, Ptr[Byte], GLsizei, GLint, GLuint, Unit]
    inline def fromPtr(ptr: Ptr[Byte] | Ptr[?]): PFNGLDRAWELEMENTSINSTANCEDBASEVERTEXBASEINSTANCEPROC = CFuncPtr.fromPtr(ptr.asInstanceOf[Ptr[Byte]])
    inline def apply(inline o: CFuncPtr7[GLenum, GLsizei, GLenum, Ptr[Byte], GLsizei, GLint, GLuint, Unit]): PFNGLDRAWELEMENTSINSTANCEDBASEVERTEXBASEINSTANCEPROC = o
    extension (v: PFNGLDRAWELEMENTSINSTANCEDBASEVERTEXBASEINSTANCEPROC)
      inline def value: CFuncPtr7[GLenum, GLsizei, GLenum, Ptr[Byte], GLsizei, GLint, GLuint, Unit] = v
      inline def toPtr: Ptr[?] = CFuncPtr.toPtr(v)

  opaque type PFNGLDRAWELEMENTSINSTANCEDBASEVERTEXEXTPROC = CFuncPtr6[GLenum, GLsizei, GLenum, Ptr[Byte], GLsizei, GLint, Unit]
  object PFNGLDRAWELEMENTSINSTANCEDBASEVERTEXEXTPROC:
    given _tag: Tag[PFNGLDRAWELEMENTSINSTANCEDBASEVERTEXEXTPROC] = Tag.materializeCFuncPtr6[GLenum, GLsizei, GLenum, Ptr[Byte], GLsizei, GLint, Unit]
    inline def fromPtr(ptr: Ptr[Byte] | Ptr[?]): PFNGLDRAWELEMENTSINSTANCEDBASEVERTEXEXTPROC = CFuncPtr.fromPtr(ptr.asInstanceOf[Ptr[Byte]])
    inline def apply(inline o: CFuncPtr6[GLenum, GLsizei, GLenum, Ptr[Byte], GLsizei, GLint, Unit]): PFNGLDRAWELEMENTSINSTANCEDBASEVERTEXEXTPROC = o
    extension (v: PFNGLDRAWELEMENTSINSTANCEDBASEVERTEXEXTPROC)
      inline def value: CFuncPtr6[GLenum, GLsizei, GLenum, Ptr[Byte], GLsizei, GLint, Unit] = v
      inline def toPtr: Ptr[?] = CFuncPtr.toPtr(v)

  opaque type PFNGLDRAWELEMENTSINSTANCEDBASEVERTEXPROC = CFuncPtr6[GLenum, GLsizei, GLenum, Ptr[Byte], GLsizei, GLint, Unit]
  object PFNGLDRAWELEMENTSINSTANCEDBASEVERTEXPROC:
    given _tag: Tag[PFNGLDRAWELEMENTSINSTANCEDBASEVERTEXPROC] = Tag.materializeCFuncPtr6[GLenum, GLsizei, GLenum, Ptr[Byte], GLsizei, GLint, Unit]
    inline def fromPtr(ptr: Ptr[Byte] | Ptr[?]): PFNGLDRAWELEMENTSINSTANCEDBASEVERTEXPROC = CFuncPtr.fromPtr(ptr.asInstanceOf[Ptr[Byte]])
    inline def apply(inline o: CFuncPtr6[GLenum, GLsizei, GLenum, Ptr[Byte], GLsizei, GLint, Unit]): PFNGLDRAWELEMENTSINSTANCEDBASEVERTEXPROC = o
    extension (v: PFNGLDRAWELEMENTSINSTANCEDBASEVERTEXPROC)
      inline def value: CFuncPtr6[GLenum, GLsizei, GLenum, Ptr[Byte], GLsizei, GLint, Unit] = v
      inline def toPtr: Ptr[?] = CFuncPtr.toPtr(v)

  opaque type PFNGLDRAWELEMENTSINSTANCEDEXTPROC = CFuncPtr5[GLenum, GLsizei, GLenum, Ptr[Byte], GLsizei, Unit]
  object PFNGLDRAWELEMENTSINSTANCEDEXTPROC:
    given _tag: Tag[PFNGLDRAWELEMENTSINSTANCEDEXTPROC] = Tag.materializeCFuncPtr5[GLenum, GLsizei, GLenum, Ptr[Byte], GLsizei, Unit]
    inline def fromPtr(ptr: Ptr[Byte] | Ptr[?]): PFNGLDRAWELEMENTSINSTANCEDEXTPROC = CFuncPtr.fromPtr(ptr.asInstanceOf[Ptr[Byte]])
    inline def apply(inline o: CFuncPtr5[GLenum, GLsizei, GLenum, Ptr[Byte], GLsizei, Unit]): PFNGLDRAWELEMENTSINSTANCEDEXTPROC = o
    extension (v: PFNGLDRAWELEMENTSINSTANCEDEXTPROC)
      inline def value: CFuncPtr5[GLenum, GLsizei, GLenum, Ptr[Byte], GLsizei, Unit] = v
      inline def toPtr: Ptr[?] = CFuncPtr.toPtr(v)

  opaque type PFNGLDRAWELEMENTSINSTANCEDNVPROC = CFuncPtr5[GLenum, GLsizei, GLenum, Ptr[Byte], GLsizei, Unit]
  object PFNGLDRAWELEMENTSINSTANCEDNVPROC:
    given _tag: Tag[PFNGLDRAWELEMENTSINSTANCEDNVPROC] = Tag.materializeCFuncPtr5[GLenum, GLsizei, GLenum, Ptr[Byte], GLsizei, Unit]
    inline def fromPtr(ptr: Ptr[Byte] | Ptr[?]): PFNGLDRAWELEMENTSINSTANCEDNVPROC = CFuncPtr.fromPtr(ptr.asInstanceOf[Ptr[Byte]])
    inline def apply(inline o: CFuncPtr5[GLenum, GLsizei, GLenum, Ptr[Byte], GLsizei, Unit]): PFNGLDRAWELEMENTSINSTANCEDNVPROC = o
    extension (v: PFNGLDRAWELEMENTSINSTANCEDNVPROC)
      inline def value: CFuncPtr5[GLenum, GLsizei, GLenum, Ptr[Byte], GLsizei, Unit] = v
      inline def toPtr: Ptr[?] = CFuncPtr.toPtr(v)

  opaque type PFNGLDRAWELEMENTSINSTANCEDPROC = CFuncPtr5[GLenum, GLsizei, GLenum, Ptr[Byte], GLsizei, Unit]
  object PFNGLDRAWELEMENTSINSTANCEDPROC:
    given _tag: Tag[PFNGLDRAWELEMENTSINSTANCEDPROC] = Tag.materializeCFuncPtr5[GLenum, GLsizei, GLenum, Ptr[Byte], GLsizei, Unit]
    inline def fromPtr(ptr: Ptr[Byte] | Ptr[?]): PFNGLDRAWELEMENTSINSTANCEDPROC = CFuncPtr.fromPtr(ptr.asInstanceOf[Ptr[Byte]])
    inline def apply(inline o: CFuncPtr5[GLenum, GLsizei, GLenum, Ptr[Byte], GLsizei, Unit]): PFNGLDRAWELEMENTSINSTANCEDPROC = o
    extension (v: PFNGLDRAWELEMENTSINSTANCEDPROC)
      inline def value: CFuncPtr5[GLenum, GLsizei, GLenum, Ptr[Byte], GLsizei, Unit] = v
      inline def toPtr: Ptr[?] = CFuncPtr.toPtr(v)

  opaque type PFNGLDRAWMESHTASKSINDIRECTNVPROC = CFuncPtr1[GLintptr, Unit]
  object PFNGLDRAWMESHTASKSINDIRECTNVPROC:
    given _tag: Tag[PFNGLDRAWMESHTASKSINDIRECTNVPROC] = Tag.materializeCFuncPtr1[GLintptr, Unit]
    inline def fromPtr(ptr: Ptr[Byte] | Ptr[?]): PFNGLDRAWMESHTASKSINDIRECTNVPROC = CFuncPtr.fromPtr(ptr.asInstanceOf[Ptr[Byte]])
    inline def apply(inline o: CFuncPtr1[GLintptr, Unit]): PFNGLDRAWMESHTASKSINDIRECTNVPROC = o
    extension (v: PFNGLDRAWMESHTASKSINDIRECTNVPROC)
      inline def value: CFuncPtr1[GLintptr, Unit] = v
      inline def toPtr: Ptr[?] = CFuncPtr.toPtr(v)

  opaque type PFNGLDRAWMESHTASKSNVPROC = CFuncPtr2[GLuint, GLuint, Unit]
  object PFNGLDRAWMESHTASKSNVPROC:
    given _tag: Tag[PFNGLDRAWMESHTASKSNVPROC] = Tag.materializeCFuncPtr2[GLuint, GLuint, Unit]
    inline def fromPtr(ptr: Ptr[Byte] | Ptr[?]): PFNGLDRAWMESHTASKSNVPROC = CFuncPtr.fromPtr(ptr.asInstanceOf[Ptr[Byte]])
    inline def apply(inline o: CFuncPtr2[GLuint, GLuint, Unit]): PFNGLDRAWMESHTASKSNVPROC = o
    extension (v: PFNGLDRAWMESHTASKSNVPROC)
      inline def value: CFuncPtr2[GLuint, GLuint, Unit] = v
      inline def toPtr: Ptr[?] = CFuncPtr.toPtr(v)

  opaque type PFNGLDRAWRANGEELEMENTARRAYAPPLEPROC = CFuncPtr5[GLenum, GLuint, GLuint, GLint, GLsizei, Unit]
  object PFNGLDRAWRANGEELEMENTARRAYAPPLEPROC:
    given _tag: Tag[PFNGLDRAWRANGEELEMENTARRAYAPPLEPROC] = Tag.materializeCFuncPtr5[GLenum, GLuint, GLuint, GLint, GLsizei, Unit]
    inline def fromPtr(ptr: Ptr[Byte] | Ptr[?]): PFNGLDRAWRANGEELEMENTARRAYAPPLEPROC = CFuncPtr.fromPtr(ptr.asInstanceOf[Ptr[Byte]])
    inline def apply(inline o: CFuncPtr5[GLenum, GLuint, GLuint, GLint, GLsizei, Unit]): PFNGLDRAWRANGEELEMENTARRAYAPPLEPROC = o
    extension (v: PFNGLDRAWRANGEELEMENTARRAYAPPLEPROC)
      inline def value: CFuncPtr5[GLenum, GLuint, GLuint, GLint, GLsizei, Unit] = v
      inline def toPtr: Ptr[?] = CFuncPtr.toPtr(v)

  opaque type PFNGLDRAWRANGEELEMENTARRAYATIPROC = CFuncPtr4[GLenum, GLuint, GLuint, GLsizei, Unit]
  object PFNGLDRAWRANGEELEMENTARRAYATIPROC:
    given _tag: Tag[PFNGLDRAWRANGEELEMENTARRAYATIPROC] = Tag.materializeCFuncPtr4[GLenum, GLuint, GLuint, GLsizei, Unit]
    inline def fromPtr(ptr: Ptr[Byte] | Ptr[?]): PFNGLDRAWRANGEELEMENTARRAYATIPROC = CFuncPtr.fromPtr(ptr.asInstanceOf[Ptr[Byte]])
    inline def apply(inline o: CFuncPtr4[GLenum, GLuint, GLuint, GLsizei, Unit]): PFNGLDRAWRANGEELEMENTARRAYATIPROC = o
    extension (v: PFNGLDRAWRANGEELEMENTARRAYATIPROC)
      inline def value: CFuncPtr4[GLenum, GLuint, GLuint, GLsizei, Unit] = v
      inline def toPtr: Ptr[?] = CFuncPtr.toPtr(v)

  opaque type PFNGLDRAWRANGEELEMENTSBASEVERTEXEXTPROC = CFuncPtr7[GLenum, GLuint, GLuint, GLsizei, GLenum, Ptr[Byte], GLint, Unit]
  object PFNGLDRAWRANGEELEMENTSBASEVERTEXEXTPROC:
    given _tag: Tag[PFNGLDRAWRANGEELEMENTSBASEVERTEXEXTPROC] = Tag.materializeCFuncPtr7[GLenum, GLuint, GLuint, GLsizei, GLenum, Ptr[Byte], GLint, Unit]
    inline def fromPtr(ptr: Ptr[Byte] | Ptr[?]): PFNGLDRAWRANGEELEMENTSBASEVERTEXEXTPROC = CFuncPtr.fromPtr(ptr.asInstanceOf[Ptr[Byte]])
    inline def apply(inline o: CFuncPtr7[GLenum, GLuint, GLuint, GLsizei, GLenum, Ptr[Byte], GLint, Unit]): PFNGLDRAWRANGEELEMENTSBASEVERTEXEXTPROC = o
    extension (v: PFNGLDRAWRANGEELEMENTSBASEVERTEXEXTPROC)
      inline def value: CFuncPtr7[GLenum, GLuint, GLuint, GLsizei, GLenum, Ptr[Byte], GLint, Unit] = v
      inline def toPtr: Ptr[?] = CFuncPtr.toPtr(v)

  opaque type PFNGLDRAWRANGEELEMENTSBASEVERTEXPROC = CFuncPtr7[GLenum, GLuint, GLuint, GLsizei, GLenum, Ptr[Byte], GLint, Unit]
  object PFNGLDRAWRANGEELEMENTSBASEVERTEXPROC:
    given _tag: Tag[PFNGLDRAWRANGEELEMENTSBASEVERTEXPROC] = Tag.materializeCFuncPtr7[GLenum, GLuint, GLuint, GLsizei, GLenum, Ptr[Byte], GLint, Unit]
    inline def fromPtr(ptr: Ptr[Byte] | Ptr[?]): PFNGLDRAWRANGEELEMENTSBASEVERTEXPROC = CFuncPtr.fromPtr(ptr.asInstanceOf[Ptr[Byte]])
    inline def apply(inline o: CFuncPtr7[GLenum, GLuint, GLuint, GLsizei, GLenum, Ptr[Byte], GLint, Unit]): PFNGLDRAWRANGEELEMENTSBASEVERTEXPROC = o
    extension (v: PFNGLDRAWRANGEELEMENTSBASEVERTEXPROC)
      inline def value: CFuncPtr7[GLenum, GLuint, GLuint, GLsizei, GLenum, Ptr[Byte], GLint, Unit] = v
      inline def toPtr: Ptr[?] = CFuncPtr.toPtr(v)

  opaque type PFNGLDRAWRANGEELEMENTSEXTPROC = CFuncPtr6[GLenum, GLuint, GLuint, GLsizei, GLenum, Ptr[Byte], Unit]
  object PFNGLDRAWRANGEELEMENTSEXTPROC:
    given _tag: Tag[PFNGLDRAWRANGEELEMENTSEXTPROC] = Tag.materializeCFuncPtr6[GLenum, GLuint, GLuint, GLsizei, GLenum, Ptr[Byte], Unit]
    inline def fromPtr(ptr: Ptr[Byte] | Ptr[?]): PFNGLDRAWRANGEELEMENTSEXTPROC = CFuncPtr.fromPtr(ptr.asInstanceOf[Ptr[Byte]])
    inline def apply(inline o: CFuncPtr6[GLenum, GLuint, GLuint, GLsizei, GLenum, Ptr[Byte], Unit]): PFNGLDRAWRANGEELEMENTSEXTPROC = o
    extension (v: PFNGLDRAWRANGEELEMENTSEXTPROC)
      inline def value: CFuncPtr6[GLenum, GLuint, GLuint, GLsizei, GLenum, Ptr[Byte], Unit] = v
      inline def toPtr: Ptr[?] = CFuncPtr.toPtr(v)

  opaque type PFNGLDRAWRANGEELEMENTSPROC = CFuncPtr6[GLenum, GLuint, GLuint, GLsizei, GLenum, Ptr[Byte], Unit]
  object PFNGLDRAWRANGEELEMENTSPROC:
    given _tag: Tag[PFNGLDRAWRANGEELEMENTSPROC] = Tag.materializeCFuncPtr6[GLenum, GLuint, GLuint, GLsizei, GLenum, Ptr[Byte], Unit]
    inline def fromPtr(ptr: Ptr[Byte] | Ptr[?]): PFNGLDRAWRANGEELEMENTSPROC = CFuncPtr.fromPtr(ptr.asInstanceOf[Ptr[Byte]])
    inline def apply(inline o: CFuncPtr6[GLenum, GLuint, GLuint, GLsizei, GLenum, Ptr[Byte], Unit]): PFNGLDRAWRANGEELEMENTSPROC = o
    extension (v: PFNGLDRAWRANGEELEMENTSPROC)
      inline def value: CFuncPtr6[GLenum, GLuint, GLuint, GLsizei, GLenum, Ptr[Byte], Unit] = v
      inline def toPtr: Ptr[?] = CFuncPtr.toPtr(v)

  opaque type PFNGLDRAWTEXTURENVPROC = CFuncPtr11[GLuint, GLuint, GLfloat, GLfloat, GLfloat, GLfloat, GLfloat, GLfloat, GLfloat, GLfloat, GLfloat, Unit]
  object PFNGLDRAWTEXTURENVPROC:
    given _tag: Tag[PFNGLDRAWTEXTURENVPROC] = Tag.materializeCFuncPtr11[GLuint, GLuint, GLfloat, GLfloat, GLfloat, GLfloat, GLfloat, GLfloat, GLfloat, GLfloat, GLfloat, Unit]
    inline def fromPtr(ptr: Ptr[Byte] | Ptr[?]): PFNGLDRAWTEXTURENVPROC = CFuncPtr.fromPtr(ptr.asInstanceOf[Ptr[Byte]])
    inline def apply(inline o: CFuncPtr11[GLuint, GLuint, GLfloat, GLfloat, GLfloat, GLfloat, GLfloat, GLfloat, GLfloat, GLfloat, GLfloat, Unit]): PFNGLDRAWTEXTURENVPROC = o
    extension (v: PFNGLDRAWTEXTURENVPROC)
      inline def value: CFuncPtr11[GLuint, GLuint, GLfloat, GLfloat, GLfloat, GLfloat, GLfloat, GLfloat, GLfloat, GLfloat, GLfloat, Unit] = v
      inline def toPtr: Ptr[?] = CFuncPtr.toPtr(v)

  opaque type PFNGLDRAWTRANSFORMFEEDBACKEXTPROC = CFuncPtr2[GLenum, GLuint, Unit]
  object PFNGLDRAWTRANSFORMFEEDBACKEXTPROC:
    given _tag: Tag[PFNGLDRAWTRANSFORMFEEDBACKEXTPROC] = Tag.materializeCFuncPtr2[GLenum, GLuint, Unit]
    inline def fromPtr(ptr: Ptr[Byte] | Ptr[?]): PFNGLDRAWTRANSFORMFEEDBACKEXTPROC = CFuncPtr.fromPtr(ptr.asInstanceOf[Ptr[Byte]])
    inline def apply(inline o: CFuncPtr2[GLenum, GLuint, Unit]): PFNGLDRAWTRANSFORMFEEDBACKEXTPROC = o
    extension (v: PFNGLDRAWTRANSFORMFEEDBACKEXTPROC)
      inline def value: CFuncPtr2[GLenum, GLuint, Unit] = v
      inline def toPtr: Ptr[?] = CFuncPtr.toPtr(v)

  opaque type PFNGLDRAWTRANSFORMFEEDBACKINSTANCEDEXTPROC = CFuncPtr3[GLenum, GLuint, GLsizei, Unit]
  object PFNGLDRAWTRANSFORMFEEDBACKINSTANCEDEXTPROC:
    given _tag: Tag[PFNGLDRAWTRANSFORMFEEDBACKINSTANCEDEXTPROC] = Tag.materializeCFuncPtr3[GLenum, GLuint, GLsizei, Unit]
    inline def fromPtr(ptr: Ptr[Byte] | Ptr[?]): PFNGLDRAWTRANSFORMFEEDBACKINSTANCEDEXTPROC = CFuncPtr.fromPtr(ptr.asInstanceOf[Ptr[Byte]])
    inline def apply(inline o: CFuncPtr3[GLenum, GLuint, GLsizei, Unit]): PFNGLDRAWTRANSFORMFEEDBACKINSTANCEDEXTPROC = o
    extension (v: PFNGLDRAWTRANSFORMFEEDBACKINSTANCEDEXTPROC)
      inline def value: CFuncPtr3[GLenum, GLuint, GLsizei, Unit] = v
      inline def toPtr: Ptr[?] = CFuncPtr.toPtr(v)

  opaque type PFNGLDRAWTRANSFORMFEEDBACKINSTANCEDPROC = CFuncPtr3[GLenum, GLuint, GLsizei, Unit]
  object PFNGLDRAWTRANSFORMFEEDBACKINSTANCEDPROC:
    given _tag: Tag[PFNGLDRAWTRANSFORMFEEDBACKINSTANCEDPROC] = Tag.materializeCFuncPtr3[GLenum, GLuint, GLsizei, Unit]
    inline def fromPtr(ptr: Ptr[Byte] | Ptr[?]): PFNGLDRAWTRANSFORMFEEDBACKINSTANCEDPROC = CFuncPtr.fromPtr(ptr.asInstanceOf[Ptr[Byte]])
    inline def apply(inline o: CFuncPtr3[GLenum, GLuint, GLsizei, Unit]): PFNGLDRAWTRANSFORMFEEDBACKINSTANCEDPROC = o
    extension (v: PFNGLDRAWTRANSFORMFEEDBACKINSTANCEDPROC)
      inline def value: CFuncPtr3[GLenum, GLuint, GLsizei, Unit] = v
      inline def toPtr: Ptr[?] = CFuncPtr.toPtr(v)

  opaque type PFNGLDRAWTRANSFORMFEEDBACKNVPROC = CFuncPtr2[GLenum, GLuint, Unit]
  object PFNGLDRAWTRANSFORMFEEDBACKNVPROC:
    given _tag: Tag[PFNGLDRAWTRANSFORMFEEDBACKNVPROC] = Tag.materializeCFuncPtr2[GLenum, GLuint, Unit]
    inline def fromPtr(ptr: Ptr[Byte] | Ptr[?]): PFNGLDRAWTRANSFORMFEEDBACKNVPROC = CFuncPtr.fromPtr(ptr.asInstanceOf[Ptr[Byte]])
    inline def apply(inline o: CFuncPtr2[GLenum, GLuint, Unit]): PFNGLDRAWTRANSFORMFEEDBACKNVPROC = o
    extension (v: PFNGLDRAWTRANSFORMFEEDBACKNVPROC)
      inline def value: CFuncPtr2[GLenum, GLuint, Unit] = v
      inline def toPtr: Ptr[?] = CFuncPtr.toPtr(v)

  opaque type PFNGLDRAWTRANSFORMFEEDBACKPROC = CFuncPtr2[GLenum, GLuint, Unit]
  object PFNGLDRAWTRANSFORMFEEDBACKPROC:
    given _tag: Tag[PFNGLDRAWTRANSFORMFEEDBACKPROC] = Tag.materializeCFuncPtr2[GLenum, GLuint, Unit]
    inline def fromPtr(ptr: Ptr[Byte] | Ptr[?]): PFNGLDRAWTRANSFORMFEEDBACKPROC = CFuncPtr.fromPtr(ptr.asInstanceOf[Ptr[Byte]])
    inline def apply(inline o: CFuncPtr2[GLenum, GLuint, Unit]): PFNGLDRAWTRANSFORMFEEDBACKPROC = o
    extension (v: PFNGLDRAWTRANSFORMFEEDBACKPROC)
      inline def value: CFuncPtr2[GLenum, GLuint, Unit] = v
      inline def toPtr: Ptr[?] = CFuncPtr.toPtr(v)

  opaque type PFNGLDRAWTRANSFORMFEEDBACKSTREAMINSTANCEDPROC = CFuncPtr4[GLenum, GLuint, GLuint, GLsizei, Unit]
  object PFNGLDRAWTRANSFORMFEEDBACKSTREAMINSTANCEDPROC:
    given _tag: Tag[PFNGLDRAWTRANSFORMFEEDBACKSTREAMINSTANCEDPROC] = Tag.materializeCFuncPtr4[GLenum, GLuint, GLuint, GLsizei, Unit]
    inline def fromPtr(ptr: Ptr[Byte] | Ptr[?]): PFNGLDRAWTRANSFORMFEEDBACKSTREAMINSTANCEDPROC = CFuncPtr.fromPtr(ptr.asInstanceOf[Ptr[Byte]])
    inline def apply(inline o: CFuncPtr4[GLenum, GLuint, GLuint, GLsizei, Unit]): PFNGLDRAWTRANSFORMFEEDBACKSTREAMINSTANCEDPROC = o
    extension (v: PFNGLDRAWTRANSFORMFEEDBACKSTREAMINSTANCEDPROC)
      inline def value: CFuncPtr4[GLenum, GLuint, GLuint, GLsizei, Unit] = v
      inline def toPtr: Ptr[?] = CFuncPtr.toPtr(v)

  opaque type PFNGLDRAWTRANSFORMFEEDBACKSTREAMPROC = CFuncPtr3[GLenum, GLuint, GLuint, Unit]
  object PFNGLDRAWTRANSFORMFEEDBACKSTREAMPROC:
    given _tag: Tag[PFNGLDRAWTRANSFORMFEEDBACKSTREAMPROC] = Tag.materializeCFuncPtr3[GLenum, GLuint, GLuint, Unit]
    inline def fromPtr(ptr: Ptr[Byte] | Ptr[?]): PFNGLDRAWTRANSFORMFEEDBACKSTREAMPROC = CFuncPtr.fromPtr(ptr.asInstanceOf[Ptr[Byte]])
    inline def apply(inline o: CFuncPtr3[GLenum, GLuint, GLuint, Unit]): PFNGLDRAWTRANSFORMFEEDBACKSTREAMPROC = o
    extension (v: PFNGLDRAWTRANSFORMFEEDBACKSTREAMPROC)
      inline def value: CFuncPtr3[GLenum, GLuint, GLuint, Unit] = v
      inline def toPtr: Ptr[?] = CFuncPtr.toPtr(v)

  opaque type PFNGLDRAWVKIMAGENVPROC = CFuncPtr11[GLuint64, GLuint, GLfloat, GLfloat, GLfloat, GLfloat, GLfloat, GLfloat, GLfloat, GLfloat, GLfloat, Unit]
  object PFNGLDRAWVKIMAGENVPROC:
    given _tag: Tag[PFNGLDRAWVKIMAGENVPROC] = Tag.materializeCFuncPtr11[GLuint64, GLuint, GLfloat, GLfloat, GLfloat, GLfloat, GLfloat, GLfloat, GLfloat, GLfloat, GLfloat, Unit]
    inline def fromPtr(ptr: Ptr[Byte] | Ptr[?]): PFNGLDRAWVKIMAGENVPROC = CFuncPtr.fromPtr(ptr.asInstanceOf[Ptr[Byte]])
    inline def apply(inline o: CFuncPtr11[GLuint64, GLuint, GLfloat, GLfloat, GLfloat, GLfloat, GLfloat, GLfloat, GLfloat, GLfloat, GLfloat, Unit]): PFNGLDRAWVKIMAGENVPROC = o
    extension (v: PFNGLDRAWVKIMAGENVPROC)
      inline def value: CFuncPtr11[GLuint64, GLuint, GLfloat, GLfloat, GLfloat, GLfloat, GLfloat, GLfloat, GLfloat, GLfloat, GLfloat, Unit] = v
      inline def toPtr: Ptr[?] = CFuncPtr.toPtr(v)

  opaque type PFNGLEDGEFLAGFORMATNVPROC = CFuncPtr1[GLsizei, Unit]
  object PFNGLEDGEFLAGFORMATNVPROC:
    given _tag: Tag[PFNGLEDGEFLAGFORMATNVPROC] = Tag.materializeCFuncPtr1[GLsizei, Unit]
    inline def fromPtr(ptr: Ptr[Byte] | Ptr[?]): PFNGLEDGEFLAGFORMATNVPROC = CFuncPtr.fromPtr(ptr.asInstanceOf[Ptr[Byte]])
    inline def apply(inline o: CFuncPtr1[GLsizei, Unit]): PFNGLEDGEFLAGFORMATNVPROC = o
    extension (v: PFNGLEDGEFLAGFORMATNVPROC)
      inline def value: CFuncPtr1[GLsizei, Unit] = v
      inline def toPtr: Ptr[?] = CFuncPtr.toPtr(v)

  opaque type PFNGLEDGEFLAGPOINTEREXTPROC = CFuncPtr3[GLsizei, GLsizei, Ptr[GLboolean], Unit]
  object PFNGLEDGEFLAGPOINTEREXTPROC:
    given _tag: Tag[PFNGLEDGEFLAGPOINTEREXTPROC] = Tag.materializeCFuncPtr3[GLsizei, GLsizei, Ptr[GLboolean], Unit]
    inline def fromPtr(ptr: Ptr[Byte] | Ptr[?]): PFNGLEDGEFLAGPOINTEREXTPROC = CFuncPtr.fromPtr(ptr.asInstanceOf[Ptr[Byte]])
    inline def apply(inline o: CFuncPtr3[GLsizei, GLsizei, Ptr[GLboolean], Unit]): PFNGLEDGEFLAGPOINTEREXTPROC = o
    extension (v: PFNGLEDGEFLAGPOINTEREXTPROC)
      inline def value: CFuncPtr3[GLsizei, GLsizei, Ptr[GLboolean], Unit] = v
      inline def toPtr: Ptr[?] = CFuncPtr.toPtr(v)

  opaque type PFNGLEDGEFLAGPOINTERLISTIBMPROC = CFuncPtr3[GLint, Ptr[Ptr[GLboolean]], GLint, Unit]
  object PFNGLEDGEFLAGPOINTERLISTIBMPROC:
    given _tag: Tag[PFNGLEDGEFLAGPOINTERLISTIBMPROC] = Tag.materializeCFuncPtr3[GLint, Ptr[Ptr[GLboolean]], GLint, Unit]
    inline def fromPtr(ptr: Ptr[Byte] | Ptr[?]): PFNGLEDGEFLAGPOINTERLISTIBMPROC = CFuncPtr.fromPtr(ptr.asInstanceOf[Ptr[Byte]])
    inline def apply(inline o: CFuncPtr3[GLint, Ptr[Ptr[GLboolean]], GLint, Unit]): PFNGLEDGEFLAGPOINTERLISTIBMPROC = o
    extension (v: PFNGLEDGEFLAGPOINTERLISTIBMPROC)
      inline def value: CFuncPtr3[GLint, Ptr[Ptr[GLboolean]], GLint, Unit] = v
      inline def toPtr: Ptr[?] = CFuncPtr.toPtr(v)

  opaque type PFNGLEGLIMAGETARGETRENDERBUFFERSTORAGEOESPROC = CFuncPtr2[GLenum, GLeglImageOES, Unit]
  object PFNGLEGLIMAGETARGETRENDERBUFFERSTORAGEOESPROC:
    given _tag: Tag[PFNGLEGLIMAGETARGETRENDERBUFFERSTORAGEOESPROC] = Tag.materializeCFuncPtr2[GLenum, GLeglImageOES, Unit]
    inline def fromPtr(ptr: Ptr[Byte] | Ptr[?]): PFNGLEGLIMAGETARGETRENDERBUFFERSTORAGEOESPROC = CFuncPtr.fromPtr(ptr.asInstanceOf[Ptr[Byte]])
    inline def apply(inline o: CFuncPtr2[GLenum, GLeglImageOES, Unit]): PFNGLEGLIMAGETARGETRENDERBUFFERSTORAGEOESPROC = o
    extension (v: PFNGLEGLIMAGETARGETRENDERBUFFERSTORAGEOESPROC)
      inline def value: CFuncPtr2[GLenum, GLeglImageOES, Unit] = v
      inline def toPtr: Ptr[?] = CFuncPtr.toPtr(v)

  opaque type PFNGLEGLIMAGETARGETTEXSTORAGEEXTPROC = CFuncPtr3[GLenum, GLeglImageOES, Ptr[GLint], Unit]
  object PFNGLEGLIMAGETARGETTEXSTORAGEEXTPROC:
    given _tag: Tag[PFNGLEGLIMAGETARGETTEXSTORAGEEXTPROC] = Tag.materializeCFuncPtr3[GLenum, GLeglImageOES, Ptr[GLint], Unit]
    inline def fromPtr(ptr: Ptr[Byte] | Ptr[?]): PFNGLEGLIMAGETARGETTEXSTORAGEEXTPROC = CFuncPtr.fromPtr(ptr.asInstanceOf[Ptr[Byte]])
    inline def apply(inline o: CFuncPtr3[GLenum, GLeglImageOES, Ptr[GLint], Unit]): PFNGLEGLIMAGETARGETTEXSTORAGEEXTPROC = o
    extension (v: PFNGLEGLIMAGETARGETTEXSTORAGEEXTPROC)
      inline def value: CFuncPtr3[GLenum, GLeglImageOES, Ptr[GLint], Unit] = v
      inline def toPtr: Ptr[?] = CFuncPtr.toPtr(v)

  opaque type PFNGLEGLIMAGETARGETTEXTURE2DOESPROC = CFuncPtr2[GLenum, GLeglImageOES, Unit]
  object PFNGLEGLIMAGETARGETTEXTURE2DOESPROC:
    given _tag: Tag[PFNGLEGLIMAGETARGETTEXTURE2DOESPROC] = Tag.materializeCFuncPtr2[GLenum, GLeglImageOES, Unit]
    inline def fromPtr(ptr: Ptr[Byte] | Ptr[?]): PFNGLEGLIMAGETARGETTEXTURE2DOESPROC = CFuncPtr.fromPtr(ptr.asInstanceOf[Ptr[Byte]])
    inline def apply(inline o: CFuncPtr2[GLenum, GLeglImageOES, Unit]): PFNGLEGLIMAGETARGETTEXTURE2DOESPROC = o
    extension (v: PFNGLEGLIMAGETARGETTEXTURE2DOESPROC)
      inline def value: CFuncPtr2[GLenum, GLeglImageOES, Unit] = v
      inline def toPtr: Ptr[?] = CFuncPtr.toPtr(v)

  opaque type PFNGLEGLIMAGETARGETTEXTURESTORAGEEXTPROC = CFuncPtr3[GLuint, GLeglImageOES, Ptr[GLint], Unit]
  object PFNGLEGLIMAGETARGETTEXTURESTORAGEEXTPROC:
    given _tag: Tag[PFNGLEGLIMAGETARGETTEXTURESTORAGEEXTPROC] = Tag.materializeCFuncPtr3[GLuint, GLeglImageOES, Ptr[GLint], Unit]
    inline def fromPtr(ptr: Ptr[Byte] | Ptr[?]): PFNGLEGLIMAGETARGETTEXTURESTORAGEEXTPROC = CFuncPtr.fromPtr(ptr.asInstanceOf[Ptr[Byte]])
    inline def apply(inline o: CFuncPtr3[GLuint, GLeglImageOES, Ptr[GLint], Unit]): PFNGLEGLIMAGETARGETTEXTURESTORAGEEXTPROC = o
    extension (v: PFNGLEGLIMAGETARGETTEXTURESTORAGEEXTPROC)
      inline def value: CFuncPtr3[GLuint, GLeglImageOES, Ptr[GLint], Unit] = v
      inline def toPtr: Ptr[?] = CFuncPtr.toPtr(v)

  opaque type PFNGLELEMENTPOINTERAPPLEPROC = CFuncPtr2[GLenum, Ptr[Byte], Unit]
  object PFNGLELEMENTPOINTERAPPLEPROC:
    given _tag: Tag[PFNGLELEMENTPOINTERAPPLEPROC] = Tag.materializeCFuncPtr2[GLenum, Ptr[Byte], Unit]
    inline def fromPtr(ptr: Ptr[Byte] | Ptr[?]): PFNGLELEMENTPOINTERAPPLEPROC = CFuncPtr.fromPtr(ptr.asInstanceOf[Ptr[Byte]])
    inline def apply(inline o: CFuncPtr2[GLenum, Ptr[Byte], Unit]): PFNGLELEMENTPOINTERAPPLEPROC = o
    extension (v: PFNGLELEMENTPOINTERAPPLEPROC)
      inline def value: CFuncPtr2[GLenum, Ptr[Byte], Unit] = v
      inline def toPtr: Ptr[?] = CFuncPtr.toPtr(v)

  opaque type PFNGLELEMENTPOINTERATIPROC = CFuncPtr2[GLenum, Ptr[Byte], Unit]
  object PFNGLELEMENTPOINTERATIPROC:
    given _tag: Tag[PFNGLELEMENTPOINTERATIPROC] = Tag.materializeCFuncPtr2[GLenum, Ptr[Byte], Unit]
    inline def fromPtr(ptr: Ptr[Byte] | Ptr[?]): PFNGLELEMENTPOINTERATIPROC = CFuncPtr.fromPtr(ptr.asInstanceOf[Ptr[Byte]])
    inline def apply(inline o: CFuncPtr2[GLenum, Ptr[Byte], Unit]): PFNGLELEMENTPOINTERATIPROC = o
    extension (v: PFNGLELEMENTPOINTERATIPROC)
      inline def value: CFuncPtr2[GLenum, Ptr[Byte], Unit] = v
      inline def toPtr: Ptr[?] = CFuncPtr.toPtr(v)

  opaque type PFNGLENABLECLIENTSTATEIEXTPROC = CFuncPtr2[GLenum, GLuint, Unit]
  object PFNGLENABLECLIENTSTATEIEXTPROC:
    given _tag: Tag[PFNGLENABLECLIENTSTATEIEXTPROC] = Tag.materializeCFuncPtr2[GLenum, GLuint, Unit]
    inline def fromPtr(ptr: Ptr[Byte] | Ptr[?]): PFNGLENABLECLIENTSTATEIEXTPROC = CFuncPtr.fromPtr(ptr.asInstanceOf[Ptr[Byte]])
    inline def apply(inline o: CFuncPtr2[GLenum, GLuint, Unit]): PFNGLENABLECLIENTSTATEIEXTPROC = o
    extension (v: PFNGLENABLECLIENTSTATEIEXTPROC)
      inline def value: CFuncPtr2[GLenum, GLuint, Unit] = v
      inline def toPtr: Ptr[?] = CFuncPtr.toPtr(v)

  opaque type PFNGLENABLECLIENTSTATEINDEXEDEXTPROC = CFuncPtr2[GLenum, GLuint, Unit]
  object PFNGLENABLECLIENTSTATEINDEXEDEXTPROC:
    given _tag: Tag[PFNGLENABLECLIENTSTATEINDEXEDEXTPROC] = Tag.materializeCFuncPtr2[GLenum, GLuint, Unit]
    inline def fromPtr(ptr: Ptr[Byte] | Ptr[?]): PFNGLENABLECLIENTSTATEINDEXEDEXTPROC = CFuncPtr.fromPtr(ptr.asInstanceOf[Ptr[Byte]])
    inline def apply(inline o: CFuncPtr2[GLenum, GLuint, Unit]): PFNGLENABLECLIENTSTATEINDEXEDEXTPROC = o
    extension (v: PFNGLENABLECLIENTSTATEINDEXEDEXTPROC)
      inline def value: CFuncPtr2[GLenum, GLuint, Unit] = v
      inline def toPtr: Ptr[?] = CFuncPtr.toPtr(v)

  opaque type PFNGLENABLEDRIVERCONTROLQCOMPROC = CFuncPtr1[GLuint, Unit]
  object PFNGLENABLEDRIVERCONTROLQCOMPROC:
    given _tag: Tag[PFNGLENABLEDRIVERCONTROLQCOMPROC] = Tag.materializeCFuncPtr1[GLuint, Unit]
    inline def fromPtr(ptr: Ptr[Byte] | Ptr[?]): PFNGLENABLEDRIVERCONTROLQCOMPROC = CFuncPtr.fromPtr(ptr.asInstanceOf[Ptr[Byte]])
    inline def apply(inline o: CFuncPtr1[GLuint, Unit]): PFNGLENABLEDRIVERCONTROLQCOMPROC = o
    extension (v: PFNGLENABLEDRIVERCONTROLQCOMPROC)
      inline def value: CFuncPtr1[GLuint, Unit] = v
      inline def toPtr: Ptr[?] = CFuncPtr.toPtr(v)

  opaque type PFNGLENABLEIEXTPROC = CFuncPtr2[GLenum, GLuint, Unit]
  object PFNGLENABLEIEXTPROC:
    given _tag: Tag[PFNGLENABLEIEXTPROC] = Tag.materializeCFuncPtr2[GLenum, GLuint, Unit]
    inline def fromPtr(ptr: Ptr[Byte] | Ptr[?]): PFNGLENABLEIEXTPROC = CFuncPtr.fromPtr(ptr.asInstanceOf[Ptr[Byte]])
    inline def apply(inline o: CFuncPtr2[GLenum, GLuint, Unit]): PFNGLENABLEIEXTPROC = o
    extension (v: PFNGLENABLEIEXTPROC)
      inline def value: CFuncPtr2[GLenum, GLuint, Unit] = v
      inline def toPtr: Ptr[?] = CFuncPtr.toPtr(v)

  opaque type PFNGLENABLEINDEXEDEXTPROC = CFuncPtr2[GLenum, GLuint, Unit]
  object PFNGLENABLEINDEXEDEXTPROC:
    given _tag: Tag[PFNGLENABLEINDEXEDEXTPROC] = Tag.materializeCFuncPtr2[GLenum, GLuint, Unit]
    inline def fromPtr(ptr: Ptr[Byte] | Ptr[?]): PFNGLENABLEINDEXEDEXTPROC = CFuncPtr.fromPtr(ptr.asInstanceOf[Ptr[Byte]])
    inline def apply(inline o: CFuncPtr2[GLenum, GLuint, Unit]): PFNGLENABLEINDEXEDEXTPROC = o
    extension (v: PFNGLENABLEINDEXEDEXTPROC)
      inline def value: CFuncPtr2[GLenum, GLuint, Unit] = v
      inline def toPtr: Ptr[?] = CFuncPtr.toPtr(v)

  opaque type PFNGLENABLEINVPROC = CFuncPtr2[GLenum, GLuint, Unit]
  object PFNGLENABLEINVPROC:
    given _tag: Tag[PFNGLENABLEINVPROC] = Tag.materializeCFuncPtr2[GLenum, GLuint, Unit]
    inline def fromPtr(ptr: Ptr[Byte] | Ptr[?]): PFNGLENABLEINVPROC = CFuncPtr.fromPtr(ptr.asInstanceOf[Ptr[Byte]])
    inline def apply(inline o: CFuncPtr2[GLenum, GLuint, Unit]): PFNGLENABLEINVPROC = o
    extension (v: PFNGLENABLEINVPROC)
      inline def value: CFuncPtr2[GLenum, GLuint, Unit] = v
      inline def toPtr: Ptr[?] = CFuncPtr.toPtr(v)

  opaque type PFNGLENABLEIOESPROC = CFuncPtr2[GLenum, GLuint, Unit]
  object PFNGLENABLEIOESPROC:
    given _tag: Tag[PFNGLENABLEIOESPROC] = Tag.materializeCFuncPtr2[GLenum, GLuint, Unit]
    inline def fromPtr(ptr: Ptr[Byte] | Ptr[?]): PFNGLENABLEIOESPROC = CFuncPtr.fromPtr(ptr.asInstanceOf[Ptr[Byte]])
    inline def apply(inline o: CFuncPtr2[GLenum, GLuint, Unit]): PFNGLENABLEIOESPROC = o
    extension (v: PFNGLENABLEIOESPROC)
      inline def value: CFuncPtr2[GLenum, GLuint, Unit] = v
      inline def toPtr: Ptr[?] = CFuncPtr.toPtr(v)

  opaque type PFNGLENABLEIPROC = CFuncPtr2[GLenum, GLuint, Unit]
  object PFNGLENABLEIPROC:
    given _tag: Tag[PFNGLENABLEIPROC] = Tag.materializeCFuncPtr2[GLenum, GLuint, Unit]
    inline def fromPtr(ptr: Ptr[Byte] | Ptr[?]): PFNGLENABLEIPROC = CFuncPtr.fromPtr(ptr.asInstanceOf[Ptr[Byte]])
    inline def apply(inline o: CFuncPtr2[GLenum, GLuint, Unit]): PFNGLENABLEIPROC = o
    extension (v: PFNGLENABLEIPROC)
      inline def value: CFuncPtr2[GLenum, GLuint, Unit] = v
      inline def toPtr: Ptr[?] = CFuncPtr.toPtr(v)

  opaque type PFNGLENABLEVARIANTCLIENTSTATEEXTPROC = CFuncPtr1[GLuint, Unit]
  object PFNGLENABLEVARIANTCLIENTSTATEEXTPROC:
    given _tag: Tag[PFNGLENABLEVARIANTCLIENTSTATEEXTPROC] = Tag.materializeCFuncPtr1[GLuint, Unit]
    inline def fromPtr(ptr: Ptr[Byte] | Ptr[?]): PFNGLENABLEVARIANTCLIENTSTATEEXTPROC = CFuncPtr.fromPtr(ptr.asInstanceOf[Ptr[Byte]])
    inline def apply(inline o: CFuncPtr1[GLuint, Unit]): PFNGLENABLEVARIANTCLIENTSTATEEXTPROC = o
    extension (v: PFNGLENABLEVARIANTCLIENTSTATEEXTPROC)
      inline def value: CFuncPtr1[GLuint, Unit] = v
      inline def toPtr: Ptr[?] = CFuncPtr.toPtr(v)

  opaque type PFNGLENABLEVERTEXARRAYATTRIBEXTPROC = CFuncPtr2[GLuint, GLuint, Unit]
  object PFNGLENABLEVERTEXARRAYATTRIBEXTPROC:
    given _tag: Tag[PFNGLENABLEVERTEXARRAYATTRIBEXTPROC] = Tag.materializeCFuncPtr2[GLuint, GLuint, Unit]
    inline def fromPtr(ptr: Ptr[Byte] | Ptr[?]): PFNGLENABLEVERTEXARRAYATTRIBEXTPROC = CFuncPtr.fromPtr(ptr.asInstanceOf[Ptr[Byte]])
    inline def apply(inline o: CFuncPtr2[GLuint, GLuint, Unit]): PFNGLENABLEVERTEXARRAYATTRIBEXTPROC = o
    extension (v: PFNGLENABLEVERTEXARRAYATTRIBEXTPROC)
      inline def value: CFuncPtr2[GLuint, GLuint, Unit] = v
      inline def toPtr: Ptr[?] = CFuncPtr.toPtr(v)

  opaque type PFNGLENABLEVERTEXARRAYATTRIBPROC = CFuncPtr2[GLuint, GLuint, Unit]
  object PFNGLENABLEVERTEXARRAYATTRIBPROC:
    given _tag: Tag[PFNGLENABLEVERTEXARRAYATTRIBPROC] = Tag.materializeCFuncPtr2[GLuint, GLuint, Unit]
    inline def fromPtr(ptr: Ptr[Byte] | Ptr[?]): PFNGLENABLEVERTEXARRAYATTRIBPROC = CFuncPtr.fromPtr(ptr.asInstanceOf[Ptr[Byte]])
    inline def apply(inline o: CFuncPtr2[GLuint, GLuint, Unit]): PFNGLENABLEVERTEXARRAYATTRIBPROC = o
    extension (v: PFNGLENABLEVERTEXARRAYATTRIBPROC)
      inline def value: CFuncPtr2[GLuint, GLuint, Unit] = v
      inline def toPtr: Ptr[?] = CFuncPtr.toPtr(v)

  opaque type PFNGLENABLEVERTEXARRAYEXTPROC = CFuncPtr2[GLuint, GLenum, Unit]
  object PFNGLENABLEVERTEXARRAYEXTPROC:
    given _tag: Tag[PFNGLENABLEVERTEXARRAYEXTPROC] = Tag.materializeCFuncPtr2[GLuint, GLenum, Unit]
    inline def fromPtr(ptr: Ptr[Byte] | Ptr[?]): PFNGLENABLEVERTEXARRAYEXTPROC = CFuncPtr.fromPtr(ptr.asInstanceOf[Ptr[Byte]])
    inline def apply(inline o: CFuncPtr2[GLuint, GLenum, Unit]): PFNGLENABLEVERTEXARRAYEXTPROC = o
    extension (v: PFNGLENABLEVERTEXARRAYEXTPROC)
      inline def value: CFuncPtr2[GLuint, GLenum, Unit] = v
      inline def toPtr: Ptr[?] = CFuncPtr.toPtr(v)

  opaque type PFNGLENABLEVERTEXATTRIBAPPLEPROC = CFuncPtr2[GLuint, GLenum, Unit]
  object PFNGLENABLEVERTEXATTRIBAPPLEPROC:
    given _tag: Tag[PFNGLENABLEVERTEXATTRIBAPPLEPROC] = Tag.materializeCFuncPtr2[GLuint, GLenum, Unit]
    inline def fromPtr(ptr: Ptr[Byte] | Ptr[?]): PFNGLENABLEVERTEXATTRIBAPPLEPROC = CFuncPtr.fromPtr(ptr.asInstanceOf[Ptr[Byte]])
    inline def apply(inline o: CFuncPtr2[GLuint, GLenum, Unit]): PFNGLENABLEVERTEXATTRIBAPPLEPROC = o
    extension (v: PFNGLENABLEVERTEXATTRIBAPPLEPROC)
      inline def value: CFuncPtr2[GLuint, GLenum, Unit] = v
      inline def toPtr: Ptr[?] = CFuncPtr.toPtr(v)

  opaque type PFNGLENABLEVERTEXATTRIBARRAYARBPROC = CFuncPtr1[GLuint, Unit]
  object PFNGLENABLEVERTEXATTRIBARRAYARBPROC:
    given _tag: Tag[PFNGLENABLEVERTEXATTRIBARRAYARBPROC] = Tag.materializeCFuncPtr1[GLuint, Unit]
    inline def fromPtr(ptr: Ptr[Byte] | Ptr[?]): PFNGLENABLEVERTEXATTRIBARRAYARBPROC = CFuncPtr.fromPtr(ptr.asInstanceOf[Ptr[Byte]])
    inline def apply(inline o: CFuncPtr1[GLuint, Unit]): PFNGLENABLEVERTEXATTRIBARRAYARBPROC = o
    extension (v: PFNGLENABLEVERTEXATTRIBARRAYARBPROC)
      inline def value: CFuncPtr1[GLuint, Unit] = v
      inline def toPtr: Ptr[?] = CFuncPtr.toPtr(v)

  opaque type PFNGLENABLEVERTEXATTRIBARRAYPROC = CFuncPtr1[GLuint, Unit]
  object PFNGLENABLEVERTEXATTRIBARRAYPROC:
    given _tag: Tag[PFNGLENABLEVERTEXATTRIBARRAYPROC] = Tag.materializeCFuncPtr1[GLuint, Unit]
    inline def fromPtr(ptr: Ptr[Byte] | Ptr[?]): PFNGLENABLEVERTEXATTRIBARRAYPROC = CFuncPtr.fromPtr(ptr.asInstanceOf[Ptr[Byte]])
    inline def apply(inline o: CFuncPtr1[GLuint, Unit]): PFNGLENABLEVERTEXATTRIBARRAYPROC = o
    extension (v: PFNGLENABLEVERTEXATTRIBARRAYPROC)
      inline def value: CFuncPtr1[GLuint, Unit] = v
      inline def toPtr: Ptr[?] = CFuncPtr.toPtr(v)

  opaque type PFNGLENDCONDITIONALRENDERNVPROC = CFuncPtr0[Unit]
  object PFNGLENDCONDITIONALRENDERNVPROC:
    given _tag: Tag[PFNGLENDCONDITIONALRENDERNVPROC] = Tag.materializeCFuncPtr0[Unit]
    inline def fromPtr(ptr: Ptr[Byte] | Ptr[?]): PFNGLENDCONDITIONALRENDERNVPROC = CFuncPtr.fromPtr(ptr.asInstanceOf[Ptr[Byte]])
    inline def apply(inline o: CFuncPtr0[Unit]): PFNGLENDCONDITIONALRENDERNVPROC = o
    extension (v: PFNGLENDCONDITIONALRENDERNVPROC)
      inline def value: CFuncPtr0[Unit] = v
      inline def toPtr: Ptr[?] = CFuncPtr.toPtr(v)

  opaque type PFNGLENDCONDITIONALRENDERNVXPROC = CFuncPtr0[Unit]
  object PFNGLENDCONDITIONALRENDERNVXPROC:
    given _tag: Tag[PFNGLENDCONDITIONALRENDERNVXPROC] = Tag.materializeCFuncPtr0[Unit]
    inline def fromPtr(ptr: Ptr[Byte] | Ptr[?]): PFNGLENDCONDITIONALRENDERNVXPROC = CFuncPtr.fromPtr(ptr.asInstanceOf[Ptr[Byte]])
    inline def apply(inline o: CFuncPtr0[Unit]): PFNGLENDCONDITIONALRENDERNVXPROC = o
    extension (v: PFNGLENDCONDITIONALRENDERNVXPROC)
      inline def value: CFuncPtr0[Unit] = v
      inline def toPtr: Ptr[?] = CFuncPtr.toPtr(v)

  opaque type PFNGLENDCONDITIONALRENDERPROC = CFuncPtr0[Unit]
  object PFNGLENDCONDITIONALRENDERPROC:
    given _tag: Tag[PFNGLENDCONDITIONALRENDERPROC] = Tag.materializeCFuncPtr0[Unit]
    inline def fromPtr(ptr: Ptr[Byte] | Ptr[?]): PFNGLENDCONDITIONALRENDERPROC = CFuncPtr.fromPtr(ptr.asInstanceOf[Ptr[Byte]])
    inline def apply(inline o: CFuncPtr0[Unit]): PFNGLENDCONDITIONALRENDERPROC = o
    extension (v: PFNGLENDCONDITIONALRENDERPROC)
      inline def value: CFuncPtr0[Unit] = v
      inline def toPtr: Ptr[?] = CFuncPtr.toPtr(v)

  opaque type PFNGLENDFRAGMENTSHADERATIPROC = CFuncPtr0[Unit]
  object PFNGLENDFRAGMENTSHADERATIPROC:
    given _tag: Tag[PFNGLENDFRAGMENTSHADERATIPROC] = Tag.materializeCFuncPtr0[Unit]
    inline def fromPtr(ptr: Ptr[Byte] | Ptr[?]): PFNGLENDFRAGMENTSHADERATIPROC = CFuncPtr.fromPtr(ptr.asInstanceOf[Ptr[Byte]])
    inline def apply(inline o: CFuncPtr0[Unit]): PFNGLENDFRAGMENTSHADERATIPROC = o
    extension (v: PFNGLENDFRAGMENTSHADERATIPROC)
      inline def value: CFuncPtr0[Unit] = v
      inline def toPtr: Ptr[?] = CFuncPtr.toPtr(v)

  opaque type PFNGLENDOCCLUSIONQUERYNVPROC = CFuncPtr0[Unit]
  object PFNGLENDOCCLUSIONQUERYNVPROC:
    given _tag: Tag[PFNGLENDOCCLUSIONQUERYNVPROC] = Tag.materializeCFuncPtr0[Unit]
    inline def fromPtr(ptr: Ptr[Byte] | Ptr[?]): PFNGLENDOCCLUSIONQUERYNVPROC = CFuncPtr.fromPtr(ptr.asInstanceOf[Ptr[Byte]])
    inline def apply(inline o: CFuncPtr0[Unit]): PFNGLENDOCCLUSIONQUERYNVPROC = o
    extension (v: PFNGLENDOCCLUSIONQUERYNVPROC)
      inline def value: CFuncPtr0[Unit] = v
      inline def toPtr: Ptr[?] = CFuncPtr.toPtr(v)

  opaque type PFNGLENDPERFMONITORAMDPROC = CFuncPtr1[GLuint, Unit]
  object PFNGLENDPERFMONITORAMDPROC:
    given _tag: Tag[PFNGLENDPERFMONITORAMDPROC] = Tag.materializeCFuncPtr1[GLuint, Unit]
    inline def fromPtr(ptr: Ptr[Byte] | Ptr[?]): PFNGLENDPERFMONITORAMDPROC = CFuncPtr.fromPtr(ptr.asInstanceOf[Ptr[Byte]])
    inline def apply(inline o: CFuncPtr1[GLuint, Unit]): PFNGLENDPERFMONITORAMDPROC = o
    extension (v: PFNGLENDPERFMONITORAMDPROC)
      inline def value: CFuncPtr1[GLuint, Unit] = v
      inline def toPtr: Ptr[?] = CFuncPtr.toPtr(v)

  opaque type PFNGLENDPERFQUERYINTELPROC = CFuncPtr1[GLuint, Unit]
  object PFNGLENDPERFQUERYINTELPROC:
    given _tag: Tag[PFNGLENDPERFQUERYINTELPROC] = Tag.materializeCFuncPtr1[GLuint, Unit]
    inline def fromPtr(ptr: Ptr[Byte] | Ptr[?]): PFNGLENDPERFQUERYINTELPROC = CFuncPtr.fromPtr(ptr.asInstanceOf[Ptr[Byte]])
    inline def apply(inline o: CFuncPtr1[GLuint, Unit]): PFNGLENDPERFQUERYINTELPROC = o
    extension (v: PFNGLENDPERFQUERYINTELPROC)
      inline def value: CFuncPtr1[GLuint, Unit] = v
      inline def toPtr: Ptr[?] = CFuncPtr.toPtr(v)

  opaque type PFNGLENDQUERYANGLEPROC = CFuncPtr1[GLenum, Unit]
  object PFNGLENDQUERYANGLEPROC:
    given _tag: Tag[PFNGLENDQUERYANGLEPROC] = Tag.materializeCFuncPtr1[GLenum, Unit]
    inline def fromPtr(ptr: Ptr[Byte] | Ptr[?]): PFNGLENDQUERYANGLEPROC = CFuncPtr.fromPtr(ptr.asInstanceOf[Ptr[Byte]])
    inline def apply(inline o: CFuncPtr1[GLenum, Unit]): PFNGLENDQUERYANGLEPROC = o
    extension (v: PFNGLENDQUERYANGLEPROC)
      inline def value: CFuncPtr1[GLenum, Unit] = v
      inline def toPtr: Ptr[?] = CFuncPtr.toPtr(v)

  opaque type PFNGLENDQUERYARBPROC = CFuncPtr1[GLenum, Unit]
  object PFNGLENDQUERYARBPROC:
    given _tag: Tag[PFNGLENDQUERYARBPROC] = Tag.materializeCFuncPtr1[GLenum, Unit]
    inline def fromPtr(ptr: Ptr[Byte] | Ptr[?]): PFNGLENDQUERYARBPROC = CFuncPtr.fromPtr(ptr.asInstanceOf[Ptr[Byte]])
    inline def apply(inline o: CFuncPtr1[GLenum, Unit]): PFNGLENDQUERYARBPROC = o
    extension (v: PFNGLENDQUERYARBPROC)
      inline def value: CFuncPtr1[GLenum, Unit] = v
      inline def toPtr: Ptr[?] = CFuncPtr.toPtr(v)

  opaque type PFNGLENDQUERYEXTPROC = CFuncPtr1[GLenum, Unit]
  object PFNGLENDQUERYEXTPROC:
    given _tag: Tag[PFNGLENDQUERYEXTPROC] = Tag.materializeCFuncPtr1[GLenum, Unit]
    inline def fromPtr(ptr: Ptr[Byte] | Ptr[?]): PFNGLENDQUERYEXTPROC = CFuncPtr.fromPtr(ptr.asInstanceOf[Ptr[Byte]])
    inline def apply(inline o: CFuncPtr1[GLenum, Unit]): PFNGLENDQUERYEXTPROC = o
    extension (v: PFNGLENDQUERYEXTPROC)
      inline def value: CFuncPtr1[GLenum, Unit] = v
      inline def toPtr: Ptr[?] = CFuncPtr.toPtr(v)

  opaque type PFNGLENDQUERYINDEXEDPROC = CFuncPtr2[GLenum, GLuint, Unit]
  object PFNGLENDQUERYINDEXEDPROC:
    given _tag: Tag[PFNGLENDQUERYINDEXEDPROC] = Tag.materializeCFuncPtr2[GLenum, GLuint, Unit]
    inline def fromPtr(ptr: Ptr[Byte] | Ptr[?]): PFNGLENDQUERYINDEXEDPROC = CFuncPtr.fromPtr(ptr.asInstanceOf[Ptr[Byte]])
    inline def apply(inline o: CFuncPtr2[GLenum, GLuint, Unit]): PFNGLENDQUERYINDEXEDPROC = o
    extension (v: PFNGLENDQUERYINDEXEDPROC)
      inline def value: CFuncPtr2[GLenum, GLuint, Unit] = v
      inline def toPtr: Ptr[?] = CFuncPtr.toPtr(v)

  opaque type PFNGLENDQUERYPROC = CFuncPtr1[GLenum, Unit]
  object PFNGLENDQUERYPROC:
    given _tag: Tag[PFNGLENDQUERYPROC] = Tag.materializeCFuncPtr1[GLenum, Unit]
    inline def fromPtr(ptr: Ptr[Byte] | Ptr[?]): PFNGLENDQUERYPROC = CFuncPtr.fromPtr(ptr.asInstanceOf[Ptr[Byte]])
    inline def apply(inline o: CFuncPtr1[GLenum, Unit]): PFNGLENDQUERYPROC = o
    extension (v: PFNGLENDQUERYPROC)
      inline def value: CFuncPtr1[GLenum, Unit] = v
      inline def toPtr: Ptr[?] = CFuncPtr.toPtr(v)

  opaque type PFNGLENDSCENEEXTPROC = CFuncPtr0[Unit]
  object PFNGLENDSCENEEXTPROC:
    given _tag: Tag[PFNGLENDSCENEEXTPROC] = Tag.materializeCFuncPtr0[Unit]
    inline def fromPtr(ptr: Ptr[Byte] | Ptr[?]): PFNGLENDSCENEEXTPROC = CFuncPtr.fromPtr(ptr.asInstanceOf[Ptr[Byte]])
    inline def apply(inline o: CFuncPtr0[Unit]): PFNGLENDSCENEEXTPROC = o
    extension (v: PFNGLENDSCENEEXTPROC)
      inline def value: CFuncPtr0[Unit] = v
      inline def toPtr: Ptr[?] = CFuncPtr.toPtr(v)

  opaque type PFNGLENDTILINGQCOMPROC = CFuncPtr1[GLbitfield, Unit]
  object PFNGLENDTILINGQCOMPROC:
    given _tag: Tag[PFNGLENDTILINGQCOMPROC] = Tag.materializeCFuncPtr1[GLbitfield, Unit]
    inline def fromPtr(ptr: Ptr[Byte] | Ptr[?]): PFNGLENDTILINGQCOMPROC = CFuncPtr.fromPtr(ptr.asInstanceOf[Ptr[Byte]])
    inline def apply(inline o: CFuncPtr1[GLbitfield, Unit]): PFNGLENDTILINGQCOMPROC = o
    extension (v: PFNGLENDTILINGQCOMPROC)
      inline def value: CFuncPtr1[GLbitfield, Unit] = v
      inline def toPtr: Ptr[?] = CFuncPtr.toPtr(v)

  opaque type PFNGLENDTRANSFORMFEEDBACKEXTPROC = CFuncPtr0[Unit]
  object PFNGLENDTRANSFORMFEEDBACKEXTPROC:
    given _tag: Tag[PFNGLENDTRANSFORMFEEDBACKEXTPROC] = Tag.materializeCFuncPtr0[Unit]
    inline def fromPtr(ptr: Ptr[Byte] | Ptr[?]): PFNGLENDTRANSFORMFEEDBACKEXTPROC = CFuncPtr.fromPtr(ptr.asInstanceOf[Ptr[Byte]])
    inline def apply(inline o: CFuncPtr0[Unit]): PFNGLENDTRANSFORMFEEDBACKEXTPROC = o
    extension (v: PFNGLENDTRANSFORMFEEDBACKEXTPROC)
      inline def value: CFuncPtr0[Unit] = v
      inline def toPtr: Ptr[?] = CFuncPtr.toPtr(v)

  opaque type PFNGLENDTRANSFORMFEEDBACKNVPROC = CFuncPtr0[Unit]
  object PFNGLENDTRANSFORMFEEDBACKNVPROC:
    given _tag: Tag[PFNGLENDTRANSFORMFEEDBACKNVPROC] = Tag.materializeCFuncPtr0[Unit]
    inline def fromPtr(ptr: Ptr[Byte] | Ptr[?]): PFNGLENDTRANSFORMFEEDBACKNVPROC = CFuncPtr.fromPtr(ptr.asInstanceOf[Ptr[Byte]])
    inline def apply(inline o: CFuncPtr0[Unit]): PFNGLENDTRANSFORMFEEDBACKNVPROC = o
    extension (v: PFNGLENDTRANSFORMFEEDBACKNVPROC)
      inline def value: CFuncPtr0[Unit] = v
      inline def toPtr: Ptr[?] = CFuncPtr.toPtr(v)

  opaque type PFNGLENDTRANSFORMFEEDBACKPROC = CFuncPtr0[Unit]
  object PFNGLENDTRANSFORMFEEDBACKPROC:
    given _tag: Tag[PFNGLENDTRANSFORMFEEDBACKPROC] = Tag.materializeCFuncPtr0[Unit]
    inline def fromPtr(ptr: Ptr[Byte] | Ptr[?]): PFNGLENDTRANSFORMFEEDBACKPROC = CFuncPtr.fromPtr(ptr.asInstanceOf[Ptr[Byte]])
    inline def apply(inline o: CFuncPtr0[Unit]): PFNGLENDTRANSFORMFEEDBACKPROC = o
    extension (v: PFNGLENDTRANSFORMFEEDBACKPROC)
      inline def value: CFuncPtr0[Unit] = v
      inline def toPtr: Ptr[?] = CFuncPtr.toPtr(v)

  opaque type PFNGLENDVERTEXSHADEREXTPROC = CFuncPtr0[Unit]
  object PFNGLENDVERTEXSHADEREXTPROC:
    given _tag: Tag[PFNGLENDVERTEXSHADEREXTPROC] = Tag.materializeCFuncPtr0[Unit]
    inline def fromPtr(ptr: Ptr[Byte] | Ptr[?]): PFNGLENDVERTEXSHADEREXTPROC = CFuncPtr.fromPtr(ptr.asInstanceOf[Ptr[Byte]])
    inline def apply(inline o: CFuncPtr0[Unit]): PFNGLENDVERTEXSHADEREXTPROC = o
    extension (v: PFNGLENDVERTEXSHADEREXTPROC)
      inline def value: CFuncPtr0[Unit] = v
      inline def toPtr: Ptr[?] = CFuncPtr.toPtr(v)

  opaque type PFNGLENDVIDEOCAPTURENVPROC = CFuncPtr1[GLuint, Unit]
  object PFNGLENDVIDEOCAPTURENVPROC:
    given _tag: Tag[PFNGLENDVIDEOCAPTURENVPROC] = Tag.materializeCFuncPtr1[GLuint, Unit]
    inline def fromPtr(ptr: Ptr[Byte] | Ptr[?]): PFNGLENDVIDEOCAPTURENVPROC = CFuncPtr.fromPtr(ptr.asInstanceOf[Ptr[Byte]])
    inline def apply(inline o: CFuncPtr1[GLuint, Unit]): PFNGLENDVIDEOCAPTURENVPROC = o
    extension (v: PFNGLENDVIDEOCAPTURENVPROC)
      inline def value: CFuncPtr1[GLuint, Unit] = v
      inline def toPtr: Ptr[?] = CFuncPtr.toPtr(v)

  opaque type PFNGLERRORSTRINGREGALPROC = CFuncPtr1[GLenum, Ptr[GLchar]]
  object PFNGLERRORSTRINGREGALPROC:
    given _tag: Tag[PFNGLERRORSTRINGREGALPROC] = Tag.materializeCFuncPtr1[GLenum, Ptr[GLchar]]
    inline def fromPtr(ptr: Ptr[Byte] | Ptr[?]): PFNGLERRORSTRINGREGALPROC = CFuncPtr.fromPtr(ptr.asInstanceOf[Ptr[Byte]])
    inline def apply(inline o: CFuncPtr1[GLenum, Ptr[GLchar]]): PFNGLERRORSTRINGREGALPROC = o
    extension (v: PFNGLERRORSTRINGREGALPROC)
      inline def value: CFuncPtr1[GLenum, Ptr[GLchar]] = v
      inline def toPtr: Ptr[?] = CFuncPtr.toPtr(v)

  opaque type PFNGLEVALMAPSNVPROC = CFuncPtr2[GLenum, GLenum, Unit]
  object PFNGLEVALMAPSNVPROC:
    given _tag: Tag[PFNGLEVALMAPSNVPROC] = Tag.materializeCFuncPtr2[GLenum, GLenum, Unit]
    inline def fromPtr(ptr: Ptr[Byte] | Ptr[?]): PFNGLEVALMAPSNVPROC = CFuncPtr.fromPtr(ptr.asInstanceOf[Ptr[Byte]])
    inline def apply(inline o: CFuncPtr2[GLenum, GLenum, Unit]): PFNGLEVALMAPSNVPROC = o
    extension (v: PFNGLEVALMAPSNVPROC)
      inline def value: CFuncPtr2[GLenum, GLenum, Unit] = v
      inline def toPtr: Ptr[?] = CFuncPtr.toPtr(v)

  opaque type PFNGLEXECUTEPROGRAMNVPROC = CFuncPtr3[GLenum, GLuint, Ptr[GLfloat], Unit]
  object PFNGLEXECUTEPROGRAMNVPROC:
    given _tag: Tag[PFNGLEXECUTEPROGRAMNVPROC] = Tag.materializeCFuncPtr3[GLenum, GLuint, Ptr[GLfloat], Unit]
    inline def fromPtr(ptr: Ptr[Byte] | Ptr[?]): PFNGLEXECUTEPROGRAMNVPROC = CFuncPtr.fromPtr(ptr.asInstanceOf[Ptr[Byte]])
    inline def apply(inline o: CFuncPtr3[GLenum, GLuint, Ptr[GLfloat], Unit]): PFNGLEXECUTEPROGRAMNVPROC = o
    extension (v: PFNGLEXECUTEPROGRAMNVPROC)
      inline def value: CFuncPtr3[GLenum, GLuint, Ptr[GLfloat], Unit] = v
      inline def toPtr: Ptr[?] = CFuncPtr.toPtr(v)

  opaque type PFNGLEXTGETBUFFERPOINTERVQCOMPROC = CFuncPtr2[GLenum, Ptr[Ptr[Byte]], Unit]
  object PFNGLEXTGETBUFFERPOINTERVQCOMPROC:
    given _tag: Tag[PFNGLEXTGETBUFFERPOINTERVQCOMPROC] = Tag.materializeCFuncPtr2[GLenum, Ptr[Ptr[Byte]], Unit]
    inline def fromPtr(ptr: Ptr[Byte] | Ptr[?]): PFNGLEXTGETBUFFERPOINTERVQCOMPROC = CFuncPtr.fromPtr(ptr.asInstanceOf[Ptr[Byte]])
    inline def apply(inline o: CFuncPtr2[GLenum, Ptr[Ptr[Byte]], Unit]): PFNGLEXTGETBUFFERPOINTERVQCOMPROC = o
    extension (v: PFNGLEXTGETBUFFERPOINTERVQCOMPROC)
      inline def value: CFuncPtr2[GLenum, Ptr[Ptr[Byte]], Unit] = v
      inline def toPtr: Ptr[?] = CFuncPtr.toPtr(v)

  opaque type PFNGLEXTGETBUFFERSQCOMPROC = CFuncPtr3[Ptr[GLuint], GLint, Ptr[GLint], Unit]
  object PFNGLEXTGETBUFFERSQCOMPROC:
    given _tag: Tag[PFNGLEXTGETBUFFERSQCOMPROC] = Tag.materializeCFuncPtr3[Ptr[GLuint], GLint, Ptr[GLint], Unit]
    inline def fromPtr(ptr: Ptr[Byte] | Ptr[?]): PFNGLEXTGETBUFFERSQCOMPROC = CFuncPtr.fromPtr(ptr.asInstanceOf[Ptr[Byte]])
    inline def apply(inline o: CFuncPtr3[Ptr[GLuint], GLint, Ptr[GLint], Unit]): PFNGLEXTGETBUFFERSQCOMPROC = o
    extension (v: PFNGLEXTGETBUFFERSQCOMPROC)
      inline def value: CFuncPtr3[Ptr[GLuint], GLint, Ptr[GLint], Unit] = v
      inline def toPtr: Ptr[?] = CFuncPtr.toPtr(v)

  opaque type PFNGLEXTGETFRAMEBUFFERSQCOMPROC = CFuncPtr3[Ptr[GLuint], GLint, Ptr[GLint], Unit]
  object PFNGLEXTGETFRAMEBUFFERSQCOMPROC:
    given _tag: Tag[PFNGLEXTGETFRAMEBUFFERSQCOMPROC] = Tag.materializeCFuncPtr3[Ptr[GLuint], GLint, Ptr[GLint], Unit]
    inline def fromPtr(ptr: Ptr[Byte] | Ptr[?]): PFNGLEXTGETFRAMEBUFFERSQCOMPROC = CFuncPtr.fromPtr(ptr.asInstanceOf[Ptr[Byte]])
    inline def apply(inline o: CFuncPtr3[Ptr[GLuint], GLint, Ptr[GLint], Unit]): PFNGLEXTGETFRAMEBUFFERSQCOMPROC = o
    extension (v: PFNGLEXTGETFRAMEBUFFERSQCOMPROC)
      inline def value: CFuncPtr3[Ptr[GLuint], GLint, Ptr[GLint], Unit] = v
      inline def toPtr: Ptr[?] = CFuncPtr.toPtr(v)

  opaque type PFNGLEXTGETPROGRAMBINARYSOURCEQCOMPROC = CFuncPtr4[GLuint, GLenum, Ptr[GLchar], Ptr[GLint], Unit]
  object PFNGLEXTGETPROGRAMBINARYSOURCEQCOMPROC:
    given _tag: Tag[PFNGLEXTGETPROGRAMBINARYSOURCEQCOMPROC] = Tag.materializeCFuncPtr4[GLuint, GLenum, Ptr[GLchar], Ptr[GLint], Unit]
    inline def fromPtr(ptr: Ptr[Byte] | Ptr[?]): PFNGLEXTGETPROGRAMBINARYSOURCEQCOMPROC = CFuncPtr.fromPtr(ptr.asInstanceOf[Ptr[Byte]])
    inline def apply(inline o: CFuncPtr4[GLuint, GLenum, Ptr[GLchar], Ptr[GLint], Unit]): PFNGLEXTGETPROGRAMBINARYSOURCEQCOMPROC = o
    extension (v: PFNGLEXTGETPROGRAMBINARYSOURCEQCOMPROC)
      inline def value: CFuncPtr4[GLuint, GLenum, Ptr[GLchar], Ptr[GLint], Unit] = v
      inline def toPtr: Ptr[?] = CFuncPtr.toPtr(v)

  opaque type PFNGLEXTGETPROGRAMSQCOMPROC = CFuncPtr3[Ptr[GLuint], GLint, Ptr[GLint], Unit]
  object PFNGLEXTGETPROGRAMSQCOMPROC:
    given _tag: Tag[PFNGLEXTGETPROGRAMSQCOMPROC] = Tag.materializeCFuncPtr3[Ptr[GLuint], GLint, Ptr[GLint], Unit]
    inline def fromPtr(ptr: Ptr[Byte] | Ptr[?]): PFNGLEXTGETPROGRAMSQCOMPROC = CFuncPtr.fromPtr(ptr.asInstanceOf[Ptr[Byte]])
    inline def apply(inline o: CFuncPtr3[Ptr[GLuint], GLint, Ptr[GLint], Unit]): PFNGLEXTGETPROGRAMSQCOMPROC = o
    extension (v: PFNGLEXTGETPROGRAMSQCOMPROC)
      inline def value: CFuncPtr3[Ptr[GLuint], GLint, Ptr[GLint], Unit] = v
      inline def toPtr: Ptr[?] = CFuncPtr.toPtr(v)

  opaque type PFNGLEXTGETRENDERBUFFERSQCOMPROC = CFuncPtr3[Ptr[GLuint], GLint, Ptr[GLint], Unit]
  object PFNGLEXTGETRENDERBUFFERSQCOMPROC:
    given _tag: Tag[PFNGLEXTGETRENDERBUFFERSQCOMPROC] = Tag.materializeCFuncPtr3[Ptr[GLuint], GLint, Ptr[GLint], Unit]
    inline def fromPtr(ptr: Ptr[Byte] | Ptr[?]): PFNGLEXTGETRENDERBUFFERSQCOMPROC = CFuncPtr.fromPtr(ptr.asInstanceOf[Ptr[Byte]])
    inline def apply(inline o: CFuncPtr3[Ptr[GLuint], GLint, Ptr[GLint], Unit]): PFNGLEXTGETRENDERBUFFERSQCOMPROC = o
    extension (v: PFNGLEXTGETRENDERBUFFERSQCOMPROC)
      inline def value: CFuncPtr3[Ptr[GLuint], GLint, Ptr[GLint], Unit] = v
      inline def toPtr: Ptr[?] = CFuncPtr.toPtr(v)

  opaque type PFNGLEXTGETSHADERSQCOMPROC = CFuncPtr3[Ptr[GLuint], GLint, Ptr[GLint], Unit]
  object PFNGLEXTGETSHADERSQCOMPROC:
    given _tag: Tag[PFNGLEXTGETSHADERSQCOMPROC] = Tag.materializeCFuncPtr3[Ptr[GLuint], GLint, Ptr[GLint], Unit]
    inline def fromPtr(ptr: Ptr[Byte] | Ptr[?]): PFNGLEXTGETSHADERSQCOMPROC = CFuncPtr.fromPtr(ptr.asInstanceOf[Ptr[Byte]])
    inline def apply(inline o: CFuncPtr3[Ptr[GLuint], GLint, Ptr[GLint], Unit]): PFNGLEXTGETSHADERSQCOMPROC = o
    extension (v: PFNGLEXTGETSHADERSQCOMPROC)
      inline def value: CFuncPtr3[Ptr[GLuint], GLint, Ptr[GLint], Unit] = v
      inline def toPtr: Ptr[?] = CFuncPtr.toPtr(v)

  opaque type PFNGLEXTGETTEXLEVELPARAMETERIVQCOMPROC = CFuncPtr5[GLuint, GLenum, GLint, GLenum, Ptr[GLint], Unit]
  object PFNGLEXTGETTEXLEVELPARAMETERIVQCOMPROC:
    given _tag: Tag[PFNGLEXTGETTEXLEVELPARAMETERIVQCOMPROC] = Tag.materializeCFuncPtr5[GLuint, GLenum, GLint, GLenum, Ptr[GLint], Unit]
    inline def fromPtr(ptr: Ptr[Byte] | Ptr[?]): PFNGLEXTGETTEXLEVELPARAMETERIVQCOMPROC = CFuncPtr.fromPtr(ptr.asInstanceOf[Ptr[Byte]])
    inline def apply(inline o: CFuncPtr5[GLuint, GLenum, GLint, GLenum, Ptr[GLint], Unit]): PFNGLEXTGETTEXLEVELPARAMETERIVQCOMPROC = o
    extension (v: PFNGLEXTGETTEXLEVELPARAMETERIVQCOMPROC)
      inline def value: CFuncPtr5[GLuint, GLenum, GLint, GLenum, Ptr[GLint], Unit] = v
      inline def toPtr: Ptr[?] = CFuncPtr.toPtr(v)

  opaque type PFNGLEXTGETTEXSUBIMAGEQCOMPROC = CFuncPtr11[GLenum, GLint, GLint, GLint, GLint, GLsizei, GLsizei, GLsizei, GLenum, GLenum, Ptr[Byte], Unit]
  object PFNGLEXTGETTEXSUBIMAGEQCOMPROC:
    given _tag: Tag[PFNGLEXTGETTEXSUBIMAGEQCOMPROC] = Tag.materializeCFuncPtr11[GLenum, GLint, GLint, GLint, GLint, GLsizei, GLsizei, GLsizei, GLenum, GLenum, Ptr[Byte], Unit]
    inline def fromPtr(ptr: Ptr[Byte] | Ptr[?]): PFNGLEXTGETTEXSUBIMAGEQCOMPROC = CFuncPtr.fromPtr(ptr.asInstanceOf[Ptr[Byte]])
    inline def apply(inline o: CFuncPtr11[GLenum, GLint, GLint, GLint, GLint, GLsizei, GLsizei, GLsizei, GLenum, GLenum, Ptr[Byte], Unit]): PFNGLEXTGETTEXSUBIMAGEQCOMPROC = o
    extension (v: PFNGLEXTGETTEXSUBIMAGEQCOMPROC)
      inline def value: CFuncPtr11[GLenum, GLint, GLint, GLint, GLint, GLsizei, GLsizei, GLsizei, GLenum, GLenum, Ptr[Byte], Unit] = v
      inline def toPtr: Ptr[?] = CFuncPtr.toPtr(v)

  opaque type PFNGLEXTGETTEXTURESQCOMPROC = CFuncPtr3[Ptr[GLuint], GLint, Ptr[GLint], Unit]
  object PFNGLEXTGETTEXTURESQCOMPROC:
    given _tag: Tag[PFNGLEXTGETTEXTURESQCOMPROC] = Tag.materializeCFuncPtr3[Ptr[GLuint], GLint, Ptr[GLint], Unit]
    inline def fromPtr(ptr: Ptr[Byte] | Ptr[?]): PFNGLEXTGETTEXTURESQCOMPROC = CFuncPtr.fromPtr(ptr.asInstanceOf[Ptr[Byte]])
    inline def apply(inline o: CFuncPtr3[Ptr[GLuint], GLint, Ptr[GLint], Unit]): PFNGLEXTGETTEXTURESQCOMPROC = o
    extension (v: PFNGLEXTGETTEXTURESQCOMPROC)
      inline def value: CFuncPtr3[Ptr[GLuint], GLint, Ptr[GLint], Unit] = v
      inline def toPtr: Ptr[?] = CFuncPtr.toPtr(v)

  opaque type PFNGLEXTISPROGRAMBINARYQCOMPROC = CFuncPtr1[GLuint, GLboolean]
  object PFNGLEXTISPROGRAMBINARYQCOMPROC:
    given _tag: Tag[PFNGLEXTISPROGRAMBINARYQCOMPROC] = Tag.materializeCFuncPtr1[GLuint, GLboolean]
    inline def fromPtr(ptr: Ptr[Byte] | Ptr[?]): PFNGLEXTISPROGRAMBINARYQCOMPROC = CFuncPtr.fromPtr(ptr.asInstanceOf[Ptr[Byte]])
    inline def apply(inline o: CFuncPtr1[GLuint, GLboolean]): PFNGLEXTISPROGRAMBINARYQCOMPROC = o
    extension (v: PFNGLEXTISPROGRAMBINARYQCOMPROC)
      inline def value: CFuncPtr1[GLuint, GLboolean] = v
      inline def toPtr: Ptr[?] = CFuncPtr.toPtr(v)

  opaque type PFNGLEXTRACTCOMPONENTEXTPROC = CFuncPtr3[GLuint, GLuint, GLuint, Unit]
  object PFNGLEXTRACTCOMPONENTEXTPROC:
    given _tag: Tag[PFNGLEXTRACTCOMPONENTEXTPROC] = Tag.materializeCFuncPtr3[GLuint, GLuint, GLuint, Unit]
    inline def fromPtr(ptr: Ptr[Byte] | Ptr[?]): PFNGLEXTRACTCOMPONENTEXTPROC = CFuncPtr.fromPtr(ptr.asInstanceOf[Ptr[Byte]])
    inline def apply(inline o: CFuncPtr3[GLuint, GLuint, GLuint, Unit]): PFNGLEXTRACTCOMPONENTEXTPROC = o
    extension (v: PFNGLEXTRACTCOMPONENTEXTPROC)
      inline def value: CFuncPtr3[GLuint, GLuint, GLuint, Unit] = v
      inline def toPtr: Ptr[?] = CFuncPtr.toPtr(v)

  opaque type PFNGLEXTTEXOBJECTSTATEOVERRIDEIQCOMPROC = CFuncPtr3[GLenum, GLenum, GLint, Unit]
  object PFNGLEXTTEXOBJECTSTATEOVERRIDEIQCOMPROC:
    given _tag: Tag[PFNGLEXTTEXOBJECTSTATEOVERRIDEIQCOMPROC] = Tag.materializeCFuncPtr3[GLenum, GLenum, GLint, Unit]
    inline def fromPtr(ptr: Ptr[Byte] | Ptr[?]): PFNGLEXTTEXOBJECTSTATEOVERRIDEIQCOMPROC = CFuncPtr.fromPtr(ptr.asInstanceOf[Ptr[Byte]])
    inline def apply(inline o: CFuncPtr3[GLenum, GLenum, GLint, Unit]): PFNGLEXTTEXOBJECTSTATEOVERRIDEIQCOMPROC = o
    extension (v: PFNGLEXTTEXOBJECTSTATEOVERRIDEIQCOMPROC)
      inline def value: CFuncPtr3[GLenum, GLenum, GLint, Unit] = v
      inline def toPtr: Ptr[?] = CFuncPtr.toPtr(v)

  opaque type PFNGLFENCESYNCAPPLEPROC = CFuncPtr2[GLenum, GLbitfield, GLsync]
  object PFNGLFENCESYNCAPPLEPROC:
    given _tag: Tag[PFNGLFENCESYNCAPPLEPROC] = Tag.materializeCFuncPtr2[GLenum, GLbitfield, GLsync]
    inline def fromPtr(ptr: Ptr[Byte] | Ptr[?]): PFNGLFENCESYNCAPPLEPROC = CFuncPtr.fromPtr(ptr.asInstanceOf[Ptr[Byte]])
    inline def apply(inline o: CFuncPtr2[GLenum, GLbitfield, GLsync]): PFNGLFENCESYNCAPPLEPROC = o
    extension (v: PFNGLFENCESYNCAPPLEPROC)
      inline def value: CFuncPtr2[GLenum, GLbitfield, GLsync] = v
      inline def toPtr: Ptr[?] = CFuncPtr.toPtr(v)

  opaque type PFNGLFENCESYNCPROC = CFuncPtr2[GLenum, GLbitfield, GLsync]
  object PFNGLFENCESYNCPROC:
    given _tag: Tag[PFNGLFENCESYNCPROC] = Tag.materializeCFuncPtr2[GLenum, GLbitfield, GLsync]
    inline def fromPtr(ptr: Ptr[Byte] | Ptr[?]): PFNGLFENCESYNCPROC = CFuncPtr.fromPtr(ptr.asInstanceOf[Ptr[Byte]])
    inline def apply(inline o: CFuncPtr2[GLenum, GLbitfield, GLsync]): PFNGLFENCESYNCPROC = o
    extension (v: PFNGLFENCESYNCPROC)
      inline def value: CFuncPtr2[GLenum, GLbitfield, GLsync] = v
      inline def toPtr: Ptr[?] = CFuncPtr.toPtr(v)

  opaque type PFNGLFINALCOMBINERINPUTNVPROC = CFuncPtr4[GLenum, GLenum, GLenum, GLenum, Unit]
  object PFNGLFINALCOMBINERINPUTNVPROC:
    given _tag: Tag[PFNGLFINALCOMBINERINPUTNVPROC] = Tag.materializeCFuncPtr4[GLenum, GLenum, GLenum, GLenum, Unit]
    inline def fromPtr(ptr: Ptr[Byte] | Ptr[?]): PFNGLFINALCOMBINERINPUTNVPROC = CFuncPtr.fromPtr(ptr.asInstanceOf[Ptr[Byte]])
    inline def apply(inline o: CFuncPtr4[GLenum, GLenum, GLenum, GLenum, Unit]): PFNGLFINALCOMBINERINPUTNVPROC = o
    extension (v: PFNGLFINALCOMBINERINPUTNVPROC)
      inline def value: CFuncPtr4[GLenum, GLenum, GLenum, GLenum, Unit] = v
      inline def toPtr: Ptr[?] = CFuncPtr.toPtr(v)

  opaque type PFNGLFINISHASYNCSGIXPROC = CFuncPtr1[Ptr[GLuint], GLint]
  object PFNGLFINISHASYNCSGIXPROC:
    given _tag: Tag[PFNGLFINISHASYNCSGIXPROC] = Tag.materializeCFuncPtr1[Ptr[GLuint], GLint]
    inline def fromPtr(ptr: Ptr[Byte] | Ptr[?]): PFNGLFINISHASYNCSGIXPROC = CFuncPtr.fromPtr(ptr.asInstanceOf[Ptr[Byte]])
    inline def apply(inline o: CFuncPtr1[Ptr[GLuint], GLint]): PFNGLFINISHASYNCSGIXPROC = o
    extension (v: PFNGLFINISHASYNCSGIXPROC)
      inline def value: CFuncPtr1[Ptr[GLuint], GLint] = v
      inline def toPtr: Ptr[?] = CFuncPtr.toPtr(v)

  opaque type PFNGLFINISHFENCEAPPLEPROC = CFuncPtr1[GLuint, Unit]
  object PFNGLFINISHFENCEAPPLEPROC:
    given _tag: Tag[PFNGLFINISHFENCEAPPLEPROC] = Tag.materializeCFuncPtr1[GLuint, Unit]
    inline def fromPtr(ptr: Ptr[Byte] | Ptr[?]): PFNGLFINISHFENCEAPPLEPROC = CFuncPtr.fromPtr(ptr.asInstanceOf[Ptr[Byte]])
    inline def apply(inline o: CFuncPtr1[GLuint, Unit]): PFNGLFINISHFENCEAPPLEPROC = o
    extension (v: PFNGLFINISHFENCEAPPLEPROC)
      inline def value: CFuncPtr1[GLuint, Unit] = v
      inline def toPtr: Ptr[?] = CFuncPtr.toPtr(v)

  opaque type PFNGLFINISHFENCENVPROC = CFuncPtr1[GLuint, Unit]
  object PFNGLFINISHFENCENVPROC:
    given _tag: Tag[PFNGLFINISHFENCENVPROC] = Tag.materializeCFuncPtr1[GLuint, Unit]
    inline def fromPtr(ptr: Ptr[Byte] | Ptr[?]): PFNGLFINISHFENCENVPROC = CFuncPtr.fromPtr(ptr.asInstanceOf[Ptr[Byte]])
    inline def apply(inline o: CFuncPtr1[GLuint, Unit]): PFNGLFINISHFENCENVPROC = o
    extension (v: PFNGLFINISHFENCENVPROC)
      inline def value: CFuncPtr1[GLuint, Unit] = v
      inline def toPtr: Ptr[?] = CFuncPtr.toPtr(v)

  opaque type PFNGLFINISHOBJECTAPPLEPROC = CFuncPtr2[GLenum, GLint, Unit]
  object PFNGLFINISHOBJECTAPPLEPROC:
    given _tag: Tag[PFNGLFINISHOBJECTAPPLEPROC] = Tag.materializeCFuncPtr2[GLenum, GLint, Unit]
    inline def fromPtr(ptr: Ptr[Byte] | Ptr[?]): PFNGLFINISHOBJECTAPPLEPROC = CFuncPtr.fromPtr(ptr.asInstanceOf[Ptr[Byte]])
    inline def apply(inline o: CFuncPtr2[GLenum, GLint, Unit]): PFNGLFINISHOBJECTAPPLEPROC = o
    extension (v: PFNGLFINISHOBJECTAPPLEPROC)
      inline def value: CFuncPtr2[GLenum, GLint, Unit] = v
      inline def toPtr: Ptr[?] = CFuncPtr.toPtr(v)

  opaque type PFNGLFINISHTEXTURESUNXPROC = CFuncPtr0[Unit]
  object PFNGLFINISHTEXTURESUNXPROC:
    given _tag: Tag[PFNGLFINISHTEXTURESUNXPROC] = Tag.materializeCFuncPtr0[Unit]
    inline def fromPtr(ptr: Ptr[Byte] | Ptr[?]): PFNGLFINISHTEXTURESUNXPROC = CFuncPtr.fromPtr(ptr.asInstanceOf[Ptr[Byte]])
    inline def apply(inline o: CFuncPtr0[Unit]): PFNGLFINISHTEXTURESUNXPROC = o
    extension (v: PFNGLFINISHTEXTURESUNXPROC)
      inline def value: CFuncPtr0[Unit] = v
      inline def toPtr: Ptr[?] = CFuncPtr.toPtr(v)

  opaque type PFNGLFLUSHMAPPEDBUFFERRANGEAPPLEPROC = CFuncPtr3[GLenum, GLintptr, GLsizeiptr, Unit]
  object PFNGLFLUSHMAPPEDBUFFERRANGEAPPLEPROC:
    given _tag: Tag[PFNGLFLUSHMAPPEDBUFFERRANGEAPPLEPROC] = Tag.materializeCFuncPtr3[GLenum, GLintptr, GLsizeiptr, Unit]
    inline def fromPtr(ptr: Ptr[Byte] | Ptr[?]): PFNGLFLUSHMAPPEDBUFFERRANGEAPPLEPROC = CFuncPtr.fromPtr(ptr.asInstanceOf[Ptr[Byte]])
    inline def apply(inline o: CFuncPtr3[GLenum, GLintptr, GLsizeiptr, Unit]): PFNGLFLUSHMAPPEDBUFFERRANGEAPPLEPROC = o
    extension (v: PFNGLFLUSHMAPPEDBUFFERRANGEAPPLEPROC)
      inline def value: CFuncPtr3[GLenum, GLintptr, GLsizeiptr, Unit] = v
      inline def toPtr: Ptr[?] = CFuncPtr.toPtr(v)

  opaque type PFNGLFLUSHMAPPEDBUFFERRANGEEXTPROC = CFuncPtr3[GLenum, GLintptr, GLsizeiptr, Unit]
  object PFNGLFLUSHMAPPEDBUFFERRANGEEXTPROC:
    given _tag: Tag[PFNGLFLUSHMAPPEDBUFFERRANGEEXTPROC] = Tag.materializeCFuncPtr3[GLenum, GLintptr, GLsizeiptr, Unit]
    inline def fromPtr(ptr: Ptr[Byte] | Ptr[?]): PFNGLFLUSHMAPPEDBUFFERRANGEEXTPROC = CFuncPtr.fromPtr(ptr.asInstanceOf[Ptr[Byte]])
    inline def apply(inline o: CFuncPtr3[GLenum, GLintptr, GLsizeiptr, Unit]): PFNGLFLUSHMAPPEDBUFFERRANGEEXTPROC = o
    extension (v: PFNGLFLUSHMAPPEDBUFFERRANGEEXTPROC)
      inline def value: CFuncPtr3[GLenum, GLintptr, GLsizeiptr, Unit] = v
      inline def toPtr: Ptr[?] = CFuncPtr.toPtr(v)

  opaque type PFNGLFLUSHMAPPEDBUFFERRANGEPROC = CFuncPtr3[GLenum, GLintptr, GLsizeiptr, Unit]
  object PFNGLFLUSHMAPPEDBUFFERRANGEPROC:
    given _tag: Tag[PFNGLFLUSHMAPPEDBUFFERRANGEPROC] = Tag.materializeCFuncPtr3[GLenum, GLintptr, GLsizeiptr, Unit]
    inline def fromPtr(ptr: Ptr[Byte] | Ptr[?]): PFNGLFLUSHMAPPEDBUFFERRANGEPROC = CFuncPtr.fromPtr(ptr.asInstanceOf[Ptr[Byte]])
    inline def apply(inline o: CFuncPtr3[GLenum, GLintptr, GLsizeiptr, Unit]): PFNGLFLUSHMAPPEDBUFFERRANGEPROC = o
    extension (v: PFNGLFLUSHMAPPEDBUFFERRANGEPROC)
      inline def value: CFuncPtr3[GLenum, GLintptr, GLsizeiptr, Unit] = v
      inline def toPtr: Ptr[?] = CFuncPtr.toPtr(v)

  opaque type PFNGLFLUSHMAPPEDNAMEDBUFFERRANGEEXTPROC = CFuncPtr3[GLuint, GLintptr, GLsizeiptr, Unit]
  object PFNGLFLUSHMAPPEDNAMEDBUFFERRANGEEXTPROC:
    given _tag: Tag[PFNGLFLUSHMAPPEDNAMEDBUFFERRANGEEXTPROC] = Tag.materializeCFuncPtr3[GLuint, GLintptr, GLsizeiptr, Unit]
    inline def fromPtr(ptr: Ptr[Byte] | Ptr[?]): PFNGLFLUSHMAPPEDNAMEDBUFFERRANGEEXTPROC = CFuncPtr.fromPtr(ptr.asInstanceOf[Ptr[Byte]])
    inline def apply(inline o: CFuncPtr3[GLuint, GLintptr, GLsizeiptr, Unit]): PFNGLFLUSHMAPPEDNAMEDBUFFERRANGEEXTPROC = o
    extension (v: PFNGLFLUSHMAPPEDNAMEDBUFFERRANGEEXTPROC)
      inline def value: CFuncPtr3[GLuint, GLintptr, GLsizeiptr, Unit] = v
      inline def toPtr: Ptr[?] = CFuncPtr.toPtr(v)

  opaque type PFNGLFLUSHMAPPEDNAMEDBUFFERRANGEPROC = CFuncPtr3[GLuint, GLintptr, GLsizeiptr, Unit]
  object PFNGLFLUSHMAPPEDNAMEDBUFFERRANGEPROC:
    given _tag: Tag[PFNGLFLUSHMAPPEDNAMEDBUFFERRANGEPROC] = Tag.materializeCFuncPtr3[GLuint, GLintptr, GLsizeiptr, Unit]
    inline def fromPtr(ptr: Ptr[Byte] | Ptr[?]): PFNGLFLUSHMAPPEDNAMEDBUFFERRANGEPROC = CFuncPtr.fromPtr(ptr.asInstanceOf[Ptr[Byte]])
    inline def apply(inline o: CFuncPtr3[GLuint, GLintptr, GLsizeiptr, Unit]): PFNGLFLUSHMAPPEDNAMEDBUFFERRANGEPROC = o
    extension (v: PFNGLFLUSHMAPPEDNAMEDBUFFERRANGEPROC)
      inline def value: CFuncPtr3[GLuint, GLintptr, GLsizeiptr, Unit] = v
      inline def toPtr: Ptr[?] = CFuncPtr.toPtr(v)

  opaque type PFNGLFLUSHPIXELDATARANGENVPROC = CFuncPtr1[GLenum, Unit]
  object PFNGLFLUSHPIXELDATARANGENVPROC:
    given _tag: Tag[PFNGLFLUSHPIXELDATARANGENVPROC] = Tag.materializeCFuncPtr1[GLenum, Unit]
    inline def fromPtr(ptr: Ptr[Byte] | Ptr[?]): PFNGLFLUSHPIXELDATARANGENVPROC = CFuncPtr.fromPtr(ptr.asInstanceOf[Ptr[Byte]])
    inline def apply(inline o: CFuncPtr1[GLenum, Unit]): PFNGLFLUSHPIXELDATARANGENVPROC = o
    extension (v: PFNGLFLUSHPIXELDATARANGENVPROC)
      inline def value: CFuncPtr1[GLenum, Unit] = v
      inline def toPtr: Ptr[?] = CFuncPtr.toPtr(v)

  opaque type PFNGLFLUSHRASTERSGIXPROC = CFuncPtr0[Unit]
  object PFNGLFLUSHRASTERSGIXPROC:
    given _tag: Tag[PFNGLFLUSHRASTERSGIXPROC] = Tag.materializeCFuncPtr0[Unit]
    inline def fromPtr(ptr: Ptr[Byte] | Ptr[?]): PFNGLFLUSHRASTERSGIXPROC = CFuncPtr.fromPtr(ptr.asInstanceOf[Ptr[Byte]])
    inline def apply(inline o: CFuncPtr0[Unit]): PFNGLFLUSHRASTERSGIXPROC = o
    extension (v: PFNGLFLUSHRASTERSGIXPROC)
      inline def value: CFuncPtr0[Unit] = v
      inline def toPtr: Ptr[?] = CFuncPtr.toPtr(v)

  opaque type PFNGLFLUSHVERTEXARRAYRANGEAPPLEPROC = CFuncPtr2[GLsizei, Ptr[Byte], Unit]
  object PFNGLFLUSHVERTEXARRAYRANGEAPPLEPROC:
    given _tag: Tag[PFNGLFLUSHVERTEXARRAYRANGEAPPLEPROC] = Tag.materializeCFuncPtr2[GLsizei, Ptr[Byte], Unit]
    inline def fromPtr(ptr: Ptr[Byte] | Ptr[?]): PFNGLFLUSHVERTEXARRAYRANGEAPPLEPROC = CFuncPtr.fromPtr(ptr.asInstanceOf[Ptr[Byte]])
    inline def apply(inline o: CFuncPtr2[GLsizei, Ptr[Byte], Unit]): PFNGLFLUSHVERTEXARRAYRANGEAPPLEPROC = o
    extension (v: PFNGLFLUSHVERTEXARRAYRANGEAPPLEPROC)
      inline def value: CFuncPtr2[GLsizei, Ptr[Byte], Unit] = v
      inline def toPtr: Ptr[?] = CFuncPtr.toPtr(v)

  opaque type PFNGLFLUSHVERTEXARRAYRANGENVPROC = CFuncPtr0[Unit]
  object PFNGLFLUSHVERTEXARRAYRANGENVPROC:
    given _tag: Tag[PFNGLFLUSHVERTEXARRAYRANGENVPROC] = Tag.materializeCFuncPtr0[Unit]
    inline def fromPtr(ptr: Ptr[Byte] | Ptr[?]): PFNGLFLUSHVERTEXARRAYRANGENVPROC = CFuncPtr.fromPtr(ptr.asInstanceOf[Ptr[Byte]])
    inline def apply(inline o: CFuncPtr0[Unit]): PFNGLFLUSHVERTEXARRAYRANGENVPROC = o
    extension (v: PFNGLFLUSHVERTEXARRAYRANGENVPROC)
      inline def value: CFuncPtr0[Unit] = v
      inline def toPtr: Ptr[?] = CFuncPtr.toPtr(v)

  opaque type PFNGLFOGCOORDDEXTPROC = CFuncPtr1[GLdouble, Unit]
  object PFNGLFOGCOORDDEXTPROC:
    given _tag: Tag[PFNGLFOGCOORDDEXTPROC] = Tag.materializeCFuncPtr1[GLdouble, Unit]
    inline def fromPtr(ptr: Ptr[Byte] | Ptr[?]): PFNGLFOGCOORDDEXTPROC = CFuncPtr.fromPtr(ptr.asInstanceOf[Ptr[Byte]])
    inline def apply(inline o: CFuncPtr1[GLdouble, Unit]): PFNGLFOGCOORDDEXTPROC = o
    extension (v: PFNGLFOGCOORDDEXTPROC)
      inline def value: CFuncPtr1[GLdouble, Unit] = v
      inline def toPtr: Ptr[?] = CFuncPtr.toPtr(v)

  opaque type PFNGLFOGCOORDDPROC = CFuncPtr1[GLdouble, Unit]
  object PFNGLFOGCOORDDPROC:
    given _tag: Tag[PFNGLFOGCOORDDPROC] = Tag.materializeCFuncPtr1[GLdouble, Unit]
    inline def fromPtr(ptr: Ptr[Byte] | Ptr[?]): PFNGLFOGCOORDDPROC = CFuncPtr.fromPtr(ptr.asInstanceOf[Ptr[Byte]])
    inline def apply(inline o: CFuncPtr1[GLdouble, Unit]): PFNGLFOGCOORDDPROC = o
    extension (v: PFNGLFOGCOORDDPROC)
      inline def value: CFuncPtr1[GLdouble, Unit] = v
      inline def toPtr: Ptr[?] = CFuncPtr.toPtr(v)

  opaque type PFNGLFOGCOORDDVEXTPROC = CFuncPtr1[Ptr[GLdouble], Unit]
  object PFNGLFOGCOORDDVEXTPROC:
    given _tag: Tag[PFNGLFOGCOORDDVEXTPROC] = Tag.materializeCFuncPtr1[Ptr[GLdouble], Unit]
    inline def fromPtr(ptr: Ptr[Byte] | Ptr[?]): PFNGLFOGCOORDDVEXTPROC = CFuncPtr.fromPtr(ptr.asInstanceOf[Ptr[Byte]])
    inline def apply(inline o: CFuncPtr1[Ptr[GLdouble], Unit]): PFNGLFOGCOORDDVEXTPROC = o
    extension (v: PFNGLFOGCOORDDVEXTPROC)
      inline def value: CFuncPtr1[Ptr[GLdouble], Unit] = v
      inline def toPtr: Ptr[?] = CFuncPtr.toPtr(v)

  opaque type PFNGLFOGCOORDDVPROC = CFuncPtr1[Ptr[GLdouble], Unit]
  object PFNGLFOGCOORDDVPROC:
    given _tag: Tag[PFNGLFOGCOORDDVPROC] = Tag.materializeCFuncPtr1[Ptr[GLdouble], Unit]
    inline def fromPtr(ptr: Ptr[Byte] | Ptr[?]): PFNGLFOGCOORDDVPROC = CFuncPtr.fromPtr(ptr.asInstanceOf[Ptr[Byte]])
    inline def apply(inline o: CFuncPtr1[Ptr[GLdouble], Unit]): PFNGLFOGCOORDDVPROC = o
    extension (v: PFNGLFOGCOORDDVPROC)
      inline def value: CFuncPtr1[Ptr[GLdouble], Unit] = v
      inline def toPtr: Ptr[?] = CFuncPtr.toPtr(v)

  opaque type PFNGLFOGCOORDFEXTPROC = CFuncPtr1[GLfloat, Unit]
  object PFNGLFOGCOORDFEXTPROC:
    given _tag: Tag[PFNGLFOGCOORDFEXTPROC] = Tag.materializeCFuncPtr1[GLfloat, Unit]
    inline def fromPtr(ptr: Ptr[Byte] | Ptr[?]): PFNGLFOGCOORDFEXTPROC = CFuncPtr.fromPtr(ptr.asInstanceOf[Ptr[Byte]])
    inline def apply(inline o: CFuncPtr1[GLfloat, Unit]): PFNGLFOGCOORDFEXTPROC = o
    extension (v: PFNGLFOGCOORDFEXTPROC)
      inline def value: CFuncPtr1[GLfloat, Unit] = v
      inline def toPtr: Ptr[?] = CFuncPtr.toPtr(v)

  opaque type PFNGLFOGCOORDFORMATNVPROC = CFuncPtr2[GLenum, GLsizei, Unit]
  object PFNGLFOGCOORDFORMATNVPROC:
    given _tag: Tag[PFNGLFOGCOORDFORMATNVPROC] = Tag.materializeCFuncPtr2[GLenum, GLsizei, Unit]
    inline def fromPtr(ptr: Ptr[Byte] | Ptr[?]): PFNGLFOGCOORDFORMATNVPROC = CFuncPtr.fromPtr(ptr.asInstanceOf[Ptr[Byte]])
    inline def apply(inline o: CFuncPtr2[GLenum, GLsizei, Unit]): PFNGLFOGCOORDFORMATNVPROC = o
    extension (v: PFNGLFOGCOORDFORMATNVPROC)
      inline def value: CFuncPtr2[GLenum, GLsizei, Unit] = v
      inline def toPtr: Ptr[?] = CFuncPtr.toPtr(v)

  opaque type PFNGLFOGCOORDFPROC = CFuncPtr1[GLfloat, Unit]
  object PFNGLFOGCOORDFPROC:
    given _tag: Tag[PFNGLFOGCOORDFPROC] = Tag.materializeCFuncPtr1[GLfloat, Unit]
    inline def fromPtr(ptr: Ptr[Byte] | Ptr[?]): PFNGLFOGCOORDFPROC = CFuncPtr.fromPtr(ptr.asInstanceOf[Ptr[Byte]])
    inline def apply(inline o: CFuncPtr1[GLfloat, Unit]): PFNGLFOGCOORDFPROC = o
    extension (v: PFNGLFOGCOORDFPROC)
      inline def value: CFuncPtr1[GLfloat, Unit] = v
      inline def toPtr: Ptr[?] = CFuncPtr.toPtr(v)

  opaque type PFNGLFOGCOORDFVEXTPROC = CFuncPtr1[Ptr[GLfloat], Unit]
  object PFNGLFOGCOORDFVEXTPROC:
    given _tag: Tag[PFNGLFOGCOORDFVEXTPROC] = Tag.materializeCFuncPtr1[Ptr[GLfloat], Unit]
    inline def fromPtr(ptr: Ptr[Byte] | Ptr[?]): PFNGLFOGCOORDFVEXTPROC = CFuncPtr.fromPtr(ptr.asInstanceOf[Ptr[Byte]])
    inline def apply(inline o: CFuncPtr1[Ptr[GLfloat], Unit]): PFNGLFOGCOORDFVEXTPROC = o
    extension (v: PFNGLFOGCOORDFVEXTPROC)
      inline def value: CFuncPtr1[Ptr[GLfloat], Unit] = v
      inline def toPtr: Ptr[?] = CFuncPtr.toPtr(v)

  opaque type PFNGLFOGCOORDFVPROC = CFuncPtr1[Ptr[GLfloat], Unit]
  object PFNGLFOGCOORDFVPROC:
    given _tag: Tag[PFNGLFOGCOORDFVPROC] = Tag.materializeCFuncPtr1[Ptr[GLfloat], Unit]
    inline def fromPtr(ptr: Ptr[Byte] | Ptr[?]): PFNGLFOGCOORDFVPROC = CFuncPtr.fromPtr(ptr.asInstanceOf[Ptr[Byte]])
    inline def apply(inline o: CFuncPtr1[Ptr[GLfloat], Unit]): PFNGLFOGCOORDFVPROC = o
    extension (v: PFNGLFOGCOORDFVPROC)
      inline def value: CFuncPtr1[Ptr[GLfloat], Unit] = v
      inline def toPtr: Ptr[?] = CFuncPtr.toPtr(v)

  opaque type PFNGLFOGCOORDHNVPROC = CFuncPtr1[GLhalf, Unit]
  object PFNGLFOGCOORDHNVPROC:
    given _tag: Tag[PFNGLFOGCOORDHNVPROC] = Tag.materializeCFuncPtr1[GLhalf, Unit]
    inline def fromPtr(ptr: Ptr[Byte] | Ptr[?]): PFNGLFOGCOORDHNVPROC = CFuncPtr.fromPtr(ptr.asInstanceOf[Ptr[Byte]])
    inline def apply(inline o: CFuncPtr1[GLhalf, Unit]): PFNGLFOGCOORDHNVPROC = o
    extension (v: PFNGLFOGCOORDHNVPROC)
      inline def value: CFuncPtr1[GLhalf, Unit] = v
      inline def toPtr: Ptr[?] = CFuncPtr.toPtr(v)

  opaque type PFNGLFOGCOORDHVNVPROC = CFuncPtr1[Ptr[GLhalf], Unit]
  object PFNGLFOGCOORDHVNVPROC:
    given _tag: Tag[PFNGLFOGCOORDHVNVPROC] = Tag.materializeCFuncPtr1[Ptr[GLhalf], Unit]
    inline def fromPtr(ptr: Ptr[Byte] | Ptr[?]): PFNGLFOGCOORDHVNVPROC = CFuncPtr.fromPtr(ptr.asInstanceOf[Ptr[Byte]])
    inline def apply(inline o: CFuncPtr1[Ptr[GLhalf], Unit]): PFNGLFOGCOORDHVNVPROC = o
    extension (v: PFNGLFOGCOORDHVNVPROC)
      inline def value: CFuncPtr1[Ptr[GLhalf], Unit] = v
      inline def toPtr: Ptr[?] = CFuncPtr.toPtr(v)

  opaque type PFNGLFOGCOORDPOINTEREXTPROC = CFuncPtr3[GLenum, GLsizei, Ptr[Byte], Unit]
  object PFNGLFOGCOORDPOINTEREXTPROC:
    given _tag: Tag[PFNGLFOGCOORDPOINTEREXTPROC] = Tag.materializeCFuncPtr3[GLenum, GLsizei, Ptr[Byte], Unit]
    inline def fromPtr(ptr: Ptr[Byte] | Ptr[?]): PFNGLFOGCOORDPOINTEREXTPROC = CFuncPtr.fromPtr(ptr.asInstanceOf[Ptr[Byte]])
    inline def apply(inline o: CFuncPtr3[GLenum, GLsizei, Ptr[Byte], Unit]): PFNGLFOGCOORDPOINTEREXTPROC = o
    extension (v: PFNGLFOGCOORDPOINTEREXTPROC)
      inline def value: CFuncPtr3[GLenum, GLsizei, Ptr[Byte], Unit] = v
      inline def toPtr: Ptr[?] = CFuncPtr.toPtr(v)

  opaque type PFNGLFOGCOORDPOINTERLISTIBMPROC = CFuncPtr4[GLenum, GLint, Ptr[Ptr[Byte]], GLint, Unit]
  object PFNGLFOGCOORDPOINTERLISTIBMPROC:
    given _tag: Tag[PFNGLFOGCOORDPOINTERLISTIBMPROC] = Tag.materializeCFuncPtr4[GLenum, GLint, Ptr[Ptr[Byte]], GLint, Unit]
    inline def fromPtr(ptr: Ptr[Byte] | Ptr[?]): PFNGLFOGCOORDPOINTERLISTIBMPROC = CFuncPtr.fromPtr(ptr.asInstanceOf[Ptr[Byte]])
    inline def apply(inline o: CFuncPtr4[GLenum, GLint, Ptr[Ptr[Byte]], GLint, Unit]): PFNGLFOGCOORDPOINTERLISTIBMPROC = o
    extension (v: PFNGLFOGCOORDPOINTERLISTIBMPROC)
      inline def value: CFuncPtr4[GLenum, GLint, Ptr[Ptr[Byte]], GLint, Unit] = v
      inline def toPtr: Ptr[?] = CFuncPtr.toPtr(v)

  opaque type PFNGLFOGCOORDPOINTERPROC = CFuncPtr3[GLenum, GLsizei, Ptr[Byte], Unit]
  object PFNGLFOGCOORDPOINTERPROC:
    given _tag: Tag[PFNGLFOGCOORDPOINTERPROC] = Tag.materializeCFuncPtr3[GLenum, GLsizei, Ptr[Byte], Unit]
    inline def fromPtr(ptr: Ptr[Byte] | Ptr[?]): PFNGLFOGCOORDPOINTERPROC = CFuncPtr.fromPtr(ptr.asInstanceOf[Ptr[Byte]])
    inline def apply(inline o: CFuncPtr3[GLenum, GLsizei, Ptr[Byte], Unit]): PFNGLFOGCOORDPOINTERPROC = o
    extension (v: PFNGLFOGCOORDPOINTERPROC)
      inline def value: CFuncPtr3[GLenum, GLsizei, Ptr[Byte], Unit] = v
      inline def toPtr: Ptr[?] = CFuncPtr.toPtr(v)

  opaque type PFNGLFOGFUNCSGISPROC = CFuncPtr2[GLsizei, Ptr[GLfloat], Unit]
  object PFNGLFOGFUNCSGISPROC:
    given _tag: Tag[PFNGLFOGFUNCSGISPROC] = Tag.materializeCFuncPtr2[GLsizei, Ptr[GLfloat], Unit]
    inline def fromPtr(ptr: Ptr[Byte] | Ptr[?]): PFNGLFOGFUNCSGISPROC = CFuncPtr.fromPtr(ptr.asInstanceOf[Ptr[Byte]])
    inline def apply(inline o: CFuncPtr2[GLsizei, Ptr[GLfloat], Unit]): PFNGLFOGFUNCSGISPROC = o
    extension (v: PFNGLFOGFUNCSGISPROC)
      inline def value: CFuncPtr2[GLsizei, Ptr[GLfloat], Unit] = v
      inline def toPtr: Ptr[?] = CFuncPtr.toPtr(v)

  opaque type PFNGLFOGLAYERSSGIXPROC = CFuncPtr2[GLsizei, Ptr[GLfloat], Unit]
  object PFNGLFOGLAYERSSGIXPROC:
    given _tag: Tag[PFNGLFOGLAYERSSGIXPROC] = Tag.materializeCFuncPtr2[GLsizei, Ptr[GLfloat], Unit]
    inline def fromPtr(ptr: Ptr[Byte] | Ptr[?]): PFNGLFOGLAYERSSGIXPROC = CFuncPtr.fromPtr(ptr.asInstanceOf[Ptr[Byte]])
    inline def apply(inline o: CFuncPtr2[GLsizei, Ptr[GLfloat], Unit]): PFNGLFOGLAYERSSGIXPROC = o
    extension (v: PFNGLFOGLAYERSSGIXPROC)
      inline def value: CFuncPtr2[GLsizei, Ptr[GLfloat], Unit] = v
      inline def toPtr: Ptr[?] = CFuncPtr.toPtr(v)

  opaque type PFNGLFOGXPROC = CFuncPtr2[GLenum, GLfixed, Unit]
  object PFNGLFOGXPROC:
    given _tag: Tag[PFNGLFOGXPROC] = Tag.materializeCFuncPtr2[GLenum, GLfixed, Unit]
    inline def fromPtr(ptr: Ptr[Byte] | Ptr[?]): PFNGLFOGXPROC = CFuncPtr.fromPtr(ptr.asInstanceOf[Ptr[Byte]])
    inline def apply(inline o: CFuncPtr2[GLenum, GLfixed, Unit]): PFNGLFOGXPROC = o
    extension (v: PFNGLFOGXPROC)
      inline def value: CFuncPtr2[GLenum, GLfixed, Unit] = v
      inline def toPtr: Ptr[?] = CFuncPtr.toPtr(v)

  opaque type PFNGLFOGXVPROC = CFuncPtr2[GLenum, Ptr[GLfixed], Unit]
  object PFNGLFOGXVPROC:
    given _tag: Tag[PFNGLFOGXVPROC] = Tag.materializeCFuncPtr2[GLenum, Ptr[GLfixed], Unit]
    inline def fromPtr(ptr: Ptr[Byte] | Ptr[?]): PFNGLFOGXVPROC = CFuncPtr.fromPtr(ptr.asInstanceOf[Ptr[Byte]])
    inline def apply(inline o: CFuncPtr2[GLenum, Ptr[GLfixed], Unit]): PFNGLFOGXVPROC = o
    extension (v: PFNGLFOGXVPROC)
      inline def value: CFuncPtr2[GLenum, Ptr[GLfixed], Unit] = v
      inline def toPtr: Ptr[?] = CFuncPtr.toPtr(v)

  opaque type PFNGLFRAGMENTCOLORMATERIALEXTPROC = CFuncPtr2[GLenum, GLenum, Unit]
  object PFNGLFRAGMENTCOLORMATERIALEXTPROC:
    given _tag: Tag[PFNGLFRAGMENTCOLORMATERIALEXTPROC] = Tag.materializeCFuncPtr2[GLenum, GLenum, Unit]
    inline def fromPtr(ptr: Ptr[Byte] | Ptr[?]): PFNGLFRAGMENTCOLORMATERIALEXTPROC = CFuncPtr.fromPtr(ptr.asInstanceOf[Ptr[Byte]])
    inline def apply(inline o: CFuncPtr2[GLenum, GLenum, Unit]): PFNGLFRAGMENTCOLORMATERIALEXTPROC = o
    extension (v: PFNGLFRAGMENTCOLORMATERIALEXTPROC)
      inline def value: CFuncPtr2[GLenum, GLenum, Unit] = v
      inline def toPtr: Ptr[?] = CFuncPtr.toPtr(v)

  opaque type PFNGLFRAGMENTCOLORMATERIALSGIXPROC = CFuncPtr2[GLenum, GLenum, Unit]
  object PFNGLFRAGMENTCOLORMATERIALSGIXPROC:
    given _tag: Tag[PFNGLFRAGMENTCOLORMATERIALSGIXPROC] = Tag.materializeCFuncPtr2[GLenum, GLenum, Unit]
    inline def fromPtr(ptr: Ptr[Byte] | Ptr[?]): PFNGLFRAGMENTCOLORMATERIALSGIXPROC = CFuncPtr.fromPtr(ptr.asInstanceOf[Ptr[Byte]])
    inline def apply(inline o: CFuncPtr2[GLenum, GLenum, Unit]): PFNGLFRAGMENTCOLORMATERIALSGIXPROC = o
    extension (v: PFNGLFRAGMENTCOLORMATERIALSGIXPROC)
      inline def value: CFuncPtr2[GLenum, GLenum, Unit] = v
      inline def toPtr: Ptr[?] = CFuncPtr.toPtr(v)

  opaque type PFNGLFRAGMENTCOVERAGECOLORNVPROC = CFuncPtr1[GLuint, Unit]
  object PFNGLFRAGMENTCOVERAGECOLORNVPROC:
    given _tag: Tag[PFNGLFRAGMENTCOVERAGECOLORNVPROC] = Tag.materializeCFuncPtr1[GLuint, Unit]
    inline def fromPtr(ptr: Ptr[Byte] | Ptr[?]): PFNGLFRAGMENTCOVERAGECOLORNVPROC = CFuncPtr.fromPtr(ptr.asInstanceOf[Ptr[Byte]])
    inline def apply(inline o: CFuncPtr1[GLuint, Unit]): PFNGLFRAGMENTCOVERAGECOLORNVPROC = o
    extension (v: PFNGLFRAGMENTCOVERAGECOLORNVPROC)
      inline def value: CFuncPtr1[GLuint, Unit] = v
      inline def toPtr: Ptr[?] = CFuncPtr.toPtr(v)

  opaque type PFNGLFRAGMENTLIGHTFEXTPROC = CFuncPtr3[GLenum, GLenum, GLfloat, Unit]
  object PFNGLFRAGMENTLIGHTFEXTPROC:
    given _tag: Tag[PFNGLFRAGMENTLIGHTFEXTPROC] = Tag.materializeCFuncPtr3[GLenum, GLenum, GLfloat, Unit]
    inline def fromPtr(ptr: Ptr[Byte] | Ptr[?]): PFNGLFRAGMENTLIGHTFEXTPROC = CFuncPtr.fromPtr(ptr.asInstanceOf[Ptr[Byte]])
    inline def apply(inline o: CFuncPtr3[GLenum, GLenum, GLfloat, Unit]): PFNGLFRAGMENTLIGHTFEXTPROC = o
    extension (v: PFNGLFRAGMENTLIGHTFEXTPROC)
      inline def value: CFuncPtr3[GLenum, GLenum, GLfloat, Unit] = v
      inline def toPtr: Ptr[?] = CFuncPtr.toPtr(v)

  opaque type PFNGLFRAGMENTLIGHTFSGIXPROC = CFuncPtr3[GLenum, GLenum, GLfloat, Unit]
  object PFNGLFRAGMENTLIGHTFSGIXPROC:
    given _tag: Tag[PFNGLFRAGMENTLIGHTFSGIXPROC] = Tag.materializeCFuncPtr3[GLenum, GLenum, GLfloat, Unit]
    inline def fromPtr(ptr: Ptr[Byte] | Ptr[?]): PFNGLFRAGMENTLIGHTFSGIXPROC = CFuncPtr.fromPtr(ptr.asInstanceOf[Ptr[Byte]])
    inline def apply(inline o: CFuncPtr3[GLenum, GLenum, GLfloat, Unit]): PFNGLFRAGMENTLIGHTFSGIXPROC = o
    extension (v: PFNGLFRAGMENTLIGHTFSGIXPROC)
      inline def value: CFuncPtr3[GLenum, GLenum, GLfloat, Unit] = v
      inline def toPtr: Ptr[?] = CFuncPtr.toPtr(v)

  opaque type PFNGLFRAGMENTLIGHTFVEXTPROC = CFuncPtr3[GLenum, GLenum, Ptr[GLfloat], Unit]
  object PFNGLFRAGMENTLIGHTFVEXTPROC:
    given _tag: Tag[PFNGLFRAGMENTLIGHTFVEXTPROC] = Tag.materializeCFuncPtr3[GLenum, GLenum, Ptr[GLfloat], Unit]
    inline def fromPtr(ptr: Ptr[Byte] | Ptr[?]): PFNGLFRAGMENTLIGHTFVEXTPROC = CFuncPtr.fromPtr(ptr.asInstanceOf[Ptr[Byte]])
    inline def apply(inline o: CFuncPtr3[GLenum, GLenum, Ptr[GLfloat], Unit]): PFNGLFRAGMENTLIGHTFVEXTPROC = o
    extension (v: PFNGLFRAGMENTLIGHTFVEXTPROC)
      inline def value: CFuncPtr3[GLenum, GLenum, Ptr[GLfloat], Unit] = v
      inline def toPtr: Ptr[?] = CFuncPtr.toPtr(v)

  opaque type PFNGLFRAGMENTLIGHTFVSGIXPROC = CFuncPtr3[GLenum, GLenum, Ptr[GLfloat], Unit]
  object PFNGLFRAGMENTLIGHTFVSGIXPROC:
    given _tag: Tag[PFNGLFRAGMENTLIGHTFVSGIXPROC] = Tag.materializeCFuncPtr3[GLenum, GLenum, Ptr[GLfloat], Unit]
    inline def fromPtr(ptr: Ptr[Byte] | Ptr[?]): PFNGLFRAGMENTLIGHTFVSGIXPROC = CFuncPtr.fromPtr(ptr.asInstanceOf[Ptr[Byte]])
    inline def apply(inline o: CFuncPtr3[GLenum, GLenum, Ptr[GLfloat], Unit]): PFNGLFRAGMENTLIGHTFVSGIXPROC = o
    extension (v: PFNGLFRAGMENTLIGHTFVSGIXPROC)
      inline def value: CFuncPtr3[GLenum, GLenum, Ptr[GLfloat], Unit] = v
      inline def toPtr: Ptr[?] = CFuncPtr.toPtr(v)

  opaque type PFNGLFRAGMENTLIGHTIEXTPROC = CFuncPtr3[GLenum, GLenum, GLint, Unit]
  object PFNGLFRAGMENTLIGHTIEXTPROC:
    given _tag: Tag[PFNGLFRAGMENTLIGHTIEXTPROC] = Tag.materializeCFuncPtr3[GLenum, GLenum, GLint, Unit]
    inline def fromPtr(ptr: Ptr[Byte] | Ptr[?]): PFNGLFRAGMENTLIGHTIEXTPROC = CFuncPtr.fromPtr(ptr.asInstanceOf[Ptr[Byte]])
    inline def apply(inline o: CFuncPtr3[GLenum, GLenum, GLint, Unit]): PFNGLFRAGMENTLIGHTIEXTPROC = o
    extension (v: PFNGLFRAGMENTLIGHTIEXTPROC)
      inline def value: CFuncPtr3[GLenum, GLenum, GLint, Unit] = v
      inline def toPtr: Ptr[?] = CFuncPtr.toPtr(v)

  opaque type PFNGLFRAGMENTLIGHTISGIXPROC = CFuncPtr3[GLenum, GLenum, GLint, Unit]
  object PFNGLFRAGMENTLIGHTISGIXPROC:
    given _tag: Tag[PFNGLFRAGMENTLIGHTISGIXPROC] = Tag.materializeCFuncPtr3[GLenum, GLenum, GLint, Unit]
    inline def fromPtr(ptr: Ptr[Byte] | Ptr[?]): PFNGLFRAGMENTLIGHTISGIXPROC = CFuncPtr.fromPtr(ptr.asInstanceOf[Ptr[Byte]])
    inline def apply(inline o: CFuncPtr3[GLenum, GLenum, GLint, Unit]): PFNGLFRAGMENTLIGHTISGIXPROC = o
    extension (v: PFNGLFRAGMENTLIGHTISGIXPROC)
      inline def value: CFuncPtr3[GLenum, GLenum, GLint, Unit] = v
      inline def toPtr: Ptr[?] = CFuncPtr.toPtr(v)

  opaque type PFNGLFRAGMENTLIGHTIVEXTPROC = CFuncPtr3[GLenum, GLenum, Ptr[GLint], Unit]
  object PFNGLFRAGMENTLIGHTIVEXTPROC:
    given _tag: Tag[PFNGLFRAGMENTLIGHTIVEXTPROC] = Tag.materializeCFuncPtr3[GLenum, GLenum, Ptr[GLint], Unit]
    inline def fromPtr(ptr: Ptr[Byte] | Ptr[?]): PFNGLFRAGMENTLIGHTIVEXTPROC = CFuncPtr.fromPtr(ptr.asInstanceOf[Ptr[Byte]])
    inline def apply(inline o: CFuncPtr3[GLenum, GLenum, Ptr[GLint], Unit]): PFNGLFRAGMENTLIGHTIVEXTPROC = o
    extension (v: PFNGLFRAGMENTLIGHTIVEXTPROC)
      inline def value: CFuncPtr3[GLenum, GLenum, Ptr[GLint], Unit] = v
      inline def toPtr: Ptr[?] = CFuncPtr.toPtr(v)

  opaque type PFNGLFRAGMENTLIGHTIVSGIXPROC = CFuncPtr3[GLenum, GLenum, Ptr[GLint], Unit]
  object PFNGLFRAGMENTLIGHTIVSGIXPROC:
    given _tag: Tag[PFNGLFRAGMENTLIGHTIVSGIXPROC] = Tag.materializeCFuncPtr3[GLenum, GLenum, Ptr[GLint], Unit]
    inline def fromPtr(ptr: Ptr[Byte] | Ptr[?]): PFNGLFRAGMENTLIGHTIVSGIXPROC = CFuncPtr.fromPtr(ptr.asInstanceOf[Ptr[Byte]])
    inline def apply(inline o: CFuncPtr3[GLenum, GLenum, Ptr[GLint], Unit]): PFNGLFRAGMENTLIGHTIVSGIXPROC = o
    extension (v: PFNGLFRAGMENTLIGHTIVSGIXPROC)
      inline def value: CFuncPtr3[GLenum, GLenum, Ptr[GLint], Unit] = v
      inline def toPtr: Ptr[?] = CFuncPtr.toPtr(v)

  opaque type PFNGLFRAGMENTLIGHTMODELFEXTPROC = CFuncPtr2[GLenum, GLfloat, Unit]
  object PFNGLFRAGMENTLIGHTMODELFEXTPROC:
    given _tag: Tag[PFNGLFRAGMENTLIGHTMODELFEXTPROC] = Tag.materializeCFuncPtr2[GLenum, GLfloat, Unit]
    inline def fromPtr(ptr: Ptr[Byte] | Ptr[?]): PFNGLFRAGMENTLIGHTMODELFEXTPROC = CFuncPtr.fromPtr(ptr.asInstanceOf[Ptr[Byte]])
    inline def apply(inline o: CFuncPtr2[GLenum, GLfloat, Unit]): PFNGLFRAGMENTLIGHTMODELFEXTPROC = o
    extension (v: PFNGLFRAGMENTLIGHTMODELFEXTPROC)
      inline def value: CFuncPtr2[GLenum, GLfloat, Unit] = v
      inline def toPtr: Ptr[?] = CFuncPtr.toPtr(v)

  opaque type PFNGLFRAGMENTLIGHTMODELFSGIXPROC = CFuncPtr2[GLenum, GLfloat, Unit]
  object PFNGLFRAGMENTLIGHTMODELFSGIXPROC:
    given _tag: Tag[PFNGLFRAGMENTLIGHTMODELFSGIXPROC] = Tag.materializeCFuncPtr2[GLenum, GLfloat, Unit]
    inline def fromPtr(ptr: Ptr[Byte] | Ptr[?]): PFNGLFRAGMENTLIGHTMODELFSGIXPROC = CFuncPtr.fromPtr(ptr.asInstanceOf[Ptr[Byte]])
    inline def apply(inline o: CFuncPtr2[GLenum, GLfloat, Unit]): PFNGLFRAGMENTLIGHTMODELFSGIXPROC = o
    extension (v: PFNGLFRAGMENTLIGHTMODELFSGIXPROC)
      inline def value: CFuncPtr2[GLenum, GLfloat, Unit] = v
      inline def toPtr: Ptr[?] = CFuncPtr.toPtr(v)

  opaque type PFNGLFRAGMENTLIGHTMODELFVEXTPROC = CFuncPtr2[GLenum, Ptr[GLfloat], Unit]
  object PFNGLFRAGMENTLIGHTMODELFVEXTPROC:
    given _tag: Tag[PFNGLFRAGMENTLIGHTMODELFVEXTPROC] = Tag.materializeCFuncPtr2[GLenum, Ptr[GLfloat], Unit]
    inline def fromPtr(ptr: Ptr[Byte] | Ptr[?]): PFNGLFRAGMENTLIGHTMODELFVEXTPROC = CFuncPtr.fromPtr(ptr.asInstanceOf[Ptr[Byte]])
    inline def apply(inline o: CFuncPtr2[GLenum, Ptr[GLfloat], Unit]): PFNGLFRAGMENTLIGHTMODELFVEXTPROC = o
    extension (v: PFNGLFRAGMENTLIGHTMODELFVEXTPROC)
      inline def value: CFuncPtr2[GLenum, Ptr[GLfloat], Unit] = v
      inline def toPtr: Ptr[?] = CFuncPtr.toPtr(v)

  opaque type PFNGLFRAGMENTLIGHTMODELFVSGIXPROC = CFuncPtr2[GLenum, Ptr[GLfloat], Unit]
  object PFNGLFRAGMENTLIGHTMODELFVSGIXPROC:
    given _tag: Tag[PFNGLFRAGMENTLIGHTMODELFVSGIXPROC] = Tag.materializeCFuncPtr2[GLenum, Ptr[GLfloat], Unit]
    inline def fromPtr(ptr: Ptr[Byte] | Ptr[?]): PFNGLFRAGMENTLIGHTMODELFVSGIXPROC = CFuncPtr.fromPtr(ptr.asInstanceOf[Ptr[Byte]])
    inline def apply(inline o: CFuncPtr2[GLenum, Ptr[GLfloat], Unit]): PFNGLFRAGMENTLIGHTMODELFVSGIXPROC = o
    extension (v: PFNGLFRAGMENTLIGHTMODELFVSGIXPROC)
      inline def value: CFuncPtr2[GLenum, Ptr[GLfloat], Unit] = v
      inline def toPtr: Ptr[?] = CFuncPtr.toPtr(v)

  opaque type PFNGLFRAGMENTLIGHTMODELIEXTPROC = CFuncPtr2[GLenum, GLint, Unit]
  object PFNGLFRAGMENTLIGHTMODELIEXTPROC:
    given _tag: Tag[PFNGLFRAGMENTLIGHTMODELIEXTPROC] = Tag.materializeCFuncPtr2[GLenum, GLint, Unit]
    inline def fromPtr(ptr: Ptr[Byte] | Ptr[?]): PFNGLFRAGMENTLIGHTMODELIEXTPROC = CFuncPtr.fromPtr(ptr.asInstanceOf[Ptr[Byte]])
    inline def apply(inline o: CFuncPtr2[GLenum, GLint, Unit]): PFNGLFRAGMENTLIGHTMODELIEXTPROC = o
    extension (v: PFNGLFRAGMENTLIGHTMODELIEXTPROC)
      inline def value: CFuncPtr2[GLenum, GLint, Unit] = v
      inline def toPtr: Ptr[?] = CFuncPtr.toPtr(v)

  opaque type PFNGLFRAGMENTLIGHTMODELISGIXPROC = CFuncPtr2[GLenum, GLint, Unit]
  object PFNGLFRAGMENTLIGHTMODELISGIXPROC:
    given _tag: Tag[PFNGLFRAGMENTLIGHTMODELISGIXPROC] = Tag.materializeCFuncPtr2[GLenum, GLint, Unit]
    inline def fromPtr(ptr: Ptr[Byte] | Ptr[?]): PFNGLFRAGMENTLIGHTMODELISGIXPROC = CFuncPtr.fromPtr(ptr.asInstanceOf[Ptr[Byte]])
    inline def apply(inline o: CFuncPtr2[GLenum, GLint, Unit]): PFNGLFRAGMENTLIGHTMODELISGIXPROC = o
    extension (v: PFNGLFRAGMENTLIGHTMODELISGIXPROC)
      inline def value: CFuncPtr2[GLenum, GLint, Unit] = v
      inline def toPtr: Ptr[?] = CFuncPtr.toPtr(v)

  opaque type PFNGLFRAGMENTLIGHTMODELIVEXTPROC = CFuncPtr2[GLenum, Ptr[GLint], Unit]
  object PFNGLFRAGMENTLIGHTMODELIVEXTPROC:
    given _tag: Tag[PFNGLFRAGMENTLIGHTMODELIVEXTPROC] = Tag.materializeCFuncPtr2[GLenum, Ptr[GLint], Unit]
    inline def fromPtr(ptr: Ptr[Byte] | Ptr[?]): PFNGLFRAGMENTLIGHTMODELIVEXTPROC = CFuncPtr.fromPtr(ptr.asInstanceOf[Ptr[Byte]])
    inline def apply(inline o: CFuncPtr2[GLenum, Ptr[GLint], Unit]): PFNGLFRAGMENTLIGHTMODELIVEXTPROC = o
    extension (v: PFNGLFRAGMENTLIGHTMODELIVEXTPROC)
      inline def value: CFuncPtr2[GLenum, Ptr[GLint], Unit] = v
      inline def toPtr: Ptr[?] = CFuncPtr.toPtr(v)

  opaque type PFNGLFRAGMENTLIGHTMODELIVSGIXPROC = CFuncPtr2[GLenum, Ptr[GLint], Unit]
  object PFNGLFRAGMENTLIGHTMODELIVSGIXPROC:
    given _tag: Tag[PFNGLFRAGMENTLIGHTMODELIVSGIXPROC] = Tag.materializeCFuncPtr2[GLenum, Ptr[GLint], Unit]
    inline def fromPtr(ptr: Ptr[Byte] | Ptr[?]): PFNGLFRAGMENTLIGHTMODELIVSGIXPROC = CFuncPtr.fromPtr(ptr.asInstanceOf[Ptr[Byte]])
    inline def apply(inline o: CFuncPtr2[GLenum, Ptr[GLint], Unit]): PFNGLFRAGMENTLIGHTMODELIVSGIXPROC = o
    extension (v: PFNGLFRAGMENTLIGHTMODELIVSGIXPROC)
      inline def value: CFuncPtr2[GLenum, Ptr[GLint], Unit] = v
      inline def toPtr: Ptr[?] = CFuncPtr.toPtr(v)

  opaque type PFNGLFRAGMENTMATERIALFEXTPROC = CFuncPtr3[GLenum, GLenum, GLfloat, Unit]
  object PFNGLFRAGMENTMATERIALFEXTPROC:
    given _tag: Tag[PFNGLFRAGMENTMATERIALFEXTPROC] = Tag.materializeCFuncPtr3[GLenum, GLenum, GLfloat, Unit]
    inline def fromPtr(ptr: Ptr[Byte] | Ptr[?]): PFNGLFRAGMENTMATERIALFEXTPROC = CFuncPtr.fromPtr(ptr.asInstanceOf[Ptr[Byte]])
    inline def apply(inline o: CFuncPtr3[GLenum, GLenum, GLfloat, Unit]): PFNGLFRAGMENTMATERIALFEXTPROC = o
    extension (v: PFNGLFRAGMENTMATERIALFEXTPROC)
      inline def value: CFuncPtr3[GLenum, GLenum, GLfloat, Unit] = v
      inline def toPtr: Ptr[?] = CFuncPtr.toPtr(v)

  opaque type PFNGLFRAGMENTMATERIALFSGIXPROC = CFuncPtr3[GLenum, GLenum, GLfloat, Unit]
  object PFNGLFRAGMENTMATERIALFSGIXPROC:
    given _tag: Tag[PFNGLFRAGMENTMATERIALFSGIXPROC] = Tag.materializeCFuncPtr3[GLenum, GLenum, GLfloat, Unit]
    inline def fromPtr(ptr: Ptr[Byte] | Ptr[?]): PFNGLFRAGMENTMATERIALFSGIXPROC = CFuncPtr.fromPtr(ptr.asInstanceOf[Ptr[Byte]])
    inline def apply(inline o: CFuncPtr3[GLenum, GLenum, GLfloat, Unit]): PFNGLFRAGMENTMATERIALFSGIXPROC = o
    extension (v: PFNGLFRAGMENTMATERIALFSGIXPROC)
      inline def value: CFuncPtr3[GLenum, GLenum, GLfloat, Unit] = v
      inline def toPtr: Ptr[?] = CFuncPtr.toPtr(v)

  opaque type PFNGLFRAGMENTMATERIALFVEXTPROC = CFuncPtr3[GLenum, GLenum, Ptr[GLfloat], Unit]
  object PFNGLFRAGMENTMATERIALFVEXTPROC:
    given _tag: Tag[PFNGLFRAGMENTMATERIALFVEXTPROC] = Tag.materializeCFuncPtr3[GLenum, GLenum, Ptr[GLfloat], Unit]
    inline def fromPtr(ptr: Ptr[Byte] | Ptr[?]): PFNGLFRAGMENTMATERIALFVEXTPROC = CFuncPtr.fromPtr(ptr.asInstanceOf[Ptr[Byte]])
    inline def apply(inline o: CFuncPtr3[GLenum, GLenum, Ptr[GLfloat], Unit]): PFNGLFRAGMENTMATERIALFVEXTPROC = o
    extension (v: PFNGLFRAGMENTMATERIALFVEXTPROC)
      inline def value: CFuncPtr3[GLenum, GLenum, Ptr[GLfloat], Unit] = v
      inline def toPtr: Ptr[?] = CFuncPtr.toPtr(v)

  opaque type PFNGLFRAGMENTMATERIALFVSGIXPROC = CFuncPtr3[GLenum, GLenum, Ptr[GLfloat], Unit]
  object PFNGLFRAGMENTMATERIALFVSGIXPROC:
    given _tag: Tag[PFNGLFRAGMENTMATERIALFVSGIXPROC] = Tag.materializeCFuncPtr3[GLenum, GLenum, Ptr[GLfloat], Unit]
    inline def fromPtr(ptr: Ptr[Byte] | Ptr[?]): PFNGLFRAGMENTMATERIALFVSGIXPROC = CFuncPtr.fromPtr(ptr.asInstanceOf[Ptr[Byte]])
    inline def apply(inline o: CFuncPtr3[GLenum, GLenum, Ptr[GLfloat], Unit]): PFNGLFRAGMENTMATERIALFVSGIXPROC = o
    extension (v: PFNGLFRAGMENTMATERIALFVSGIXPROC)
      inline def value: CFuncPtr3[GLenum, GLenum, Ptr[GLfloat], Unit] = v
      inline def toPtr: Ptr[?] = CFuncPtr.toPtr(v)

  opaque type PFNGLFRAGMENTMATERIALIEXTPROC = CFuncPtr3[GLenum, GLenum, GLint, Unit]
  object PFNGLFRAGMENTMATERIALIEXTPROC:
    given _tag: Tag[PFNGLFRAGMENTMATERIALIEXTPROC] = Tag.materializeCFuncPtr3[GLenum, GLenum, GLint, Unit]
    inline def fromPtr(ptr: Ptr[Byte] | Ptr[?]): PFNGLFRAGMENTMATERIALIEXTPROC = CFuncPtr.fromPtr(ptr.asInstanceOf[Ptr[Byte]])
    inline def apply(inline o: CFuncPtr3[GLenum, GLenum, GLint, Unit]): PFNGLFRAGMENTMATERIALIEXTPROC = o
    extension (v: PFNGLFRAGMENTMATERIALIEXTPROC)
      inline def value: CFuncPtr3[GLenum, GLenum, GLint, Unit] = v
      inline def toPtr: Ptr[?] = CFuncPtr.toPtr(v)

  opaque type PFNGLFRAGMENTMATERIALISGIXPROC = CFuncPtr3[GLenum, GLenum, GLint, Unit]
  object PFNGLFRAGMENTMATERIALISGIXPROC:
    given _tag: Tag[PFNGLFRAGMENTMATERIALISGIXPROC] = Tag.materializeCFuncPtr3[GLenum, GLenum, GLint, Unit]
    inline def fromPtr(ptr: Ptr[Byte] | Ptr[?]): PFNGLFRAGMENTMATERIALISGIXPROC = CFuncPtr.fromPtr(ptr.asInstanceOf[Ptr[Byte]])
    inline def apply(inline o: CFuncPtr3[GLenum, GLenum, GLint, Unit]): PFNGLFRAGMENTMATERIALISGIXPROC = o
    extension (v: PFNGLFRAGMENTMATERIALISGIXPROC)
      inline def value: CFuncPtr3[GLenum, GLenum, GLint, Unit] = v
      inline def toPtr: Ptr[?] = CFuncPtr.toPtr(v)

  opaque type PFNGLFRAGMENTMATERIALIVEXTPROC = CFuncPtr3[GLenum, GLenum, Ptr[GLint], Unit]
  object PFNGLFRAGMENTMATERIALIVEXTPROC:
    given _tag: Tag[PFNGLFRAGMENTMATERIALIVEXTPROC] = Tag.materializeCFuncPtr3[GLenum, GLenum, Ptr[GLint], Unit]
    inline def fromPtr(ptr: Ptr[Byte] | Ptr[?]): PFNGLFRAGMENTMATERIALIVEXTPROC = CFuncPtr.fromPtr(ptr.asInstanceOf[Ptr[Byte]])
    inline def apply(inline o: CFuncPtr3[GLenum, GLenum, Ptr[GLint], Unit]): PFNGLFRAGMENTMATERIALIVEXTPROC = o
    extension (v: PFNGLFRAGMENTMATERIALIVEXTPROC)
      inline def value: CFuncPtr3[GLenum, GLenum, Ptr[GLint], Unit] = v
      inline def toPtr: Ptr[?] = CFuncPtr.toPtr(v)

  opaque type PFNGLFRAGMENTMATERIALIVSGIXPROC = CFuncPtr3[GLenum, GLenum, Ptr[GLint], Unit]
  object PFNGLFRAGMENTMATERIALIVSGIXPROC:
    given _tag: Tag[PFNGLFRAGMENTMATERIALIVSGIXPROC] = Tag.materializeCFuncPtr3[GLenum, GLenum, Ptr[GLint], Unit]
    inline def fromPtr(ptr: Ptr[Byte] | Ptr[?]): PFNGLFRAGMENTMATERIALIVSGIXPROC = CFuncPtr.fromPtr(ptr.asInstanceOf[Ptr[Byte]])
    inline def apply(inline o: CFuncPtr3[GLenum, GLenum, Ptr[GLint], Unit]): PFNGLFRAGMENTMATERIALIVSGIXPROC = o
    extension (v: PFNGLFRAGMENTMATERIALIVSGIXPROC)
      inline def value: CFuncPtr3[GLenum, GLenum, Ptr[GLint], Unit] = v
      inline def toPtr: Ptr[?] = CFuncPtr.toPtr(v)

  opaque type PFNGLFRAMEBUFFERDRAWBUFFEREXTPROC = CFuncPtr2[GLuint, GLenum, Unit]
  object PFNGLFRAMEBUFFERDRAWBUFFEREXTPROC:
    given _tag: Tag[PFNGLFRAMEBUFFERDRAWBUFFEREXTPROC] = Tag.materializeCFuncPtr2[GLuint, GLenum, Unit]
    inline def fromPtr(ptr: Ptr[Byte] | Ptr[?]): PFNGLFRAMEBUFFERDRAWBUFFEREXTPROC = CFuncPtr.fromPtr(ptr.asInstanceOf[Ptr[Byte]])
    inline def apply(inline o: CFuncPtr2[GLuint, GLenum, Unit]): PFNGLFRAMEBUFFERDRAWBUFFEREXTPROC = o
    extension (v: PFNGLFRAMEBUFFERDRAWBUFFEREXTPROC)
      inline def value: CFuncPtr2[GLuint, GLenum, Unit] = v
      inline def toPtr: Ptr[?] = CFuncPtr.toPtr(v)

  opaque type PFNGLFRAMEBUFFERDRAWBUFFERSEXTPROC = CFuncPtr3[GLuint, GLsizei, Ptr[GLenum], Unit]
  object PFNGLFRAMEBUFFERDRAWBUFFERSEXTPROC:
    given _tag: Tag[PFNGLFRAMEBUFFERDRAWBUFFERSEXTPROC] = Tag.materializeCFuncPtr3[GLuint, GLsizei, Ptr[GLenum], Unit]
    inline def fromPtr(ptr: Ptr[Byte] | Ptr[?]): PFNGLFRAMEBUFFERDRAWBUFFERSEXTPROC = CFuncPtr.fromPtr(ptr.asInstanceOf[Ptr[Byte]])
    inline def apply(inline o: CFuncPtr3[GLuint, GLsizei, Ptr[GLenum], Unit]): PFNGLFRAMEBUFFERDRAWBUFFERSEXTPROC = o
    extension (v: PFNGLFRAMEBUFFERDRAWBUFFERSEXTPROC)
      inline def value: CFuncPtr3[GLuint, GLsizei, Ptr[GLenum], Unit] = v
      inline def toPtr: Ptr[?] = CFuncPtr.toPtr(v)

  opaque type PFNGLFRAMEBUFFERFETCHBARRIEREXTPROC = CFuncPtr0[Unit]
  object PFNGLFRAMEBUFFERFETCHBARRIEREXTPROC:
    given _tag: Tag[PFNGLFRAMEBUFFERFETCHBARRIEREXTPROC] = Tag.materializeCFuncPtr0[Unit]
    inline def fromPtr(ptr: Ptr[Byte] | Ptr[?]): PFNGLFRAMEBUFFERFETCHBARRIEREXTPROC = CFuncPtr.fromPtr(ptr.asInstanceOf[Ptr[Byte]])
    inline def apply(inline o: CFuncPtr0[Unit]): PFNGLFRAMEBUFFERFETCHBARRIEREXTPROC = o
    extension (v: PFNGLFRAMEBUFFERFETCHBARRIEREXTPROC)
      inline def value: CFuncPtr0[Unit] = v
      inline def toPtr: Ptr[?] = CFuncPtr.toPtr(v)

  opaque type PFNGLFRAMEBUFFERFETCHBARRIERQCOMPROC = CFuncPtr0[Unit]
  object PFNGLFRAMEBUFFERFETCHBARRIERQCOMPROC:
    given _tag: Tag[PFNGLFRAMEBUFFERFETCHBARRIERQCOMPROC] = Tag.materializeCFuncPtr0[Unit]
    inline def fromPtr(ptr: Ptr[Byte] | Ptr[?]): PFNGLFRAMEBUFFERFETCHBARRIERQCOMPROC = CFuncPtr.fromPtr(ptr.asInstanceOf[Ptr[Byte]])
    inline def apply(inline o: CFuncPtr0[Unit]): PFNGLFRAMEBUFFERFETCHBARRIERQCOMPROC = o
    extension (v: PFNGLFRAMEBUFFERFETCHBARRIERQCOMPROC)
      inline def value: CFuncPtr0[Unit] = v
      inline def toPtr: Ptr[?] = CFuncPtr.toPtr(v)

  opaque type PFNGLFRAMEBUFFERFOVEATIONCONFIGQCOMPROC = CFuncPtr5[GLuint, GLuint, GLuint, GLuint, Ptr[GLuint], Unit]
  object PFNGLFRAMEBUFFERFOVEATIONCONFIGQCOMPROC:
    given _tag: Tag[PFNGLFRAMEBUFFERFOVEATIONCONFIGQCOMPROC] = Tag.materializeCFuncPtr5[GLuint, GLuint, GLuint, GLuint, Ptr[GLuint], Unit]
    inline def fromPtr(ptr: Ptr[Byte] | Ptr[?]): PFNGLFRAMEBUFFERFOVEATIONCONFIGQCOMPROC = CFuncPtr.fromPtr(ptr.asInstanceOf[Ptr[Byte]])
    inline def apply(inline o: CFuncPtr5[GLuint, GLuint, GLuint, GLuint, Ptr[GLuint], Unit]): PFNGLFRAMEBUFFERFOVEATIONCONFIGQCOMPROC = o
    extension (v: PFNGLFRAMEBUFFERFOVEATIONCONFIGQCOMPROC)
      inline def value: CFuncPtr5[GLuint, GLuint, GLuint, GLuint, Ptr[GLuint], Unit] = v
      inline def toPtr: Ptr[?] = CFuncPtr.toPtr(v)

  opaque type PFNGLFRAMEBUFFERFOVEATIONPARAMETERSQCOMPROC = CFuncPtr8[GLuint, GLuint, GLuint, GLfloat, GLfloat, GLfloat, GLfloat, GLfloat, Unit]
  object PFNGLFRAMEBUFFERFOVEATIONPARAMETERSQCOMPROC:
    given _tag: Tag[PFNGLFRAMEBUFFERFOVEATIONPARAMETERSQCOMPROC] = Tag.materializeCFuncPtr8[GLuint, GLuint, GLuint, GLfloat, GLfloat, GLfloat, GLfloat, GLfloat, Unit]
    inline def fromPtr(ptr: Ptr[Byte] | Ptr[?]): PFNGLFRAMEBUFFERFOVEATIONPARAMETERSQCOMPROC = CFuncPtr.fromPtr(ptr.asInstanceOf[Ptr[Byte]])
    inline def apply(inline o: CFuncPtr8[GLuint, GLuint, GLuint, GLfloat, GLfloat, GLfloat, GLfloat, GLfloat, Unit]): PFNGLFRAMEBUFFERFOVEATIONPARAMETERSQCOMPROC = o
    extension (v: PFNGLFRAMEBUFFERFOVEATIONPARAMETERSQCOMPROC)
      inline def value: CFuncPtr8[GLuint, GLuint, GLuint, GLfloat, GLfloat, GLfloat, GLfloat, GLfloat, Unit] = v
      inline def toPtr: Ptr[?] = CFuncPtr.toPtr(v)

  opaque type PFNGLFRAMEBUFFERPARAMETERIMESAPROC = CFuncPtr3[GLenum, GLenum, GLint, Unit]
  object PFNGLFRAMEBUFFERPARAMETERIMESAPROC:
    given _tag: Tag[PFNGLFRAMEBUFFERPARAMETERIMESAPROC] = Tag.materializeCFuncPtr3[GLenum, GLenum, GLint, Unit]
    inline def fromPtr(ptr: Ptr[Byte] | Ptr[?]): PFNGLFRAMEBUFFERPARAMETERIMESAPROC = CFuncPtr.fromPtr(ptr.asInstanceOf[Ptr[Byte]])
    inline def apply(inline o: CFuncPtr3[GLenum, GLenum, GLint, Unit]): PFNGLFRAMEBUFFERPARAMETERIMESAPROC = o
    extension (v: PFNGLFRAMEBUFFERPARAMETERIMESAPROC)
      inline def value: CFuncPtr3[GLenum, GLenum, GLint, Unit] = v
      inline def toPtr: Ptr[?] = CFuncPtr.toPtr(v)

  opaque type PFNGLFRAMEBUFFERPARAMETERIPROC = CFuncPtr3[GLenum, GLenum, GLint, Unit]
  object PFNGLFRAMEBUFFERPARAMETERIPROC:
    given _tag: Tag[PFNGLFRAMEBUFFERPARAMETERIPROC] = Tag.materializeCFuncPtr3[GLenum, GLenum, GLint, Unit]
    inline def fromPtr(ptr: Ptr[Byte] | Ptr[?]): PFNGLFRAMEBUFFERPARAMETERIPROC = CFuncPtr.fromPtr(ptr.asInstanceOf[Ptr[Byte]])
    inline def apply(inline o: CFuncPtr3[GLenum, GLenum, GLint, Unit]): PFNGLFRAMEBUFFERPARAMETERIPROC = o
    extension (v: PFNGLFRAMEBUFFERPARAMETERIPROC)
      inline def value: CFuncPtr3[GLenum, GLenum, GLint, Unit] = v
      inline def toPtr: Ptr[?] = CFuncPtr.toPtr(v)

  opaque type PFNGLFRAMEBUFFERPIXELLOCALSTORAGESIZEEXTPROC = CFuncPtr2[GLuint, GLsizei, Unit]
  object PFNGLFRAMEBUFFERPIXELLOCALSTORAGESIZEEXTPROC:
    given _tag: Tag[PFNGLFRAMEBUFFERPIXELLOCALSTORAGESIZEEXTPROC] = Tag.materializeCFuncPtr2[GLuint, GLsizei, Unit]
    inline def fromPtr(ptr: Ptr[Byte] | Ptr[?]): PFNGLFRAMEBUFFERPIXELLOCALSTORAGESIZEEXTPROC = CFuncPtr.fromPtr(ptr.asInstanceOf[Ptr[Byte]])
    inline def apply(inline o: CFuncPtr2[GLuint, GLsizei, Unit]): PFNGLFRAMEBUFFERPIXELLOCALSTORAGESIZEEXTPROC = o
    extension (v: PFNGLFRAMEBUFFERPIXELLOCALSTORAGESIZEEXTPROC)
      inline def value: CFuncPtr2[GLuint, GLsizei, Unit] = v
      inline def toPtr: Ptr[?] = CFuncPtr.toPtr(v)

  opaque type PFNGLFRAMEBUFFERREADBUFFEREXTPROC = CFuncPtr2[GLuint, GLenum, Unit]
  object PFNGLFRAMEBUFFERREADBUFFEREXTPROC:
    given _tag: Tag[PFNGLFRAMEBUFFERREADBUFFEREXTPROC] = Tag.materializeCFuncPtr2[GLuint, GLenum, Unit]
    inline def fromPtr(ptr: Ptr[Byte] | Ptr[?]): PFNGLFRAMEBUFFERREADBUFFEREXTPROC = CFuncPtr.fromPtr(ptr.asInstanceOf[Ptr[Byte]])
    inline def apply(inline o: CFuncPtr2[GLuint, GLenum, Unit]): PFNGLFRAMEBUFFERREADBUFFEREXTPROC = o
    extension (v: PFNGLFRAMEBUFFERREADBUFFEREXTPROC)
      inline def value: CFuncPtr2[GLuint, GLenum, Unit] = v
      inline def toPtr: Ptr[?] = CFuncPtr.toPtr(v)

  opaque type PFNGLFRAMEBUFFERRENDERBUFFEREXTPROC = CFuncPtr4[GLenum, GLenum, GLenum, GLuint, Unit]
  object PFNGLFRAMEBUFFERRENDERBUFFEREXTPROC:
    given _tag: Tag[PFNGLFRAMEBUFFERRENDERBUFFEREXTPROC] = Tag.materializeCFuncPtr4[GLenum, GLenum, GLenum, GLuint, Unit]
    inline def fromPtr(ptr: Ptr[Byte] | Ptr[?]): PFNGLFRAMEBUFFERRENDERBUFFEREXTPROC = CFuncPtr.fromPtr(ptr.asInstanceOf[Ptr[Byte]])
    inline def apply(inline o: CFuncPtr4[GLenum, GLenum, GLenum, GLuint, Unit]): PFNGLFRAMEBUFFERRENDERBUFFEREXTPROC = o
    extension (v: PFNGLFRAMEBUFFERRENDERBUFFEREXTPROC)
      inline def value: CFuncPtr4[GLenum, GLenum, GLenum, GLuint, Unit] = v
      inline def toPtr: Ptr[?] = CFuncPtr.toPtr(v)

  opaque type PFNGLFRAMEBUFFERRENDERBUFFEROESPROC = CFuncPtr4[GLenum, GLenum, GLenum, GLuint, Unit]
  object PFNGLFRAMEBUFFERRENDERBUFFEROESPROC:
    given _tag: Tag[PFNGLFRAMEBUFFERRENDERBUFFEROESPROC] = Tag.materializeCFuncPtr4[GLenum, GLenum, GLenum, GLuint, Unit]
    inline def fromPtr(ptr: Ptr[Byte] | Ptr[?]): PFNGLFRAMEBUFFERRENDERBUFFEROESPROC = CFuncPtr.fromPtr(ptr.asInstanceOf[Ptr[Byte]])
    inline def apply(inline o: CFuncPtr4[GLenum, GLenum, GLenum, GLuint, Unit]): PFNGLFRAMEBUFFERRENDERBUFFEROESPROC = o
    extension (v: PFNGLFRAMEBUFFERRENDERBUFFEROESPROC)
      inline def value: CFuncPtr4[GLenum, GLenum, GLenum, GLuint, Unit] = v
      inline def toPtr: Ptr[?] = CFuncPtr.toPtr(v)

  opaque type PFNGLFRAMEBUFFERRENDERBUFFERPROC = CFuncPtr4[GLenum, GLenum, GLenum, GLuint, Unit]
  object PFNGLFRAMEBUFFERRENDERBUFFERPROC:
    given _tag: Tag[PFNGLFRAMEBUFFERRENDERBUFFERPROC] = Tag.materializeCFuncPtr4[GLenum, GLenum, GLenum, GLuint, Unit]
    inline def fromPtr(ptr: Ptr[Byte] | Ptr[?]): PFNGLFRAMEBUFFERRENDERBUFFERPROC = CFuncPtr.fromPtr(ptr.asInstanceOf[Ptr[Byte]])
    inline def apply(inline o: CFuncPtr4[GLenum, GLenum, GLenum, GLuint, Unit]): PFNGLFRAMEBUFFERRENDERBUFFERPROC = o
    extension (v: PFNGLFRAMEBUFFERRENDERBUFFERPROC)
      inline def value: CFuncPtr4[GLenum, GLenum, GLenum, GLuint, Unit] = v
      inline def toPtr: Ptr[?] = CFuncPtr.toPtr(v)

  opaque type PFNGLFRAMEBUFFERSAMPLELOCATIONSFVARBPROC = CFuncPtr4[GLenum, GLuint, GLsizei, Ptr[GLfloat], Unit]
  object PFNGLFRAMEBUFFERSAMPLELOCATIONSFVARBPROC:
    given _tag: Tag[PFNGLFRAMEBUFFERSAMPLELOCATIONSFVARBPROC] = Tag.materializeCFuncPtr4[GLenum, GLuint, GLsizei, Ptr[GLfloat], Unit]
    inline def fromPtr(ptr: Ptr[Byte] | Ptr[?]): PFNGLFRAMEBUFFERSAMPLELOCATIONSFVARBPROC = CFuncPtr.fromPtr(ptr.asInstanceOf[Ptr[Byte]])
    inline def apply(inline o: CFuncPtr4[GLenum, GLuint, GLsizei, Ptr[GLfloat], Unit]): PFNGLFRAMEBUFFERSAMPLELOCATIONSFVARBPROC = o
    extension (v: PFNGLFRAMEBUFFERSAMPLELOCATIONSFVARBPROC)
      inline def value: CFuncPtr4[GLenum, GLuint, GLsizei, Ptr[GLfloat], Unit] = v
      inline def toPtr: Ptr[?] = CFuncPtr.toPtr(v)

  opaque type PFNGLFRAMEBUFFERSAMPLELOCATIONSFVNVPROC = CFuncPtr4[GLenum, GLuint, GLsizei, Ptr[GLfloat], Unit]
  object PFNGLFRAMEBUFFERSAMPLELOCATIONSFVNVPROC:
    given _tag: Tag[PFNGLFRAMEBUFFERSAMPLELOCATIONSFVNVPROC] = Tag.materializeCFuncPtr4[GLenum, GLuint, GLsizei, Ptr[GLfloat], Unit]
    inline def fromPtr(ptr: Ptr[Byte] | Ptr[?]): PFNGLFRAMEBUFFERSAMPLELOCATIONSFVNVPROC = CFuncPtr.fromPtr(ptr.asInstanceOf[Ptr[Byte]])
    inline def apply(inline o: CFuncPtr4[GLenum, GLuint, GLsizei, Ptr[GLfloat], Unit]): PFNGLFRAMEBUFFERSAMPLELOCATIONSFVNVPROC = o
    extension (v: PFNGLFRAMEBUFFERSAMPLELOCATIONSFVNVPROC)
      inline def value: CFuncPtr4[GLenum, GLuint, GLsizei, Ptr[GLfloat], Unit] = v
      inline def toPtr: Ptr[?] = CFuncPtr.toPtr(v)

  opaque type PFNGLFRAMEBUFFERSAMPLEPOSITIONSFVAMDPROC = CFuncPtr4[GLenum, GLuint, GLuint, Ptr[GLfloat], Unit]
  object PFNGLFRAMEBUFFERSAMPLEPOSITIONSFVAMDPROC:
    given _tag: Tag[PFNGLFRAMEBUFFERSAMPLEPOSITIONSFVAMDPROC] = Tag.materializeCFuncPtr4[GLenum, GLuint, GLuint, Ptr[GLfloat], Unit]
    inline def fromPtr(ptr: Ptr[Byte] | Ptr[?]): PFNGLFRAMEBUFFERSAMPLEPOSITIONSFVAMDPROC = CFuncPtr.fromPtr(ptr.asInstanceOf[Ptr[Byte]])
    inline def apply(inline o: CFuncPtr4[GLenum, GLuint, GLuint, Ptr[GLfloat], Unit]): PFNGLFRAMEBUFFERSAMPLEPOSITIONSFVAMDPROC = o
    extension (v: PFNGLFRAMEBUFFERSAMPLEPOSITIONSFVAMDPROC)
      inline def value: CFuncPtr4[GLenum, GLuint, GLuint, Ptr[GLfloat], Unit] = v
      inline def toPtr: Ptr[?] = CFuncPtr.toPtr(v)

  opaque type PFNGLFRAMEBUFFERTEXTURE1DEXTPROC = CFuncPtr5[GLenum, GLenum, GLenum, GLuint, GLint, Unit]
  object PFNGLFRAMEBUFFERTEXTURE1DEXTPROC:
    given _tag: Tag[PFNGLFRAMEBUFFERTEXTURE1DEXTPROC] = Tag.materializeCFuncPtr5[GLenum, GLenum, GLenum, GLuint, GLint, Unit]
    inline def fromPtr(ptr: Ptr[Byte] | Ptr[?]): PFNGLFRAMEBUFFERTEXTURE1DEXTPROC = CFuncPtr.fromPtr(ptr.asInstanceOf[Ptr[Byte]])
    inline def apply(inline o: CFuncPtr5[GLenum, GLenum, GLenum, GLuint, GLint, Unit]): PFNGLFRAMEBUFFERTEXTURE1DEXTPROC = o
    extension (v: PFNGLFRAMEBUFFERTEXTURE1DEXTPROC)
      inline def value: CFuncPtr5[GLenum, GLenum, GLenum, GLuint, GLint, Unit] = v
      inline def toPtr: Ptr[?] = CFuncPtr.toPtr(v)

  opaque type PFNGLFRAMEBUFFERTEXTURE1DPROC = CFuncPtr5[GLenum, GLenum, GLenum, GLuint, GLint, Unit]
  object PFNGLFRAMEBUFFERTEXTURE1DPROC:
    given _tag: Tag[PFNGLFRAMEBUFFERTEXTURE1DPROC] = Tag.materializeCFuncPtr5[GLenum, GLenum, GLenum, GLuint, GLint, Unit]
    inline def fromPtr(ptr: Ptr[Byte] | Ptr[?]): PFNGLFRAMEBUFFERTEXTURE1DPROC = CFuncPtr.fromPtr(ptr.asInstanceOf[Ptr[Byte]])
    inline def apply(inline o: CFuncPtr5[GLenum, GLenum, GLenum, GLuint, GLint, Unit]): PFNGLFRAMEBUFFERTEXTURE1DPROC = o
    extension (v: PFNGLFRAMEBUFFERTEXTURE1DPROC)
      inline def value: CFuncPtr5[GLenum, GLenum, GLenum, GLuint, GLint, Unit] = v
      inline def toPtr: Ptr[?] = CFuncPtr.toPtr(v)

  opaque type PFNGLFRAMEBUFFERTEXTURE2DDOWNSAMPLEIMGPROC = CFuncPtr7[GLenum, GLenum, GLenum, GLuint, GLint, GLint, GLint, Unit]
  object PFNGLFRAMEBUFFERTEXTURE2DDOWNSAMPLEIMGPROC:
    given _tag: Tag[PFNGLFRAMEBUFFERTEXTURE2DDOWNSAMPLEIMGPROC] = Tag.materializeCFuncPtr7[GLenum, GLenum, GLenum, GLuint, GLint, GLint, GLint, Unit]
    inline def fromPtr(ptr: Ptr[Byte] | Ptr[?]): PFNGLFRAMEBUFFERTEXTURE2DDOWNSAMPLEIMGPROC = CFuncPtr.fromPtr(ptr.asInstanceOf[Ptr[Byte]])
    inline def apply(inline o: CFuncPtr7[GLenum, GLenum, GLenum, GLuint, GLint, GLint, GLint, Unit]): PFNGLFRAMEBUFFERTEXTURE2DDOWNSAMPLEIMGPROC = o
    extension (v: PFNGLFRAMEBUFFERTEXTURE2DDOWNSAMPLEIMGPROC)
      inline def value: CFuncPtr7[GLenum, GLenum, GLenum, GLuint, GLint, GLint, GLint, Unit] = v
      inline def toPtr: Ptr[?] = CFuncPtr.toPtr(v)

  opaque type PFNGLFRAMEBUFFERTEXTURE2DEXTPROC = CFuncPtr5[GLenum, GLenum, GLenum, GLuint, GLint, Unit]
  object PFNGLFRAMEBUFFERTEXTURE2DEXTPROC:
    given _tag: Tag[PFNGLFRAMEBUFFERTEXTURE2DEXTPROC] = Tag.materializeCFuncPtr5[GLenum, GLenum, GLenum, GLuint, GLint, Unit]
    inline def fromPtr(ptr: Ptr[Byte] | Ptr[?]): PFNGLFRAMEBUFFERTEXTURE2DEXTPROC = CFuncPtr.fromPtr(ptr.asInstanceOf[Ptr[Byte]])
    inline def apply(inline o: CFuncPtr5[GLenum, GLenum, GLenum, GLuint, GLint, Unit]): PFNGLFRAMEBUFFERTEXTURE2DEXTPROC = o
    extension (v: PFNGLFRAMEBUFFERTEXTURE2DEXTPROC)
      inline def value: CFuncPtr5[GLenum, GLenum, GLenum, GLuint, GLint, Unit] = v
      inline def toPtr: Ptr[?] = CFuncPtr.toPtr(v)

  opaque type PFNGLFRAMEBUFFERTEXTURE2DMULTISAMPLEEXTPROC = CFuncPtr6[GLenum, GLenum, GLenum, GLuint, GLint, GLsizei, Unit]
  object PFNGLFRAMEBUFFERTEXTURE2DMULTISAMPLEEXTPROC:
    given _tag: Tag[PFNGLFRAMEBUFFERTEXTURE2DMULTISAMPLEEXTPROC] = Tag.materializeCFuncPtr6[GLenum, GLenum, GLenum, GLuint, GLint, GLsizei, Unit]
    inline def fromPtr(ptr: Ptr[Byte] | Ptr[?]): PFNGLFRAMEBUFFERTEXTURE2DMULTISAMPLEEXTPROC = CFuncPtr.fromPtr(ptr.asInstanceOf[Ptr[Byte]])
    inline def apply(inline o: CFuncPtr6[GLenum, GLenum, GLenum, GLuint, GLint, GLsizei, Unit]): PFNGLFRAMEBUFFERTEXTURE2DMULTISAMPLEEXTPROC = o
    extension (v: PFNGLFRAMEBUFFERTEXTURE2DMULTISAMPLEEXTPROC)
      inline def value: CFuncPtr6[GLenum, GLenum, GLenum, GLuint, GLint, GLsizei, Unit] = v
      inline def toPtr: Ptr[?] = CFuncPtr.toPtr(v)

  opaque type PFNGLFRAMEBUFFERTEXTURE2DMULTISAMPLEIMGPROC = CFuncPtr6[GLenum, GLenum, GLenum, GLuint, GLint, GLsizei, Unit]
  object PFNGLFRAMEBUFFERTEXTURE2DMULTISAMPLEIMGPROC:
    given _tag: Tag[PFNGLFRAMEBUFFERTEXTURE2DMULTISAMPLEIMGPROC] = Tag.materializeCFuncPtr6[GLenum, GLenum, GLenum, GLuint, GLint, GLsizei, Unit]
    inline def fromPtr(ptr: Ptr[Byte] | Ptr[?]): PFNGLFRAMEBUFFERTEXTURE2DMULTISAMPLEIMGPROC = CFuncPtr.fromPtr(ptr.asInstanceOf[Ptr[Byte]])
    inline def apply(inline o: CFuncPtr6[GLenum, GLenum, GLenum, GLuint, GLint, GLsizei, Unit]): PFNGLFRAMEBUFFERTEXTURE2DMULTISAMPLEIMGPROC = o
    extension (v: PFNGLFRAMEBUFFERTEXTURE2DMULTISAMPLEIMGPROC)
      inline def value: CFuncPtr6[GLenum, GLenum, GLenum, GLuint, GLint, GLsizei, Unit] = v
      inline def toPtr: Ptr[?] = CFuncPtr.toPtr(v)

  opaque type PFNGLFRAMEBUFFERTEXTURE2DOESPROC = CFuncPtr5[GLenum, GLenum, GLenum, GLuint, GLint, Unit]
  object PFNGLFRAMEBUFFERTEXTURE2DOESPROC:
    given _tag: Tag[PFNGLFRAMEBUFFERTEXTURE2DOESPROC] = Tag.materializeCFuncPtr5[GLenum, GLenum, GLenum, GLuint, GLint, Unit]
    inline def fromPtr(ptr: Ptr[Byte] | Ptr[?]): PFNGLFRAMEBUFFERTEXTURE2DOESPROC = CFuncPtr.fromPtr(ptr.asInstanceOf[Ptr[Byte]])
    inline def apply(inline o: CFuncPtr5[GLenum, GLenum, GLenum, GLuint, GLint, Unit]): PFNGLFRAMEBUFFERTEXTURE2DOESPROC = o
    extension (v: PFNGLFRAMEBUFFERTEXTURE2DOESPROC)
      inline def value: CFuncPtr5[GLenum, GLenum, GLenum, GLuint, GLint, Unit] = v
      inline def toPtr: Ptr[?] = CFuncPtr.toPtr(v)

  opaque type PFNGLFRAMEBUFFERTEXTURE2DPROC = CFuncPtr5[GLenum, GLenum, GLenum, GLuint, GLint, Unit]
  object PFNGLFRAMEBUFFERTEXTURE2DPROC:
    given _tag: Tag[PFNGLFRAMEBUFFERTEXTURE2DPROC] = Tag.materializeCFuncPtr5[GLenum, GLenum, GLenum, GLuint, GLint, Unit]
    inline def fromPtr(ptr: Ptr[Byte] | Ptr[?]): PFNGLFRAMEBUFFERTEXTURE2DPROC = CFuncPtr.fromPtr(ptr.asInstanceOf[Ptr[Byte]])
    inline def apply(inline o: CFuncPtr5[GLenum, GLenum, GLenum, GLuint, GLint, Unit]): PFNGLFRAMEBUFFERTEXTURE2DPROC = o
    extension (v: PFNGLFRAMEBUFFERTEXTURE2DPROC)
      inline def value: CFuncPtr5[GLenum, GLenum, GLenum, GLuint, GLint, Unit] = v
      inline def toPtr: Ptr[?] = CFuncPtr.toPtr(v)

  opaque type PFNGLFRAMEBUFFERTEXTURE3DEXTPROC = CFuncPtr6[GLenum, GLenum, GLenum, GLuint, GLint, GLint, Unit]
  object PFNGLFRAMEBUFFERTEXTURE3DEXTPROC:
    given _tag: Tag[PFNGLFRAMEBUFFERTEXTURE3DEXTPROC] = Tag.materializeCFuncPtr6[GLenum, GLenum, GLenum, GLuint, GLint, GLint, Unit]
    inline def fromPtr(ptr: Ptr[Byte] | Ptr[?]): PFNGLFRAMEBUFFERTEXTURE3DEXTPROC = CFuncPtr.fromPtr(ptr.asInstanceOf[Ptr[Byte]])
    inline def apply(inline o: CFuncPtr6[GLenum, GLenum, GLenum, GLuint, GLint, GLint, Unit]): PFNGLFRAMEBUFFERTEXTURE3DEXTPROC = o
    extension (v: PFNGLFRAMEBUFFERTEXTURE3DEXTPROC)
      inline def value: CFuncPtr6[GLenum, GLenum, GLenum, GLuint, GLint, GLint, Unit] = v
      inline def toPtr: Ptr[?] = CFuncPtr.toPtr(v)

  opaque type PFNGLFRAMEBUFFERTEXTURE3DOESPROC = CFuncPtr6[GLenum, GLenum, GLenum, GLuint, GLint, GLint, Unit]
  object PFNGLFRAMEBUFFERTEXTURE3DOESPROC:
    given _tag: Tag[PFNGLFRAMEBUFFERTEXTURE3DOESPROC] = Tag.materializeCFuncPtr6[GLenum, GLenum, GLenum, GLuint, GLint, GLint, Unit]
    inline def fromPtr(ptr: Ptr[Byte] | Ptr[?]): PFNGLFRAMEBUFFERTEXTURE3DOESPROC = CFuncPtr.fromPtr(ptr.asInstanceOf[Ptr[Byte]])
    inline def apply(inline o: CFuncPtr6[GLenum, GLenum, GLenum, GLuint, GLint, GLint, Unit]): PFNGLFRAMEBUFFERTEXTURE3DOESPROC = o
    extension (v: PFNGLFRAMEBUFFERTEXTURE3DOESPROC)
      inline def value: CFuncPtr6[GLenum, GLenum, GLenum, GLuint, GLint, GLint, Unit] = v
      inline def toPtr: Ptr[?] = CFuncPtr.toPtr(v)

  opaque type PFNGLFRAMEBUFFERTEXTURE3DPROC = CFuncPtr6[GLenum, GLenum, GLenum, GLuint, GLint, GLint, Unit]
  object PFNGLFRAMEBUFFERTEXTURE3DPROC:
    given _tag: Tag[PFNGLFRAMEBUFFERTEXTURE3DPROC] = Tag.materializeCFuncPtr6[GLenum, GLenum, GLenum, GLuint, GLint, GLint, Unit]
    inline def fromPtr(ptr: Ptr[Byte] | Ptr[?]): PFNGLFRAMEBUFFERTEXTURE3DPROC = CFuncPtr.fromPtr(ptr.asInstanceOf[Ptr[Byte]])
    inline def apply(inline o: CFuncPtr6[GLenum, GLenum, GLenum, GLuint, GLint, GLint, Unit]): PFNGLFRAMEBUFFERTEXTURE3DPROC = o
    extension (v: PFNGLFRAMEBUFFERTEXTURE3DPROC)
      inline def value: CFuncPtr6[GLenum, GLenum, GLenum, GLuint, GLint, GLint, Unit] = v
      inline def toPtr: Ptr[?] = CFuncPtr.toPtr(v)

  opaque type PFNGLFRAMEBUFFERTEXTUREARBPROC = CFuncPtr4[GLenum, GLenum, GLuint, GLint, Unit]
  object PFNGLFRAMEBUFFERTEXTUREARBPROC:
    given _tag: Tag[PFNGLFRAMEBUFFERTEXTUREARBPROC] = Tag.materializeCFuncPtr4[GLenum, GLenum, GLuint, GLint, Unit]
    inline def fromPtr(ptr: Ptr[Byte] | Ptr[?]): PFNGLFRAMEBUFFERTEXTUREARBPROC = CFuncPtr.fromPtr(ptr.asInstanceOf[Ptr[Byte]])
    inline def apply(inline o: CFuncPtr4[GLenum, GLenum, GLuint, GLint, Unit]): PFNGLFRAMEBUFFERTEXTUREARBPROC = o
    extension (v: PFNGLFRAMEBUFFERTEXTUREARBPROC)
      inline def value: CFuncPtr4[GLenum, GLenum, GLuint, GLint, Unit] = v
      inline def toPtr: Ptr[?] = CFuncPtr.toPtr(v)

  opaque type PFNGLFRAMEBUFFERTEXTUREEXTPROC = CFuncPtr4[GLenum, GLenum, GLuint, GLint, Unit]
  object PFNGLFRAMEBUFFERTEXTUREEXTPROC:
    given _tag: Tag[PFNGLFRAMEBUFFERTEXTUREEXTPROC] = Tag.materializeCFuncPtr4[GLenum, GLenum, GLuint, GLint, Unit]
    inline def fromPtr(ptr: Ptr[Byte] | Ptr[?]): PFNGLFRAMEBUFFERTEXTUREEXTPROC = CFuncPtr.fromPtr(ptr.asInstanceOf[Ptr[Byte]])
    inline def apply(inline o: CFuncPtr4[GLenum, GLenum, GLuint, GLint, Unit]): PFNGLFRAMEBUFFERTEXTUREEXTPROC = o
    extension (v: PFNGLFRAMEBUFFERTEXTUREEXTPROC)
      inline def value: CFuncPtr4[GLenum, GLenum, GLuint, GLint, Unit] = v
      inline def toPtr: Ptr[?] = CFuncPtr.toPtr(v)

  opaque type PFNGLFRAMEBUFFERTEXTUREFACEARBPROC = CFuncPtr5[GLenum, GLenum, GLuint, GLint, GLenum, Unit]
  object PFNGLFRAMEBUFFERTEXTUREFACEARBPROC:
    given _tag: Tag[PFNGLFRAMEBUFFERTEXTUREFACEARBPROC] = Tag.materializeCFuncPtr5[GLenum, GLenum, GLuint, GLint, GLenum, Unit]
    inline def fromPtr(ptr: Ptr[Byte] | Ptr[?]): PFNGLFRAMEBUFFERTEXTUREFACEARBPROC = CFuncPtr.fromPtr(ptr.asInstanceOf[Ptr[Byte]])
    inline def apply(inline o: CFuncPtr5[GLenum, GLenum, GLuint, GLint, GLenum, Unit]): PFNGLFRAMEBUFFERTEXTUREFACEARBPROC = o
    extension (v: PFNGLFRAMEBUFFERTEXTUREFACEARBPROC)
      inline def value: CFuncPtr5[GLenum, GLenum, GLuint, GLint, GLenum, Unit] = v
      inline def toPtr: Ptr[?] = CFuncPtr.toPtr(v)

  opaque type PFNGLFRAMEBUFFERTEXTUREFACEEXTPROC = CFuncPtr5[GLenum, GLenum, GLuint, GLint, GLenum, Unit]
  object PFNGLFRAMEBUFFERTEXTUREFACEEXTPROC:
    given _tag: Tag[PFNGLFRAMEBUFFERTEXTUREFACEEXTPROC] = Tag.materializeCFuncPtr5[GLenum, GLenum, GLuint, GLint, GLenum, Unit]
    inline def fromPtr(ptr: Ptr[Byte] | Ptr[?]): PFNGLFRAMEBUFFERTEXTUREFACEEXTPROC = CFuncPtr.fromPtr(ptr.asInstanceOf[Ptr[Byte]])
    inline def apply(inline o: CFuncPtr5[GLenum, GLenum, GLuint, GLint, GLenum, Unit]): PFNGLFRAMEBUFFERTEXTUREFACEEXTPROC = o
    extension (v: PFNGLFRAMEBUFFERTEXTUREFACEEXTPROC)
      inline def value: CFuncPtr5[GLenum, GLenum, GLuint, GLint, GLenum, Unit] = v
      inline def toPtr: Ptr[?] = CFuncPtr.toPtr(v)

  opaque type PFNGLFRAMEBUFFERTEXTURELAYERARBPROC = CFuncPtr5[GLenum, GLenum, GLuint, GLint, GLint, Unit]
  object PFNGLFRAMEBUFFERTEXTURELAYERARBPROC:
    given _tag: Tag[PFNGLFRAMEBUFFERTEXTURELAYERARBPROC] = Tag.materializeCFuncPtr5[GLenum, GLenum, GLuint, GLint, GLint, Unit]
    inline def fromPtr(ptr: Ptr[Byte] | Ptr[?]): PFNGLFRAMEBUFFERTEXTURELAYERARBPROC = CFuncPtr.fromPtr(ptr.asInstanceOf[Ptr[Byte]])
    inline def apply(inline o: CFuncPtr5[GLenum, GLenum, GLuint, GLint, GLint, Unit]): PFNGLFRAMEBUFFERTEXTURELAYERARBPROC = o
    extension (v: PFNGLFRAMEBUFFERTEXTURELAYERARBPROC)
      inline def value: CFuncPtr5[GLenum, GLenum, GLuint, GLint, GLint, Unit] = v
      inline def toPtr: Ptr[?] = CFuncPtr.toPtr(v)

  opaque type PFNGLFRAMEBUFFERTEXTURELAYERDOWNSAMPLEIMGPROC = CFuncPtr7[GLenum, GLenum, GLuint, GLint, GLint, GLint, GLint, Unit]
  object PFNGLFRAMEBUFFERTEXTURELAYERDOWNSAMPLEIMGPROC:
    given _tag: Tag[PFNGLFRAMEBUFFERTEXTURELAYERDOWNSAMPLEIMGPROC] = Tag.materializeCFuncPtr7[GLenum, GLenum, GLuint, GLint, GLint, GLint, GLint, Unit]
    inline def fromPtr(ptr: Ptr[Byte] | Ptr[?]): PFNGLFRAMEBUFFERTEXTURELAYERDOWNSAMPLEIMGPROC = CFuncPtr.fromPtr(ptr.asInstanceOf[Ptr[Byte]])
    inline def apply(inline o: CFuncPtr7[GLenum, GLenum, GLuint, GLint, GLint, GLint, GLint, Unit]): PFNGLFRAMEBUFFERTEXTURELAYERDOWNSAMPLEIMGPROC = o
    extension (v: PFNGLFRAMEBUFFERTEXTURELAYERDOWNSAMPLEIMGPROC)
      inline def value: CFuncPtr7[GLenum, GLenum, GLuint, GLint, GLint, GLint, GLint, Unit] = v
      inline def toPtr: Ptr[?] = CFuncPtr.toPtr(v)

  opaque type PFNGLFRAMEBUFFERTEXTURELAYEREXTPROC = CFuncPtr5[GLenum, GLenum, GLuint, GLint, GLint, Unit]
  object PFNGLFRAMEBUFFERTEXTURELAYEREXTPROC:
    given _tag: Tag[PFNGLFRAMEBUFFERTEXTURELAYEREXTPROC] = Tag.materializeCFuncPtr5[GLenum, GLenum, GLuint, GLint, GLint, Unit]
    inline def fromPtr(ptr: Ptr[Byte] | Ptr[?]): PFNGLFRAMEBUFFERTEXTURELAYEREXTPROC = CFuncPtr.fromPtr(ptr.asInstanceOf[Ptr[Byte]])
    inline def apply(inline o: CFuncPtr5[GLenum, GLenum, GLuint, GLint, GLint, Unit]): PFNGLFRAMEBUFFERTEXTURELAYEREXTPROC = o
    extension (v: PFNGLFRAMEBUFFERTEXTURELAYEREXTPROC)
      inline def value: CFuncPtr5[GLenum, GLenum, GLuint, GLint, GLint, Unit] = v
      inline def toPtr: Ptr[?] = CFuncPtr.toPtr(v)

  opaque type PFNGLFRAMEBUFFERTEXTURELAYERNVPROC = CFuncPtr5[GLenum, GLenum, GLuint, GLint, GLint, Unit]
  object PFNGLFRAMEBUFFERTEXTURELAYERNVPROC:
    given _tag: Tag[PFNGLFRAMEBUFFERTEXTURELAYERNVPROC] = Tag.materializeCFuncPtr5[GLenum, GLenum, GLuint, GLint, GLint, Unit]
    inline def fromPtr(ptr: Ptr[Byte] | Ptr[?]): PFNGLFRAMEBUFFERTEXTURELAYERNVPROC = CFuncPtr.fromPtr(ptr.asInstanceOf[Ptr[Byte]])
    inline def apply(inline o: CFuncPtr5[GLenum, GLenum, GLuint, GLint, GLint, Unit]): PFNGLFRAMEBUFFERTEXTURELAYERNVPROC = o
    extension (v: PFNGLFRAMEBUFFERTEXTURELAYERNVPROC)
      inline def value: CFuncPtr5[GLenum, GLenum, GLuint, GLint, GLint, Unit] = v
      inline def toPtr: Ptr[?] = CFuncPtr.toPtr(v)

  opaque type PFNGLFRAMEBUFFERTEXTURELAYERPROC = CFuncPtr5[GLenum, GLenum, GLuint, GLint, GLint, Unit]
  object PFNGLFRAMEBUFFERTEXTURELAYERPROC:
    given _tag: Tag[PFNGLFRAMEBUFFERTEXTURELAYERPROC] = Tag.materializeCFuncPtr5[GLenum, GLenum, GLuint, GLint, GLint, Unit]
    inline def fromPtr(ptr: Ptr[Byte] | Ptr[?]): PFNGLFRAMEBUFFERTEXTURELAYERPROC = CFuncPtr.fromPtr(ptr.asInstanceOf[Ptr[Byte]])
    inline def apply(inline o: CFuncPtr5[GLenum, GLenum, GLuint, GLint, GLint, Unit]): PFNGLFRAMEBUFFERTEXTURELAYERPROC = o
    extension (v: PFNGLFRAMEBUFFERTEXTURELAYERPROC)
      inline def value: CFuncPtr5[GLenum, GLenum, GLuint, GLint, GLint, Unit] = v
      inline def toPtr: Ptr[?] = CFuncPtr.toPtr(v)

  opaque type PFNGLFRAMEBUFFERTEXTUREMULTISAMPLEMULTIVIEWOVRPROC = CFuncPtr7[GLenum, GLenum, GLuint, GLint, GLsizei, GLint, GLsizei, Unit]
  object PFNGLFRAMEBUFFERTEXTUREMULTISAMPLEMULTIVIEWOVRPROC:
    given _tag: Tag[PFNGLFRAMEBUFFERTEXTUREMULTISAMPLEMULTIVIEWOVRPROC] = Tag.materializeCFuncPtr7[GLenum, GLenum, GLuint, GLint, GLsizei, GLint, GLsizei, Unit]
    inline def fromPtr(ptr: Ptr[Byte] | Ptr[?]): PFNGLFRAMEBUFFERTEXTUREMULTISAMPLEMULTIVIEWOVRPROC = CFuncPtr.fromPtr(ptr.asInstanceOf[Ptr[Byte]])
    inline def apply(inline o: CFuncPtr7[GLenum, GLenum, GLuint, GLint, GLsizei, GLint, GLsizei, Unit]): PFNGLFRAMEBUFFERTEXTUREMULTISAMPLEMULTIVIEWOVRPROC = o
    extension (v: PFNGLFRAMEBUFFERTEXTUREMULTISAMPLEMULTIVIEWOVRPROC)
      inline def value: CFuncPtr7[GLenum, GLenum, GLuint, GLint, GLsizei, GLint, GLsizei, Unit] = v
      inline def toPtr: Ptr[?] = CFuncPtr.toPtr(v)

  opaque type PFNGLFRAMEBUFFERTEXTUREMULTIVIEWOVRPROC = CFuncPtr6[GLenum, GLenum, GLuint, GLint, GLint, GLsizei, Unit]
  object PFNGLFRAMEBUFFERTEXTUREMULTIVIEWOVRPROC:
    given _tag: Tag[PFNGLFRAMEBUFFERTEXTUREMULTIVIEWOVRPROC] = Tag.materializeCFuncPtr6[GLenum, GLenum, GLuint, GLint, GLint, GLsizei, Unit]
    inline def fromPtr(ptr: Ptr[Byte] | Ptr[?]): PFNGLFRAMEBUFFERTEXTUREMULTIVIEWOVRPROC = CFuncPtr.fromPtr(ptr.asInstanceOf[Ptr[Byte]])
    inline def apply(inline o: CFuncPtr6[GLenum, GLenum, GLuint, GLint, GLint, GLsizei, Unit]): PFNGLFRAMEBUFFERTEXTUREMULTIVIEWOVRPROC = o
    extension (v: PFNGLFRAMEBUFFERTEXTUREMULTIVIEWOVRPROC)
      inline def value: CFuncPtr6[GLenum, GLenum, GLuint, GLint, GLint, GLsizei, Unit] = v
      inline def toPtr: Ptr[?] = CFuncPtr.toPtr(v)

  opaque type PFNGLFRAMEBUFFERTEXTUREPROC = CFuncPtr4[GLenum, GLenum, GLuint, GLint, Unit]
  object PFNGLFRAMEBUFFERTEXTUREPROC:
    given _tag: Tag[PFNGLFRAMEBUFFERTEXTUREPROC] = Tag.materializeCFuncPtr4[GLenum, GLenum, GLuint, GLint, Unit]
    inline def fromPtr(ptr: Ptr[Byte] | Ptr[?]): PFNGLFRAMEBUFFERTEXTUREPROC = CFuncPtr.fromPtr(ptr.asInstanceOf[Ptr[Byte]])
    inline def apply(inline o: CFuncPtr4[GLenum, GLenum, GLuint, GLint, Unit]): PFNGLFRAMEBUFFERTEXTUREPROC = o
    extension (v: PFNGLFRAMEBUFFERTEXTUREPROC)
      inline def value: CFuncPtr4[GLenum, GLenum, GLuint, GLint, Unit] = v
      inline def toPtr: Ptr[?] = CFuncPtr.toPtr(v)

  opaque type PFNGLFRAMETERMINATORGREMEDYPROC = CFuncPtr0[Unit]
  object PFNGLFRAMETERMINATORGREMEDYPROC:
    given _tag: Tag[PFNGLFRAMETERMINATORGREMEDYPROC] = Tag.materializeCFuncPtr0[Unit]
    inline def fromPtr(ptr: Ptr[Byte] | Ptr[?]): PFNGLFRAMETERMINATORGREMEDYPROC = CFuncPtr.fromPtr(ptr.asInstanceOf[Ptr[Byte]])
    inline def apply(inline o: CFuncPtr0[Unit]): PFNGLFRAMETERMINATORGREMEDYPROC = o
    extension (v: PFNGLFRAMETERMINATORGREMEDYPROC)
      inline def value: CFuncPtr0[Unit] = v
      inline def toPtr: Ptr[?] = CFuncPtr.toPtr(v)

  opaque type PFNGLFRAMEZOOMSGIXPROC = CFuncPtr1[GLint, Unit]
  object PFNGLFRAMEZOOMSGIXPROC:
    given _tag: Tag[PFNGLFRAMEZOOMSGIXPROC] = Tag.materializeCFuncPtr1[GLint, Unit]
    inline def fromPtr(ptr: Ptr[Byte] | Ptr[?]): PFNGLFRAMEZOOMSGIXPROC = CFuncPtr.fromPtr(ptr.asInstanceOf[Ptr[Byte]])
    inline def apply(inline o: CFuncPtr1[GLint, Unit]): PFNGLFRAMEZOOMSGIXPROC = o
    extension (v: PFNGLFRAMEZOOMSGIXPROC)
      inline def value: CFuncPtr1[GLint, Unit] = v
      inline def toPtr: Ptr[?] = CFuncPtr.toPtr(v)

  opaque type PFNGLFREEOBJECTBUFFERATIPROC = CFuncPtr1[GLuint, Unit]
  object PFNGLFREEOBJECTBUFFERATIPROC:
    given _tag: Tag[PFNGLFREEOBJECTBUFFERATIPROC] = Tag.materializeCFuncPtr1[GLuint, Unit]
    inline def fromPtr(ptr: Ptr[Byte] | Ptr[?]): PFNGLFREEOBJECTBUFFERATIPROC = CFuncPtr.fromPtr(ptr.asInstanceOf[Ptr[Byte]])
    inline def apply(inline o: CFuncPtr1[GLuint, Unit]): PFNGLFREEOBJECTBUFFERATIPROC = o
    extension (v: PFNGLFREEOBJECTBUFFERATIPROC)
      inline def value: CFuncPtr1[GLuint, Unit] = v
      inline def toPtr: Ptr[?] = CFuncPtr.toPtr(v)

  opaque type PFNGLFRUSTUMFOESPROC = CFuncPtr6[GLfloat, GLfloat, GLfloat, GLfloat, GLfloat, GLfloat, Unit]
  object PFNGLFRUSTUMFOESPROC:
    given _tag: Tag[PFNGLFRUSTUMFOESPROC] = Tag.materializeCFuncPtr6[GLfloat, GLfloat, GLfloat, GLfloat, GLfloat, GLfloat, Unit]
    inline def fromPtr(ptr: Ptr[Byte] | Ptr[?]): PFNGLFRUSTUMFOESPROC = CFuncPtr.fromPtr(ptr.asInstanceOf[Ptr[Byte]])
    inline def apply(inline o: CFuncPtr6[GLfloat, GLfloat, GLfloat, GLfloat, GLfloat, GLfloat, Unit]): PFNGLFRUSTUMFOESPROC = o
    extension (v: PFNGLFRUSTUMFOESPROC)
      inline def value: CFuncPtr6[GLfloat, GLfloat, GLfloat, GLfloat, GLfloat, GLfloat, Unit] = v
      inline def toPtr: Ptr[?] = CFuncPtr.toPtr(v)

  opaque type PFNGLFRUSTUMFPROC = CFuncPtr6[GLfloat, GLfloat, GLfloat, GLfloat, GLfloat, GLfloat, Unit]
  object PFNGLFRUSTUMFPROC:
    given _tag: Tag[PFNGLFRUSTUMFPROC] = Tag.materializeCFuncPtr6[GLfloat, GLfloat, GLfloat, GLfloat, GLfloat, GLfloat, Unit]
    inline def fromPtr(ptr: Ptr[Byte] | Ptr[?]): PFNGLFRUSTUMFPROC = CFuncPtr.fromPtr(ptr.asInstanceOf[Ptr[Byte]])
    inline def apply(inline o: CFuncPtr6[GLfloat, GLfloat, GLfloat, GLfloat, GLfloat, GLfloat, Unit]): PFNGLFRUSTUMFPROC = o
    extension (v: PFNGLFRUSTUMFPROC)
      inline def value: CFuncPtr6[GLfloat, GLfloat, GLfloat, GLfloat, GLfloat, GLfloat, Unit] = v
      inline def toPtr: Ptr[?] = CFuncPtr.toPtr(v)

  opaque type PFNGLFRUSTUMXPROC = CFuncPtr6[GLfixed, GLfixed, GLfixed, GLfixed, GLfixed, GLfixed, Unit]
  object PFNGLFRUSTUMXPROC:
    given _tag: Tag[PFNGLFRUSTUMXPROC] = Tag.materializeCFuncPtr6[GLfixed, GLfixed, GLfixed, GLfixed, GLfixed, GLfixed, Unit]
    inline def fromPtr(ptr: Ptr[Byte] | Ptr[?]): PFNGLFRUSTUMXPROC = CFuncPtr.fromPtr(ptr.asInstanceOf[Ptr[Byte]])
    inline def apply(inline o: CFuncPtr6[GLfixed, GLfixed, GLfixed, GLfixed, GLfixed, GLfixed, Unit]): PFNGLFRUSTUMXPROC = o
    extension (v: PFNGLFRUSTUMXPROC)
      inline def value: CFuncPtr6[GLfixed, GLfixed, GLfixed, GLfixed, GLfixed, GLfixed, Unit] = v
      inline def toPtr: Ptr[?] = CFuncPtr.toPtr(v)

  opaque type PFNGLGENASYNCMARKERSSGIXPROC = CFuncPtr1[GLsizei, GLuint]
  object PFNGLGENASYNCMARKERSSGIXPROC:
    given _tag: Tag[PFNGLGENASYNCMARKERSSGIXPROC] = Tag.materializeCFuncPtr1[GLsizei, GLuint]
    inline def fromPtr(ptr: Ptr[Byte] | Ptr[?]): PFNGLGENASYNCMARKERSSGIXPROC = CFuncPtr.fromPtr(ptr.asInstanceOf[Ptr[Byte]])
    inline def apply(inline o: CFuncPtr1[GLsizei, GLuint]): PFNGLGENASYNCMARKERSSGIXPROC = o
    extension (v: PFNGLGENASYNCMARKERSSGIXPROC)
      inline def value: CFuncPtr1[GLsizei, GLuint] = v
      inline def toPtr: Ptr[?] = CFuncPtr.toPtr(v)

  opaque type PFNGLGENBUFFERSARBPROC = CFuncPtr2[GLsizei, Ptr[GLuint], Unit]
  object PFNGLGENBUFFERSARBPROC:
    given _tag: Tag[PFNGLGENBUFFERSARBPROC] = Tag.materializeCFuncPtr2[GLsizei, Ptr[GLuint], Unit]
    inline def fromPtr(ptr: Ptr[Byte] | Ptr[?]): PFNGLGENBUFFERSARBPROC = CFuncPtr.fromPtr(ptr.asInstanceOf[Ptr[Byte]])
    inline def apply(inline o: CFuncPtr2[GLsizei, Ptr[GLuint], Unit]): PFNGLGENBUFFERSARBPROC = o
    extension (v: PFNGLGENBUFFERSARBPROC)
      inline def value: CFuncPtr2[GLsizei, Ptr[GLuint], Unit] = v
      inline def toPtr: Ptr[?] = CFuncPtr.toPtr(v)

  opaque type PFNGLGENBUFFERSPROC = CFuncPtr2[GLsizei, Ptr[GLuint], Unit]
  object PFNGLGENBUFFERSPROC:
    given _tag: Tag[PFNGLGENBUFFERSPROC] = Tag.materializeCFuncPtr2[GLsizei, Ptr[GLuint], Unit]
    inline def fromPtr(ptr: Ptr[Byte] | Ptr[?]): PFNGLGENBUFFERSPROC = CFuncPtr.fromPtr(ptr.asInstanceOf[Ptr[Byte]])
    inline def apply(inline o: CFuncPtr2[GLsizei, Ptr[GLuint], Unit]): PFNGLGENBUFFERSPROC = o
    extension (v: PFNGLGENBUFFERSPROC)
      inline def value: CFuncPtr2[GLsizei, Ptr[GLuint], Unit] = v
      inline def toPtr: Ptr[?] = CFuncPtr.toPtr(v)

  opaque type PFNGLGENERATEMIPMAPEXTPROC = CFuncPtr1[GLenum, Unit]
  object PFNGLGENERATEMIPMAPEXTPROC:
    given _tag: Tag[PFNGLGENERATEMIPMAPEXTPROC] = Tag.materializeCFuncPtr1[GLenum, Unit]
    inline def fromPtr(ptr: Ptr[Byte] | Ptr[?]): PFNGLGENERATEMIPMAPEXTPROC = CFuncPtr.fromPtr(ptr.asInstanceOf[Ptr[Byte]])
    inline def apply(inline o: CFuncPtr1[GLenum, Unit]): PFNGLGENERATEMIPMAPEXTPROC = o
    extension (v: PFNGLGENERATEMIPMAPEXTPROC)
      inline def value: CFuncPtr1[GLenum, Unit] = v
      inline def toPtr: Ptr[?] = CFuncPtr.toPtr(v)

  opaque type PFNGLGENERATEMIPMAPOESPROC = CFuncPtr1[GLenum, Unit]
  object PFNGLGENERATEMIPMAPOESPROC:
    given _tag: Tag[PFNGLGENERATEMIPMAPOESPROC] = Tag.materializeCFuncPtr1[GLenum, Unit]
    inline def fromPtr(ptr: Ptr[Byte] | Ptr[?]): PFNGLGENERATEMIPMAPOESPROC = CFuncPtr.fromPtr(ptr.asInstanceOf[Ptr[Byte]])
    inline def apply(inline o: CFuncPtr1[GLenum, Unit]): PFNGLGENERATEMIPMAPOESPROC = o
    extension (v: PFNGLGENERATEMIPMAPOESPROC)
      inline def value: CFuncPtr1[GLenum, Unit] = v
      inline def toPtr: Ptr[?] = CFuncPtr.toPtr(v)

  opaque type PFNGLGENERATEMIPMAPPROC = CFuncPtr1[GLenum, Unit]
  object PFNGLGENERATEMIPMAPPROC:
    given _tag: Tag[PFNGLGENERATEMIPMAPPROC] = Tag.materializeCFuncPtr1[GLenum, Unit]
    inline def fromPtr(ptr: Ptr[Byte] | Ptr[?]): PFNGLGENERATEMIPMAPPROC = CFuncPtr.fromPtr(ptr.asInstanceOf[Ptr[Byte]])
    inline def apply(inline o: CFuncPtr1[GLenum, Unit]): PFNGLGENERATEMIPMAPPROC = o
    extension (v: PFNGLGENERATEMIPMAPPROC)
      inline def value: CFuncPtr1[GLenum, Unit] = v
      inline def toPtr: Ptr[?] = CFuncPtr.toPtr(v)

  opaque type PFNGLGENERATEMULTITEXMIPMAPEXTPROC = CFuncPtr2[GLenum, GLenum, Unit]
  object PFNGLGENERATEMULTITEXMIPMAPEXTPROC:
    given _tag: Tag[PFNGLGENERATEMULTITEXMIPMAPEXTPROC] = Tag.materializeCFuncPtr2[GLenum, GLenum, Unit]
    inline def fromPtr(ptr: Ptr[Byte] | Ptr[?]): PFNGLGENERATEMULTITEXMIPMAPEXTPROC = CFuncPtr.fromPtr(ptr.asInstanceOf[Ptr[Byte]])
    inline def apply(inline o: CFuncPtr2[GLenum, GLenum, Unit]): PFNGLGENERATEMULTITEXMIPMAPEXTPROC = o
    extension (v: PFNGLGENERATEMULTITEXMIPMAPEXTPROC)
      inline def value: CFuncPtr2[GLenum, GLenum, Unit] = v
      inline def toPtr: Ptr[?] = CFuncPtr.toPtr(v)

  opaque type PFNGLGENERATETEXTUREMIPMAPEXTPROC = CFuncPtr2[GLuint, GLenum, Unit]
  object PFNGLGENERATETEXTUREMIPMAPEXTPROC:
    given _tag: Tag[PFNGLGENERATETEXTUREMIPMAPEXTPROC] = Tag.materializeCFuncPtr2[GLuint, GLenum, Unit]
    inline def fromPtr(ptr: Ptr[Byte] | Ptr[?]): PFNGLGENERATETEXTUREMIPMAPEXTPROC = CFuncPtr.fromPtr(ptr.asInstanceOf[Ptr[Byte]])
    inline def apply(inline o: CFuncPtr2[GLuint, GLenum, Unit]): PFNGLGENERATETEXTUREMIPMAPEXTPROC = o
    extension (v: PFNGLGENERATETEXTUREMIPMAPEXTPROC)
      inline def value: CFuncPtr2[GLuint, GLenum, Unit] = v
      inline def toPtr: Ptr[?] = CFuncPtr.toPtr(v)

  opaque type PFNGLGENERATETEXTUREMIPMAPPROC = CFuncPtr1[GLuint, Unit]
  object PFNGLGENERATETEXTUREMIPMAPPROC:
    given _tag: Tag[PFNGLGENERATETEXTUREMIPMAPPROC] = Tag.materializeCFuncPtr1[GLuint, Unit]
    inline def fromPtr(ptr: Ptr[Byte] | Ptr[?]): PFNGLGENERATETEXTUREMIPMAPPROC = CFuncPtr.fromPtr(ptr.asInstanceOf[Ptr[Byte]])
    inline def apply(inline o: CFuncPtr1[GLuint, Unit]): PFNGLGENERATETEXTUREMIPMAPPROC = o
    extension (v: PFNGLGENERATETEXTUREMIPMAPPROC)
      inline def value: CFuncPtr1[GLuint, Unit] = v
      inline def toPtr: Ptr[?] = CFuncPtr.toPtr(v)

  opaque type PFNGLGENFENCESAPPLEPROC = CFuncPtr2[GLsizei, Ptr[GLuint], Unit]
  object PFNGLGENFENCESAPPLEPROC:
    given _tag: Tag[PFNGLGENFENCESAPPLEPROC] = Tag.materializeCFuncPtr2[GLsizei, Ptr[GLuint], Unit]
    inline def fromPtr(ptr: Ptr[Byte] | Ptr[?]): PFNGLGENFENCESAPPLEPROC = CFuncPtr.fromPtr(ptr.asInstanceOf[Ptr[Byte]])
    inline def apply(inline o: CFuncPtr2[GLsizei, Ptr[GLuint], Unit]): PFNGLGENFENCESAPPLEPROC = o
    extension (v: PFNGLGENFENCESAPPLEPROC)
      inline def value: CFuncPtr2[GLsizei, Ptr[GLuint], Unit] = v
      inline def toPtr: Ptr[?] = CFuncPtr.toPtr(v)

  opaque type PFNGLGENFENCESNVPROC = CFuncPtr2[GLsizei, Ptr[GLuint], Unit]
  object PFNGLGENFENCESNVPROC:
    given _tag: Tag[PFNGLGENFENCESNVPROC] = Tag.materializeCFuncPtr2[GLsizei, Ptr[GLuint], Unit]
    inline def fromPtr(ptr: Ptr[Byte] | Ptr[?]): PFNGLGENFENCESNVPROC = CFuncPtr.fromPtr(ptr.asInstanceOf[Ptr[Byte]])
    inline def apply(inline o: CFuncPtr2[GLsizei, Ptr[GLuint], Unit]): PFNGLGENFENCESNVPROC = o
    extension (v: PFNGLGENFENCESNVPROC)
      inline def value: CFuncPtr2[GLsizei, Ptr[GLuint], Unit] = v
      inline def toPtr: Ptr[?] = CFuncPtr.toPtr(v)

  opaque type PFNGLGENFRAGMENTSHADERSATIPROC = CFuncPtr1[GLuint, GLuint]
  object PFNGLGENFRAGMENTSHADERSATIPROC:
    given _tag: Tag[PFNGLGENFRAGMENTSHADERSATIPROC] = Tag.materializeCFuncPtr1[GLuint, GLuint]
    inline def fromPtr(ptr: Ptr[Byte] | Ptr[?]): PFNGLGENFRAGMENTSHADERSATIPROC = CFuncPtr.fromPtr(ptr.asInstanceOf[Ptr[Byte]])
    inline def apply(inline o: CFuncPtr1[GLuint, GLuint]): PFNGLGENFRAGMENTSHADERSATIPROC = o
    extension (v: PFNGLGENFRAGMENTSHADERSATIPROC)
      inline def value: CFuncPtr1[GLuint, GLuint] = v
      inline def toPtr: Ptr[?] = CFuncPtr.toPtr(v)

  opaque type PFNGLGENFRAMEBUFFERSEXTPROC = CFuncPtr2[GLsizei, Ptr[GLuint], Unit]
  object PFNGLGENFRAMEBUFFERSEXTPROC:
    given _tag: Tag[PFNGLGENFRAMEBUFFERSEXTPROC] = Tag.materializeCFuncPtr2[GLsizei, Ptr[GLuint], Unit]
    inline def fromPtr(ptr: Ptr[Byte] | Ptr[?]): PFNGLGENFRAMEBUFFERSEXTPROC = CFuncPtr.fromPtr(ptr.asInstanceOf[Ptr[Byte]])
    inline def apply(inline o: CFuncPtr2[GLsizei, Ptr[GLuint], Unit]): PFNGLGENFRAMEBUFFERSEXTPROC = o
    extension (v: PFNGLGENFRAMEBUFFERSEXTPROC)
      inline def value: CFuncPtr2[GLsizei, Ptr[GLuint], Unit] = v
      inline def toPtr: Ptr[?] = CFuncPtr.toPtr(v)

  opaque type PFNGLGENFRAMEBUFFERSOESPROC = CFuncPtr2[GLsizei, Ptr[GLuint], Unit]
  object PFNGLGENFRAMEBUFFERSOESPROC:
    given _tag: Tag[PFNGLGENFRAMEBUFFERSOESPROC] = Tag.materializeCFuncPtr2[GLsizei, Ptr[GLuint], Unit]
    inline def fromPtr(ptr: Ptr[Byte] | Ptr[?]): PFNGLGENFRAMEBUFFERSOESPROC = CFuncPtr.fromPtr(ptr.asInstanceOf[Ptr[Byte]])
    inline def apply(inline o: CFuncPtr2[GLsizei, Ptr[GLuint], Unit]): PFNGLGENFRAMEBUFFERSOESPROC = o
    extension (v: PFNGLGENFRAMEBUFFERSOESPROC)
      inline def value: CFuncPtr2[GLsizei, Ptr[GLuint], Unit] = v
      inline def toPtr: Ptr[?] = CFuncPtr.toPtr(v)

  opaque type PFNGLGENFRAMEBUFFERSPROC = CFuncPtr2[GLsizei, Ptr[GLuint], Unit]
  object PFNGLGENFRAMEBUFFERSPROC:
    given _tag: Tag[PFNGLGENFRAMEBUFFERSPROC] = Tag.materializeCFuncPtr2[GLsizei, Ptr[GLuint], Unit]
    inline def fromPtr(ptr: Ptr[Byte] | Ptr[?]): PFNGLGENFRAMEBUFFERSPROC = CFuncPtr.fromPtr(ptr.asInstanceOf[Ptr[Byte]])
    inline def apply(inline o: CFuncPtr2[GLsizei, Ptr[GLuint], Unit]): PFNGLGENFRAMEBUFFERSPROC = o
    extension (v: PFNGLGENFRAMEBUFFERSPROC)
      inline def value: CFuncPtr2[GLsizei, Ptr[GLuint], Unit] = v
      inline def toPtr: Ptr[?] = CFuncPtr.toPtr(v)

  opaque type PFNGLGENMPEGPREDICTORSSGIXPROC = CFuncPtr2[GLsizei, Ptr[GLuint], Unit]
  object PFNGLGENMPEGPREDICTORSSGIXPROC:
    given _tag: Tag[PFNGLGENMPEGPREDICTORSSGIXPROC] = Tag.materializeCFuncPtr2[GLsizei, Ptr[GLuint], Unit]
    inline def fromPtr(ptr: Ptr[Byte] | Ptr[?]): PFNGLGENMPEGPREDICTORSSGIXPROC = CFuncPtr.fromPtr(ptr.asInstanceOf[Ptr[Byte]])
    inline def apply(inline o: CFuncPtr2[GLsizei, Ptr[GLuint], Unit]): PFNGLGENMPEGPREDICTORSSGIXPROC = o
    extension (v: PFNGLGENMPEGPREDICTORSSGIXPROC)
      inline def value: CFuncPtr2[GLsizei, Ptr[GLuint], Unit] = v
      inline def toPtr: Ptr[?] = CFuncPtr.toPtr(v)

  opaque type PFNGLGENNAMESAMDPROC = CFuncPtr3[GLenum, GLuint, Ptr[GLuint], Unit]
  object PFNGLGENNAMESAMDPROC:
    given _tag: Tag[PFNGLGENNAMESAMDPROC] = Tag.materializeCFuncPtr3[GLenum, GLuint, Ptr[GLuint], Unit]
    inline def fromPtr(ptr: Ptr[Byte] | Ptr[?]): PFNGLGENNAMESAMDPROC = CFuncPtr.fromPtr(ptr.asInstanceOf[Ptr[Byte]])
    inline def apply(inline o: CFuncPtr3[GLenum, GLuint, Ptr[GLuint], Unit]): PFNGLGENNAMESAMDPROC = o
    extension (v: PFNGLGENNAMESAMDPROC)
      inline def value: CFuncPtr3[GLenum, GLuint, Ptr[GLuint], Unit] = v
      inline def toPtr: Ptr[?] = CFuncPtr.toPtr(v)

  opaque type PFNGLGENOCCLUSIONQUERIESNVPROC = CFuncPtr2[GLsizei, Ptr[GLuint], Unit]
  object PFNGLGENOCCLUSIONQUERIESNVPROC:
    given _tag: Tag[PFNGLGENOCCLUSIONQUERIESNVPROC] = Tag.materializeCFuncPtr2[GLsizei, Ptr[GLuint], Unit]
    inline def fromPtr(ptr: Ptr[Byte] | Ptr[?]): PFNGLGENOCCLUSIONQUERIESNVPROC = CFuncPtr.fromPtr(ptr.asInstanceOf[Ptr[Byte]])
    inline def apply(inline o: CFuncPtr2[GLsizei, Ptr[GLuint], Unit]): PFNGLGENOCCLUSIONQUERIESNVPROC = o
    extension (v: PFNGLGENOCCLUSIONQUERIESNVPROC)
      inline def value: CFuncPtr2[GLsizei, Ptr[GLuint], Unit] = v
      inline def toPtr: Ptr[?] = CFuncPtr.toPtr(v)

  opaque type PFNGLGENPATHSNVPROC = CFuncPtr1[GLsizei, GLuint]
  object PFNGLGENPATHSNVPROC:
    given _tag: Tag[PFNGLGENPATHSNVPROC] = Tag.materializeCFuncPtr1[GLsizei, GLuint]
    inline def fromPtr(ptr: Ptr[Byte] | Ptr[?]): PFNGLGENPATHSNVPROC = CFuncPtr.fromPtr(ptr.asInstanceOf[Ptr[Byte]])
    inline def apply(inline o: CFuncPtr1[GLsizei, GLuint]): PFNGLGENPATHSNVPROC = o
    extension (v: PFNGLGENPATHSNVPROC)
      inline def value: CFuncPtr1[GLsizei, GLuint] = v
      inline def toPtr: Ptr[?] = CFuncPtr.toPtr(v)

  opaque type PFNGLGENPERFMONITORSAMDPROC = CFuncPtr2[GLsizei, Ptr[GLuint], Unit]
  object PFNGLGENPERFMONITORSAMDPROC:
    given _tag: Tag[PFNGLGENPERFMONITORSAMDPROC] = Tag.materializeCFuncPtr2[GLsizei, Ptr[GLuint], Unit]
    inline def fromPtr(ptr: Ptr[Byte] | Ptr[?]): PFNGLGENPERFMONITORSAMDPROC = CFuncPtr.fromPtr(ptr.asInstanceOf[Ptr[Byte]])
    inline def apply(inline o: CFuncPtr2[GLsizei, Ptr[GLuint], Unit]): PFNGLGENPERFMONITORSAMDPROC = o
    extension (v: PFNGLGENPERFMONITORSAMDPROC)
      inline def value: CFuncPtr2[GLsizei, Ptr[GLuint], Unit] = v
      inline def toPtr: Ptr[?] = CFuncPtr.toPtr(v)

  opaque type PFNGLGENPROGRAMPIPELINESPROC = CFuncPtr2[GLsizei, Ptr[GLuint], Unit]
  object PFNGLGENPROGRAMPIPELINESPROC:
    given _tag: Tag[PFNGLGENPROGRAMPIPELINESPROC] = Tag.materializeCFuncPtr2[GLsizei, Ptr[GLuint], Unit]
    inline def fromPtr(ptr: Ptr[Byte] | Ptr[?]): PFNGLGENPROGRAMPIPELINESPROC = CFuncPtr.fromPtr(ptr.asInstanceOf[Ptr[Byte]])
    inline def apply(inline o: CFuncPtr2[GLsizei, Ptr[GLuint], Unit]): PFNGLGENPROGRAMPIPELINESPROC = o
    extension (v: PFNGLGENPROGRAMPIPELINESPROC)
      inline def value: CFuncPtr2[GLsizei, Ptr[GLuint], Unit] = v
      inline def toPtr: Ptr[?] = CFuncPtr.toPtr(v)

  opaque type PFNGLGENPROGRAMSARBPROC = CFuncPtr2[GLsizei, Ptr[GLuint], Unit]
  object PFNGLGENPROGRAMSARBPROC:
    given _tag: Tag[PFNGLGENPROGRAMSARBPROC] = Tag.materializeCFuncPtr2[GLsizei, Ptr[GLuint], Unit]
    inline def fromPtr(ptr: Ptr[Byte] | Ptr[?]): PFNGLGENPROGRAMSARBPROC = CFuncPtr.fromPtr(ptr.asInstanceOf[Ptr[Byte]])
    inline def apply(inline o: CFuncPtr2[GLsizei, Ptr[GLuint], Unit]): PFNGLGENPROGRAMSARBPROC = o
    extension (v: PFNGLGENPROGRAMSARBPROC)
      inline def value: CFuncPtr2[GLsizei, Ptr[GLuint], Unit] = v
      inline def toPtr: Ptr[?] = CFuncPtr.toPtr(v)

  opaque type PFNGLGENPROGRAMSNVPROC = CFuncPtr2[GLsizei, Ptr[GLuint], Unit]
  object PFNGLGENPROGRAMSNVPROC:
    given _tag: Tag[PFNGLGENPROGRAMSNVPROC] = Tag.materializeCFuncPtr2[GLsizei, Ptr[GLuint], Unit]
    inline def fromPtr(ptr: Ptr[Byte] | Ptr[?]): PFNGLGENPROGRAMSNVPROC = CFuncPtr.fromPtr(ptr.asInstanceOf[Ptr[Byte]])
    inline def apply(inline o: CFuncPtr2[GLsizei, Ptr[GLuint], Unit]): PFNGLGENPROGRAMSNVPROC = o
    extension (v: PFNGLGENPROGRAMSNVPROC)
      inline def value: CFuncPtr2[GLsizei, Ptr[GLuint], Unit] = v
      inline def toPtr: Ptr[?] = CFuncPtr.toPtr(v)

  opaque type PFNGLGENQUERIESANGLEPROC = CFuncPtr2[GLsizei, Ptr[GLuint], Unit]
  object PFNGLGENQUERIESANGLEPROC:
    given _tag: Tag[PFNGLGENQUERIESANGLEPROC] = Tag.materializeCFuncPtr2[GLsizei, Ptr[GLuint], Unit]
    inline def fromPtr(ptr: Ptr[Byte] | Ptr[?]): PFNGLGENQUERIESANGLEPROC = CFuncPtr.fromPtr(ptr.asInstanceOf[Ptr[Byte]])
    inline def apply(inline o: CFuncPtr2[GLsizei, Ptr[GLuint], Unit]): PFNGLGENQUERIESANGLEPROC = o
    extension (v: PFNGLGENQUERIESANGLEPROC)
      inline def value: CFuncPtr2[GLsizei, Ptr[GLuint], Unit] = v
      inline def toPtr: Ptr[?] = CFuncPtr.toPtr(v)

  opaque type PFNGLGENQUERIESARBPROC = CFuncPtr2[GLsizei, Ptr[GLuint], Unit]
  object PFNGLGENQUERIESARBPROC:
    given _tag: Tag[PFNGLGENQUERIESARBPROC] = Tag.materializeCFuncPtr2[GLsizei, Ptr[GLuint], Unit]
    inline def fromPtr(ptr: Ptr[Byte] | Ptr[?]): PFNGLGENQUERIESARBPROC = CFuncPtr.fromPtr(ptr.asInstanceOf[Ptr[Byte]])
    inline def apply(inline o: CFuncPtr2[GLsizei, Ptr[GLuint], Unit]): PFNGLGENQUERIESARBPROC = o
    extension (v: PFNGLGENQUERIESARBPROC)
      inline def value: CFuncPtr2[GLsizei, Ptr[GLuint], Unit] = v
      inline def toPtr: Ptr[?] = CFuncPtr.toPtr(v)

  opaque type PFNGLGENQUERIESEXTPROC = CFuncPtr2[GLsizei, Ptr[GLuint], Unit]
  object PFNGLGENQUERIESEXTPROC:
    given _tag: Tag[PFNGLGENQUERIESEXTPROC] = Tag.materializeCFuncPtr2[GLsizei, Ptr[GLuint], Unit]
    inline def fromPtr(ptr: Ptr[Byte] | Ptr[?]): PFNGLGENQUERIESEXTPROC = CFuncPtr.fromPtr(ptr.asInstanceOf[Ptr[Byte]])
    inline def apply(inline o: CFuncPtr2[GLsizei, Ptr[GLuint], Unit]): PFNGLGENQUERIESEXTPROC = o
    extension (v: PFNGLGENQUERIESEXTPROC)
      inline def value: CFuncPtr2[GLsizei, Ptr[GLuint], Unit] = v
      inline def toPtr: Ptr[?] = CFuncPtr.toPtr(v)

  opaque type PFNGLGENQUERIESPROC = CFuncPtr2[GLsizei, Ptr[GLuint], Unit]
  object PFNGLGENQUERIESPROC:
    given _tag: Tag[PFNGLGENQUERIESPROC] = Tag.materializeCFuncPtr2[GLsizei, Ptr[GLuint], Unit]
    inline def fromPtr(ptr: Ptr[Byte] | Ptr[?]): PFNGLGENQUERIESPROC = CFuncPtr.fromPtr(ptr.asInstanceOf[Ptr[Byte]])
    inline def apply(inline o: CFuncPtr2[GLsizei, Ptr[GLuint], Unit]): PFNGLGENQUERIESPROC = o
    extension (v: PFNGLGENQUERIESPROC)
      inline def value: CFuncPtr2[GLsizei, Ptr[GLuint], Unit] = v
      inline def toPtr: Ptr[?] = CFuncPtr.toPtr(v)

  opaque type PFNGLGENRENDERBUFFERSEXTPROC = CFuncPtr2[GLsizei, Ptr[GLuint], Unit]
  object PFNGLGENRENDERBUFFERSEXTPROC:
    given _tag: Tag[PFNGLGENRENDERBUFFERSEXTPROC] = Tag.materializeCFuncPtr2[GLsizei, Ptr[GLuint], Unit]
    inline def fromPtr(ptr: Ptr[Byte] | Ptr[?]): PFNGLGENRENDERBUFFERSEXTPROC = CFuncPtr.fromPtr(ptr.asInstanceOf[Ptr[Byte]])
    inline def apply(inline o: CFuncPtr2[GLsizei, Ptr[GLuint], Unit]): PFNGLGENRENDERBUFFERSEXTPROC = o
    extension (v: PFNGLGENRENDERBUFFERSEXTPROC)
      inline def value: CFuncPtr2[GLsizei, Ptr[GLuint], Unit] = v
      inline def toPtr: Ptr[?] = CFuncPtr.toPtr(v)

  opaque type PFNGLGENRENDERBUFFERSOESPROC = CFuncPtr2[GLsizei, Ptr[GLuint], Unit]
  object PFNGLGENRENDERBUFFERSOESPROC:
    given _tag: Tag[PFNGLGENRENDERBUFFERSOESPROC] = Tag.materializeCFuncPtr2[GLsizei, Ptr[GLuint], Unit]
    inline def fromPtr(ptr: Ptr[Byte] | Ptr[?]): PFNGLGENRENDERBUFFERSOESPROC = CFuncPtr.fromPtr(ptr.asInstanceOf[Ptr[Byte]])
    inline def apply(inline o: CFuncPtr2[GLsizei, Ptr[GLuint], Unit]): PFNGLGENRENDERBUFFERSOESPROC = o
    extension (v: PFNGLGENRENDERBUFFERSOESPROC)
      inline def value: CFuncPtr2[GLsizei, Ptr[GLuint], Unit] = v
      inline def toPtr: Ptr[?] = CFuncPtr.toPtr(v)

  opaque type PFNGLGENRENDERBUFFERSPROC = CFuncPtr2[GLsizei, Ptr[GLuint], Unit]
  object PFNGLGENRENDERBUFFERSPROC:
    given _tag: Tag[PFNGLGENRENDERBUFFERSPROC] = Tag.materializeCFuncPtr2[GLsizei, Ptr[GLuint], Unit]
    inline def fromPtr(ptr: Ptr[Byte] | Ptr[?]): PFNGLGENRENDERBUFFERSPROC = CFuncPtr.fromPtr(ptr.asInstanceOf[Ptr[Byte]])
    inline def apply(inline o: CFuncPtr2[GLsizei, Ptr[GLuint], Unit]): PFNGLGENRENDERBUFFERSPROC = o
    extension (v: PFNGLGENRENDERBUFFERSPROC)
      inline def value: CFuncPtr2[GLsizei, Ptr[GLuint], Unit] = v
      inline def toPtr: Ptr[?] = CFuncPtr.toPtr(v)

  opaque type PFNGLGENSAMPLERSPROC = CFuncPtr2[GLsizei, Ptr[GLuint], Unit]
  object PFNGLGENSAMPLERSPROC:
    given _tag: Tag[PFNGLGENSAMPLERSPROC] = Tag.materializeCFuncPtr2[GLsizei, Ptr[GLuint], Unit]
    inline def fromPtr(ptr: Ptr[Byte] | Ptr[?]): PFNGLGENSAMPLERSPROC = CFuncPtr.fromPtr(ptr.asInstanceOf[Ptr[Byte]])
    inline def apply(inline o: CFuncPtr2[GLsizei, Ptr[GLuint], Unit]): PFNGLGENSAMPLERSPROC = o
    extension (v: PFNGLGENSAMPLERSPROC)
      inline def value: CFuncPtr2[GLsizei, Ptr[GLuint], Unit] = v
      inline def toPtr: Ptr[?] = CFuncPtr.toPtr(v)

  opaque type PFNGLGENSEMAPHORESEXTPROC = CFuncPtr2[GLsizei, Ptr[GLuint], Unit]
  object PFNGLGENSEMAPHORESEXTPROC:
    given _tag: Tag[PFNGLGENSEMAPHORESEXTPROC] = Tag.materializeCFuncPtr2[GLsizei, Ptr[GLuint], Unit]
    inline def fromPtr(ptr: Ptr[Byte] | Ptr[?]): PFNGLGENSEMAPHORESEXTPROC = CFuncPtr.fromPtr(ptr.asInstanceOf[Ptr[Byte]])
    inline def apply(inline o: CFuncPtr2[GLsizei, Ptr[GLuint], Unit]): PFNGLGENSEMAPHORESEXTPROC = o
    extension (v: PFNGLGENSEMAPHORESEXTPROC)
      inline def value: CFuncPtr2[GLsizei, Ptr[GLuint], Unit] = v
      inline def toPtr: Ptr[?] = CFuncPtr.toPtr(v)

  opaque type PFNGLGENSYMBOLSEXTPROC = CFuncPtr4[GLenum, GLenum, GLenum, GLuint, GLuint]
  object PFNGLGENSYMBOLSEXTPROC:
    given _tag: Tag[PFNGLGENSYMBOLSEXTPROC] = Tag.materializeCFuncPtr4[GLenum, GLenum, GLenum, GLuint, GLuint]
    inline def fromPtr(ptr: Ptr[Byte] | Ptr[?]): PFNGLGENSYMBOLSEXTPROC = CFuncPtr.fromPtr(ptr.asInstanceOf[Ptr[Byte]])
    inline def apply(inline o: CFuncPtr4[GLenum, GLenum, GLenum, GLuint, GLuint]): PFNGLGENSYMBOLSEXTPROC = o
    extension (v: PFNGLGENSYMBOLSEXTPROC)
      inline def value: CFuncPtr4[GLenum, GLenum, GLenum, GLuint, GLuint] = v
      inline def toPtr: Ptr[?] = CFuncPtr.toPtr(v)

  opaque type PFNGLGENTEXTURESEXTPROC = CFuncPtr2[GLsizei, Ptr[GLuint], Unit]
  object PFNGLGENTEXTURESEXTPROC:
    given _tag: Tag[PFNGLGENTEXTURESEXTPROC] = Tag.materializeCFuncPtr2[GLsizei, Ptr[GLuint], Unit]
    inline def fromPtr(ptr: Ptr[Byte] | Ptr[?]): PFNGLGENTEXTURESEXTPROC = CFuncPtr.fromPtr(ptr.asInstanceOf[Ptr[Byte]])
    inline def apply(inline o: CFuncPtr2[GLsizei, Ptr[GLuint], Unit]): PFNGLGENTEXTURESEXTPROC = o
    extension (v: PFNGLGENTEXTURESEXTPROC)
      inline def value: CFuncPtr2[GLsizei, Ptr[GLuint], Unit] = v
      inline def toPtr: Ptr[?] = CFuncPtr.toPtr(v)

  opaque type PFNGLGENTRANSFORMFEEDBACKSNVPROC = CFuncPtr2[GLsizei, Ptr[GLuint], Unit]
  object PFNGLGENTRANSFORMFEEDBACKSNVPROC:
    given _tag: Tag[PFNGLGENTRANSFORMFEEDBACKSNVPROC] = Tag.materializeCFuncPtr2[GLsizei, Ptr[GLuint], Unit]
    inline def fromPtr(ptr: Ptr[Byte] | Ptr[?]): PFNGLGENTRANSFORMFEEDBACKSNVPROC = CFuncPtr.fromPtr(ptr.asInstanceOf[Ptr[Byte]])
    inline def apply(inline o: CFuncPtr2[GLsizei, Ptr[GLuint], Unit]): PFNGLGENTRANSFORMFEEDBACKSNVPROC = o
    extension (v: PFNGLGENTRANSFORMFEEDBACKSNVPROC)
      inline def value: CFuncPtr2[GLsizei, Ptr[GLuint], Unit] = v
      inline def toPtr: Ptr[?] = CFuncPtr.toPtr(v)

  opaque type PFNGLGENTRANSFORMFEEDBACKSPROC = CFuncPtr2[GLsizei, Ptr[GLuint], Unit]
  object PFNGLGENTRANSFORMFEEDBACKSPROC:
    given _tag: Tag[PFNGLGENTRANSFORMFEEDBACKSPROC] = Tag.materializeCFuncPtr2[GLsizei, Ptr[GLuint], Unit]
    inline def fromPtr(ptr: Ptr[Byte] | Ptr[?]): PFNGLGENTRANSFORMFEEDBACKSPROC = CFuncPtr.fromPtr(ptr.asInstanceOf[Ptr[Byte]])
    inline def apply(inline o: CFuncPtr2[GLsizei, Ptr[GLuint], Unit]): PFNGLGENTRANSFORMFEEDBACKSPROC = o
    extension (v: PFNGLGENTRANSFORMFEEDBACKSPROC)
      inline def value: CFuncPtr2[GLsizei, Ptr[GLuint], Unit] = v
      inline def toPtr: Ptr[?] = CFuncPtr.toPtr(v)

  opaque type PFNGLGENVERTEXARRAYSAPPLEPROC = CFuncPtr2[GLsizei, Ptr[GLuint], Unit]
  object PFNGLGENVERTEXARRAYSAPPLEPROC:
    given _tag: Tag[PFNGLGENVERTEXARRAYSAPPLEPROC] = Tag.materializeCFuncPtr2[GLsizei, Ptr[GLuint], Unit]
    inline def fromPtr(ptr: Ptr[Byte] | Ptr[?]): PFNGLGENVERTEXARRAYSAPPLEPROC = CFuncPtr.fromPtr(ptr.asInstanceOf[Ptr[Byte]])
    inline def apply(inline o: CFuncPtr2[GLsizei, Ptr[GLuint], Unit]): PFNGLGENVERTEXARRAYSAPPLEPROC = o
    extension (v: PFNGLGENVERTEXARRAYSAPPLEPROC)
      inline def value: CFuncPtr2[GLsizei, Ptr[GLuint], Unit] = v
      inline def toPtr: Ptr[?] = CFuncPtr.toPtr(v)

  opaque type PFNGLGENVERTEXARRAYSOESPROC = CFuncPtr2[GLsizei, Ptr[GLuint], Unit]
  object PFNGLGENVERTEXARRAYSOESPROC:
    given _tag: Tag[PFNGLGENVERTEXARRAYSOESPROC] = Tag.materializeCFuncPtr2[GLsizei, Ptr[GLuint], Unit]
    inline def fromPtr(ptr: Ptr[Byte] | Ptr[?]): PFNGLGENVERTEXARRAYSOESPROC = CFuncPtr.fromPtr(ptr.asInstanceOf[Ptr[Byte]])
    inline def apply(inline o: CFuncPtr2[GLsizei, Ptr[GLuint], Unit]): PFNGLGENVERTEXARRAYSOESPROC = o
    extension (v: PFNGLGENVERTEXARRAYSOESPROC)
      inline def value: CFuncPtr2[GLsizei, Ptr[GLuint], Unit] = v
      inline def toPtr: Ptr[?] = CFuncPtr.toPtr(v)

  opaque type PFNGLGENVERTEXARRAYSPROC = CFuncPtr2[GLsizei, Ptr[GLuint], Unit]
  object PFNGLGENVERTEXARRAYSPROC:
    given _tag: Tag[PFNGLGENVERTEXARRAYSPROC] = Tag.materializeCFuncPtr2[GLsizei, Ptr[GLuint], Unit]
    inline def fromPtr(ptr: Ptr[Byte] | Ptr[?]): PFNGLGENVERTEXARRAYSPROC = CFuncPtr.fromPtr(ptr.asInstanceOf[Ptr[Byte]])
    inline def apply(inline o: CFuncPtr2[GLsizei, Ptr[GLuint], Unit]): PFNGLGENVERTEXARRAYSPROC = o
    extension (v: PFNGLGENVERTEXARRAYSPROC)
      inline def value: CFuncPtr2[GLsizei, Ptr[GLuint], Unit] = v
      inline def toPtr: Ptr[?] = CFuncPtr.toPtr(v)

  opaque type PFNGLGENVERTEXARRAYSSGIXPROC = CFuncPtr2[GLsizei, Ptr[GLuint], Unit]
  object PFNGLGENVERTEXARRAYSSGIXPROC:
    given _tag: Tag[PFNGLGENVERTEXARRAYSSGIXPROC] = Tag.materializeCFuncPtr2[GLsizei, Ptr[GLuint], Unit]
    inline def fromPtr(ptr: Ptr[Byte] | Ptr[?]): PFNGLGENVERTEXARRAYSSGIXPROC = CFuncPtr.fromPtr(ptr.asInstanceOf[Ptr[Byte]])
    inline def apply(inline o: CFuncPtr2[GLsizei, Ptr[GLuint], Unit]): PFNGLGENVERTEXARRAYSSGIXPROC = o
    extension (v: PFNGLGENVERTEXARRAYSSGIXPROC)
      inline def value: CFuncPtr2[GLsizei, Ptr[GLuint], Unit] = v
      inline def toPtr: Ptr[?] = CFuncPtr.toPtr(v)

  opaque type PFNGLGENVERTEXSHADERSEXTPROC = CFuncPtr1[GLuint, GLuint]
  object PFNGLGENVERTEXSHADERSEXTPROC:
    given _tag: Tag[PFNGLGENVERTEXSHADERSEXTPROC] = Tag.materializeCFuncPtr1[GLuint, GLuint]
    inline def fromPtr(ptr: Ptr[Byte] | Ptr[?]): PFNGLGENVERTEXSHADERSEXTPROC = CFuncPtr.fromPtr(ptr.asInstanceOf[Ptr[Byte]])
    inline def apply(inline o: CFuncPtr1[GLuint, GLuint]): PFNGLGENVERTEXSHADERSEXTPROC = o
    extension (v: PFNGLGENVERTEXSHADERSEXTPROC)
      inline def value: CFuncPtr1[GLuint, GLuint] = v
      inline def toPtr: Ptr[?] = CFuncPtr.toPtr(v)

  opaque type PFNGLGETACTIVEATOMICCOUNTERBUFFERIVPROC = CFuncPtr4[GLuint, GLuint, GLenum, Ptr[GLint], Unit]
  object PFNGLGETACTIVEATOMICCOUNTERBUFFERIVPROC:
    given _tag: Tag[PFNGLGETACTIVEATOMICCOUNTERBUFFERIVPROC] = Tag.materializeCFuncPtr4[GLuint, GLuint, GLenum, Ptr[GLint], Unit]
    inline def fromPtr(ptr: Ptr[Byte] | Ptr[?]): PFNGLGETACTIVEATOMICCOUNTERBUFFERIVPROC = CFuncPtr.fromPtr(ptr.asInstanceOf[Ptr[Byte]])
    inline def apply(inline o: CFuncPtr4[GLuint, GLuint, GLenum, Ptr[GLint], Unit]): PFNGLGETACTIVEATOMICCOUNTERBUFFERIVPROC = o
    extension (v: PFNGLGETACTIVEATOMICCOUNTERBUFFERIVPROC)
      inline def value: CFuncPtr4[GLuint, GLuint, GLenum, Ptr[GLint], Unit] = v
      inline def toPtr: Ptr[?] = CFuncPtr.toPtr(v)

  opaque type PFNGLGETACTIVEATTRIBARBPROC = CFuncPtr7[GLhandleARB, GLuint, GLsizei, Ptr[GLsizei], Ptr[GLint], Ptr[GLenum], Ptr[GLcharARB], Unit]
  object PFNGLGETACTIVEATTRIBARBPROC:
    given _tag: Tag[PFNGLGETACTIVEATTRIBARBPROC] = Tag.materializeCFuncPtr7[GLhandleARB, GLuint, GLsizei, Ptr[GLsizei], Ptr[GLint], Ptr[GLenum], Ptr[GLcharARB], Unit]
    inline def fromPtr(ptr: Ptr[Byte] | Ptr[?]): PFNGLGETACTIVEATTRIBARBPROC = CFuncPtr.fromPtr(ptr.asInstanceOf[Ptr[Byte]])
    inline def apply(inline o: CFuncPtr7[GLhandleARB, GLuint, GLsizei, Ptr[GLsizei], Ptr[GLint], Ptr[GLenum], Ptr[GLcharARB], Unit]): PFNGLGETACTIVEATTRIBARBPROC = o
    extension (v: PFNGLGETACTIVEATTRIBARBPROC)
      inline def value: CFuncPtr7[GLhandleARB, GLuint, GLsizei, Ptr[GLsizei], Ptr[GLint], Ptr[GLenum], Ptr[GLcharARB], Unit] = v
      inline def toPtr: Ptr[?] = CFuncPtr.toPtr(v)

  opaque type PFNGLGETACTIVEATTRIBPROC = CFuncPtr7[GLuint, GLuint, GLsizei, Ptr[GLsizei], Ptr[GLint], Ptr[GLenum], Ptr[GLchar], Unit]
  object PFNGLGETACTIVEATTRIBPROC:
    given _tag: Tag[PFNGLGETACTIVEATTRIBPROC] = Tag.materializeCFuncPtr7[GLuint, GLuint, GLsizei, Ptr[GLsizei], Ptr[GLint], Ptr[GLenum], Ptr[GLchar], Unit]
    inline def fromPtr(ptr: Ptr[Byte] | Ptr[?]): PFNGLGETACTIVEATTRIBPROC = CFuncPtr.fromPtr(ptr.asInstanceOf[Ptr[Byte]])
    inline def apply(inline o: CFuncPtr7[GLuint, GLuint, GLsizei, Ptr[GLsizei], Ptr[GLint], Ptr[GLenum], Ptr[GLchar], Unit]): PFNGLGETACTIVEATTRIBPROC = o
    extension (v: PFNGLGETACTIVEATTRIBPROC)
      inline def value: CFuncPtr7[GLuint, GLuint, GLsizei, Ptr[GLsizei], Ptr[GLint], Ptr[GLenum], Ptr[GLchar], Unit] = v
      inline def toPtr: Ptr[?] = CFuncPtr.toPtr(v)

  opaque type PFNGLGETACTIVESUBROUTINENAMEPROC = CFuncPtr6[GLuint, GLenum, GLuint, GLsizei, Ptr[GLsizei], Ptr[GLchar], Unit]
  object PFNGLGETACTIVESUBROUTINENAMEPROC:
    given _tag: Tag[PFNGLGETACTIVESUBROUTINENAMEPROC] = Tag.materializeCFuncPtr6[GLuint, GLenum, GLuint, GLsizei, Ptr[GLsizei], Ptr[GLchar], Unit]
    inline def fromPtr(ptr: Ptr[Byte] | Ptr[?]): PFNGLGETACTIVESUBROUTINENAMEPROC = CFuncPtr.fromPtr(ptr.asInstanceOf[Ptr[Byte]])
    inline def apply(inline o: CFuncPtr6[GLuint, GLenum, GLuint, GLsizei, Ptr[GLsizei], Ptr[GLchar], Unit]): PFNGLGETACTIVESUBROUTINENAMEPROC = o
    extension (v: PFNGLGETACTIVESUBROUTINENAMEPROC)
      inline def value: CFuncPtr6[GLuint, GLenum, GLuint, GLsizei, Ptr[GLsizei], Ptr[GLchar], Unit] = v
      inline def toPtr: Ptr[?] = CFuncPtr.toPtr(v)

  opaque type PFNGLGETACTIVESUBROUTINEUNIFORMIVPROC = CFuncPtr5[GLuint, GLenum, GLuint, GLenum, Ptr[GLint], Unit]
  object PFNGLGETACTIVESUBROUTINEUNIFORMIVPROC:
    given _tag: Tag[PFNGLGETACTIVESUBROUTINEUNIFORMIVPROC] = Tag.materializeCFuncPtr5[GLuint, GLenum, GLuint, GLenum, Ptr[GLint], Unit]
    inline def fromPtr(ptr: Ptr[Byte] | Ptr[?]): PFNGLGETACTIVESUBROUTINEUNIFORMIVPROC = CFuncPtr.fromPtr(ptr.asInstanceOf[Ptr[Byte]])
    inline def apply(inline o: CFuncPtr5[GLuint, GLenum, GLuint, GLenum, Ptr[GLint], Unit]): PFNGLGETACTIVESUBROUTINEUNIFORMIVPROC = o
    extension (v: PFNGLGETACTIVESUBROUTINEUNIFORMIVPROC)
      inline def value: CFuncPtr5[GLuint, GLenum, GLuint, GLenum, Ptr[GLint], Unit] = v
      inline def toPtr: Ptr[?] = CFuncPtr.toPtr(v)

  opaque type PFNGLGETACTIVESUBROUTINEUNIFORMNAMEPROC = CFuncPtr6[GLuint, GLenum, GLuint, GLsizei, Ptr[GLsizei], Ptr[GLchar], Unit]
  object PFNGLGETACTIVESUBROUTINEUNIFORMNAMEPROC:
    given _tag: Tag[PFNGLGETACTIVESUBROUTINEUNIFORMNAMEPROC] = Tag.materializeCFuncPtr6[GLuint, GLenum, GLuint, GLsizei, Ptr[GLsizei], Ptr[GLchar], Unit]
    inline def fromPtr(ptr: Ptr[Byte] | Ptr[?]): PFNGLGETACTIVESUBROUTINEUNIFORMNAMEPROC = CFuncPtr.fromPtr(ptr.asInstanceOf[Ptr[Byte]])
    inline def apply(inline o: CFuncPtr6[GLuint, GLenum, GLuint, GLsizei, Ptr[GLsizei], Ptr[GLchar], Unit]): PFNGLGETACTIVESUBROUTINEUNIFORMNAMEPROC = o
    extension (v: PFNGLGETACTIVESUBROUTINEUNIFORMNAMEPROC)
      inline def value: CFuncPtr6[GLuint, GLenum, GLuint, GLsizei, Ptr[GLsizei], Ptr[GLchar], Unit] = v
      inline def toPtr: Ptr[?] = CFuncPtr.toPtr(v)

  opaque type PFNGLGETACTIVEUNIFORMARBPROC = CFuncPtr7[GLhandleARB, GLuint, GLsizei, Ptr[GLsizei], Ptr[GLint], Ptr[GLenum], Ptr[GLcharARB], Unit]
  object PFNGLGETACTIVEUNIFORMARBPROC:
    given _tag: Tag[PFNGLGETACTIVEUNIFORMARBPROC] = Tag.materializeCFuncPtr7[GLhandleARB, GLuint, GLsizei, Ptr[GLsizei], Ptr[GLint], Ptr[GLenum], Ptr[GLcharARB], Unit]
    inline def fromPtr(ptr: Ptr[Byte] | Ptr[?]): PFNGLGETACTIVEUNIFORMARBPROC = CFuncPtr.fromPtr(ptr.asInstanceOf[Ptr[Byte]])
    inline def apply(inline o: CFuncPtr7[GLhandleARB, GLuint, GLsizei, Ptr[GLsizei], Ptr[GLint], Ptr[GLenum], Ptr[GLcharARB], Unit]): PFNGLGETACTIVEUNIFORMARBPROC = o
    extension (v: PFNGLGETACTIVEUNIFORMARBPROC)
      inline def value: CFuncPtr7[GLhandleARB, GLuint, GLsizei, Ptr[GLsizei], Ptr[GLint], Ptr[GLenum], Ptr[GLcharARB], Unit] = v
      inline def toPtr: Ptr[?] = CFuncPtr.toPtr(v)

  opaque type PFNGLGETACTIVEUNIFORMBLOCKIVPROC = CFuncPtr4[GLuint, GLuint, GLenum, Ptr[GLint], Unit]
  object PFNGLGETACTIVEUNIFORMBLOCKIVPROC:
    given _tag: Tag[PFNGLGETACTIVEUNIFORMBLOCKIVPROC] = Tag.materializeCFuncPtr4[GLuint, GLuint, GLenum, Ptr[GLint], Unit]
    inline def fromPtr(ptr: Ptr[Byte] | Ptr[?]): PFNGLGETACTIVEUNIFORMBLOCKIVPROC = CFuncPtr.fromPtr(ptr.asInstanceOf[Ptr[Byte]])
    inline def apply(inline o: CFuncPtr4[GLuint, GLuint, GLenum, Ptr[GLint], Unit]): PFNGLGETACTIVEUNIFORMBLOCKIVPROC = o
    extension (v: PFNGLGETACTIVEUNIFORMBLOCKIVPROC)
      inline def value: CFuncPtr4[GLuint, GLuint, GLenum, Ptr[GLint], Unit] = v
      inline def toPtr: Ptr[?] = CFuncPtr.toPtr(v)

  opaque type PFNGLGETACTIVEUNIFORMBLOCKNAMEPROC = CFuncPtr5[GLuint, GLuint, GLsizei, Ptr[GLsizei], Ptr[GLchar], Unit]
  object PFNGLGETACTIVEUNIFORMBLOCKNAMEPROC:
    given _tag: Tag[PFNGLGETACTIVEUNIFORMBLOCKNAMEPROC] = Tag.materializeCFuncPtr5[GLuint, GLuint, GLsizei, Ptr[GLsizei], Ptr[GLchar], Unit]
    inline def fromPtr(ptr: Ptr[Byte] | Ptr[?]): PFNGLGETACTIVEUNIFORMBLOCKNAMEPROC = CFuncPtr.fromPtr(ptr.asInstanceOf[Ptr[Byte]])
    inline def apply(inline o: CFuncPtr5[GLuint, GLuint, GLsizei, Ptr[GLsizei], Ptr[GLchar], Unit]): PFNGLGETACTIVEUNIFORMBLOCKNAMEPROC = o
    extension (v: PFNGLGETACTIVEUNIFORMBLOCKNAMEPROC)
      inline def value: CFuncPtr5[GLuint, GLuint, GLsizei, Ptr[GLsizei], Ptr[GLchar], Unit] = v
      inline def toPtr: Ptr[?] = CFuncPtr.toPtr(v)

  opaque type PFNGLGETACTIVEUNIFORMNAMEPROC = CFuncPtr5[GLuint, GLuint, GLsizei, Ptr[GLsizei], Ptr[GLchar], Unit]
  object PFNGLGETACTIVEUNIFORMNAMEPROC:
    given _tag: Tag[PFNGLGETACTIVEUNIFORMNAMEPROC] = Tag.materializeCFuncPtr5[GLuint, GLuint, GLsizei, Ptr[GLsizei], Ptr[GLchar], Unit]
    inline def fromPtr(ptr: Ptr[Byte] | Ptr[?]): PFNGLGETACTIVEUNIFORMNAMEPROC = CFuncPtr.fromPtr(ptr.asInstanceOf[Ptr[Byte]])
    inline def apply(inline o: CFuncPtr5[GLuint, GLuint, GLsizei, Ptr[GLsizei], Ptr[GLchar], Unit]): PFNGLGETACTIVEUNIFORMNAMEPROC = o
    extension (v: PFNGLGETACTIVEUNIFORMNAMEPROC)
      inline def value: CFuncPtr5[GLuint, GLuint, GLsizei, Ptr[GLsizei], Ptr[GLchar], Unit] = v
      inline def toPtr: Ptr[?] = CFuncPtr.toPtr(v)

  opaque type PFNGLGETACTIVEUNIFORMPROC = CFuncPtr7[GLuint, GLuint, GLsizei, Ptr[GLsizei], Ptr[GLint], Ptr[GLenum], Ptr[GLchar], Unit]
  object PFNGLGETACTIVEUNIFORMPROC:
    given _tag: Tag[PFNGLGETACTIVEUNIFORMPROC] = Tag.materializeCFuncPtr7[GLuint, GLuint, GLsizei, Ptr[GLsizei], Ptr[GLint], Ptr[GLenum], Ptr[GLchar], Unit]
    inline def fromPtr(ptr: Ptr[Byte] | Ptr[?]): PFNGLGETACTIVEUNIFORMPROC = CFuncPtr.fromPtr(ptr.asInstanceOf[Ptr[Byte]])
    inline def apply(inline o: CFuncPtr7[GLuint, GLuint, GLsizei, Ptr[GLsizei], Ptr[GLint], Ptr[GLenum], Ptr[GLchar], Unit]): PFNGLGETACTIVEUNIFORMPROC = o
    extension (v: PFNGLGETACTIVEUNIFORMPROC)
      inline def value: CFuncPtr7[GLuint, GLuint, GLsizei, Ptr[GLsizei], Ptr[GLint], Ptr[GLenum], Ptr[GLchar], Unit] = v
      inline def toPtr: Ptr[?] = CFuncPtr.toPtr(v)

  opaque type PFNGLGETACTIVEUNIFORMSIVPROC = CFuncPtr5[GLuint, GLsizei, Ptr[GLuint], GLenum, Ptr[GLint], Unit]
  object PFNGLGETACTIVEUNIFORMSIVPROC:
    given _tag: Tag[PFNGLGETACTIVEUNIFORMSIVPROC] = Tag.materializeCFuncPtr5[GLuint, GLsizei, Ptr[GLuint], GLenum, Ptr[GLint], Unit]
    inline def fromPtr(ptr: Ptr[Byte] | Ptr[?]): PFNGLGETACTIVEUNIFORMSIVPROC = CFuncPtr.fromPtr(ptr.asInstanceOf[Ptr[Byte]])
    inline def apply(inline o: CFuncPtr5[GLuint, GLsizei, Ptr[GLuint], GLenum, Ptr[GLint], Unit]): PFNGLGETACTIVEUNIFORMSIVPROC = o
    extension (v: PFNGLGETACTIVEUNIFORMSIVPROC)
      inline def value: CFuncPtr5[GLuint, GLsizei, Ptr[GLuint], GLenum, Ptr[GLint], Unit] = v
      inline def toPtr: Ptr[?] = CFuncPtr.toPtr(v)

  opaque type PFNGLGETACTIVEVARYINGNVPROC = CFuncPtr7[GLuint, GLuint, GLsizei, Ptr[GLsizei], Ptr[GLsizei], Ptr[GLenum], Ptr[GLchar], Unit]
  object PFNGLGETACTIVEVARYINGNVPROC:
    given _tag: Tag[PFNGLGETACTIVEVARYINGNVPROC] = Tag.materializeCFuncPtr7[GLuint, GLuint, GLsizei, Ptr[GLsizei], Ptr[GLsizei], Ptr[GLenum], Ptr[GLchar], Unit]
    inline def fromPtr(ptr: Ptr[Byte] | Ptr[?]): PFNGLGETACTIVEVARYINGNVPROC = CFuncPtr.fromPtr(ptr.asInstanceOf[Ptr[Byte]])
    inline def apply(inline o: CFuncPtr7[GLuint, GLuint, GLsizei, Ptr[GLsizei], Ptr[GLsizei], Ptr[GLenum], Ptr[GLchar], Unit]): PFNGLGETACTIVEVARYINGNVPROC = o
    extension (v: PFNGLGETACTIVEVARYINGNVPROC)
      inline def value: CFuncPtr7[GLuint, GLuint, GLsizei, Ptr[GLsizei], Ptr[GLsizei], Ptr[GLenum], Ptr[GLchar], Unit] = v
      inline def toPtr: Ptr[?] = CFuncPtr.toPtr(v)

  opaque type PFNGLGETARRAYOBJECTFVATIPROC = CFuncPtr3[GLenum, GLenum, Ptr[GLfloat], Unit]
  object PFNGLGETARRAYOBJECTFVATIPROC:
    given _tag: Tag[PFNGLGETARRAYOBJECTFVATIPROC] = Tag.materializeCFuncPtr3[GLenum, GLenum, Ptr[GLfloat], Unit]
    inline def fromPtr(ptr: Ptr[Byte] | Ptr[?]): PFNGLGETARRAYOBJECTFVATIPROC = CFuncPtr.fromPtr(ptr.asInstanceOf[Ptr[Byte]])
    inline def apply(inline o: CFuncPtr3[GLenum, GLenum, Ptr[GLfloat], Unit]): PFNGLGETARRAYOBJECTFVATIPROC = o
    extension (v: PFNGLGETARRAYOBJECTFVATIPROC)
      inline def value: CFuncPtr3[GLenum, GLenum, Ptr[GLfloat], Unit] = v
      inline def toPtr: Ptr[?] = CFuncPtr.toPtr(v)

  opaque type PFNGLGETARRAYOBJECTIVATIPROC = CFuncPtr3[GLenum, GLenum, Ptr[GLint], Unit]
  object PFNGLGETARRAYOBJECTIVATIPROC:
    given _tag: Tag[PFNGLGETARRAYOBJECTIVATIPROC] = Tag.materializeCFuncPtr3[GLenum, GLenum, Ptr[GLint], Unit]
    inline def fromPtr(ptr: Ptr[Byte] | Ptr[?]): PFNGLGETARRAYOBJECTIVATIPROC = CFuncPtr.fromPtr(ptr.asInstanceOf[Ptr[Byte]])
    inline def apply(inline o: CFuncPtr3[GLenum, GLenum, Ptr[GLint], Unit]): PFNGLGETARRAYOBJECTIVATIPROC = o
    extension (v: PFNGLGETARRAYOBJECTIVATIPROC)
      inline def value: CFuncPtr3[GLenum, GLenum, Ptr[GLint], Unit] = v
      inline def toPtr: Ptr[?] = CFuncPtr.toPtr(v)

  opaque type PFNGLGETATTACHEDOBJECTSARBPROC = CFuncPtr4[GLhandleARB, GLsizei, Ptr[GLsizei], Ptr[GLhandleARB], Unit]
  object PFNGLGETATTACHEDOBJECTSARBPROC:
    given _tag: Tag[PFNGLGETATTACHEDOBJECTSARBPROC] = Tag.materializeCFuncPtr4[GLhandleARB, GLsizei, Ptr[GLsizei], Ptr[GLhandleARB], Unit]
    inline def fromPtr(ptr: Ptr[Byte] | Ptr[?]): PFNGLGETATTACHEDOBJECTSARBPROC = CFuncPtr.fromPtr(ptr.asInstanceOf[Ptr[Byte]])
    inline def apply(inline o: CFuncPtr4[GLhandleARB, GLsizei, Ptr[GLsizei], Ptr[GLhandleARB], Unit]): PFNGLGETATTACHEDOBJECTSARBPROC = o
    extension (v: PFNGLGETATTACHEDOBJECTSARBPROC)
      inline def value: CFuncPtr4[GLhandleARB, GLsizei, Ptr[GLsizei], Ptr[GLhandleARB], Unit] = v
      inline def toPtr: Ptr[?] = CFuncPtr.toPtr(v)

  opaque type PFNGLGETATTACHEDSHADERSPROC = CFuncPtr4[GLuint, GLsizei, Ptr[GLsizei], Ptr[GLuint], Unit]
  object PFNGLGETATTACHEDSHADERSPROC:
    given _tag: Tag[PFNGLGETATTACHEDSHADERSPROC] = Tag.materializeCFuncPtr4[GLuint, GLsizei, Ptr[GLsizei], Ptr[GLuint], Unit]
    inline def fromPtr(ptr: Ptr[Byte] | Ptr[?]): PFNGLGETATTACHEDSHADERSPROC = CFuncPtr.fromPtr(ptr.asInstanceOf[Ptr[Byte]])
    inline def apply(inline o: CFuncPtr4[GLuint, GLsizei, Ptr[GLsizei], Ptr[GLuint], Unit]): PFNGLGETATTACHEDSHADERSPROC = o
    extension (v: PFNGLGETATTACHEDSHADERSPROC)
      inline def value: CFuncPtr4[GLuint, GLsizei, Ptr[GLsizei], Ptr[GLuint], Unit] = v
      inline def toPtr: Ptr[?] = CFuncPtr.toPtr(v)

  opaque type PFNGLGETATTRIBLOCATIONARBPROC = CFuncPtr2[GLhandleARB, Ptr[GLcharARB], GLint]
  object PFNGLGETATTRIBLOCATIONARBPROC:
    given _tag: Tag[PFNGLGETATTRIBLOCATIONARBPROC] = Tag.materializeCFuncPtr2[GLhandleARB, Ptr[GLcharARB], GLint]
    inline def fromPtr(ptr: Ptr[Byte] | Ptr[?]): PFNGLGETATTRIBLOCATIONARBPROC = CFuncPtr.fromPtr(ptr.asInstanceOf[Ptr[Byte]])
    inline def apply(inline o: CFuncPtr2[GLhandleARB, Ptr[GLcharARB], GLint]): PFNGLGETATTRIBLOCATIONARBPROC = o
    extension (v: PFNGLGETATTRIBLOCATIONARBPROC)
      inline def value: CFuncPtr2[GLhandleARB, Ptr[GLcharARB], GLint] = v
      inline def toPtr: Ptr[?] = CFuncPtr.toPtr(v)

  opaque type PFNGLGETATTRIBLOCATIONPROC = CFuncPtr2[GLuint, Ptr[GLchar], GLint]
  object PFNGLGETATTRIBLOCATIONPROC:
    given _tag: Tag[PFNGLGETATTRIBLOCATIONPROC] = Tag.materializeCFuncPtr2[GLuint, Ptr[GLchar], GLint]
    inline def fromPtr(ptr: Ptr[Byte] | Ptr[?]): PFNGLGETATTRIBLOCATIONPROC = CFuncPtr.fromPtr(ptr.asInstanceOf[Ptr[Byte]])
    inline def apply(inline o: CFuncPtr2[GLuint, Ptr[GLchar], GLint]): PFNGLGETATTRIBLOCATIONPROC = o
    extension (v: PFNGLGETATTRIBLOCATIONPROC)
      inline def value: CFuncPtr2[GLuint, Ptr[GLchar], GLint] = v
      inline def toPtr: Ptr[?] = CFuncPtr.toPtr(v)

  opaque type PFNGLGETBOOLEANINDEXEDVEXTPROC = CFuncPtr3[GLenum, GLuint, Ptr[GLboolean], Unit]
  object PFNGLGETBOOLEANINDEXEDVEXTPROC:
    given _tag: Tag[PFNGLGETBOOLEANINDEXEDVEXTPROC] = Tag.materializeCFuncPtr3[GLenum, GLuint, Ptr[GLboolean], Unit]
    inline def fromPtr(ptr: Ptr[Byte] | Ptr[?]): PFNGLGETBOOLEANINDEXEDVEXTPROC = CFuncPtr.fromPtr(ptr.asInstanceOf[Ptr[Byte]])
    inline def apply(inline o: CFuncPtr3[GLenum, GLuint, Ptr[GLboolean], Unit]): PFNGLGETBOOLEANINDEXEDVEXTPROC = o
    extension (v: PFNGLGETBOOLEANINDEXEDVEXTPROC)
      inline def value: CFuncPtr3[GLenum, GLuint, Ptr[GLboolean], Unit] = v
      inline def toPtr: Ptr[?] = CFuncPtr.toPtr(v)

  opaque type PFNGLGETBOOLEANI_VPROC = CFuncPtr3[GLenum, GLuint, Ptr[GLboolean], Unit]
  object PFNGLGETBOOLEANI_VPROC:
    given _tag: Tag[PFNGLGETBOOLEANI_VPROC] = Tag.materializeCFuncPtr3[GLenum, GLuint, Ptr[GLboolean], Unit]
    inline def fromPtr(ptr: Ptr[Byte] | Ptr[?]): PFNGLGETBOOLEANI_VPROC = CFuncPtr.fromPtr(ptr.asInstanceOf[Ptr[Byte]])
    inline def apply(inline o: CFuncPtr3[GLenum, GLuint, Ptr[GLboolean], Unit]): PFNGLGETBOOLEANI_VPROC = o
    extension (v: PFNGLGETBOOLEANI_VPROC)
      inline def value: CFuncPtr3[GLenum, GLuint, Ptr[GLboolean], Unit] = v
      inline def toPtr: Ptr[?] = CFuncPtr.toPtr(v)

  opaque type PFNGLGETBUFFERPARAMETERI64VPROC = CFuncPtr3[GLenum, GLenum, Ptr[GLint64], Unit]
  object PFNGLGETBUFFERPARAMETERI64VPROC:
    given _tag: Tag[PFNGLGETBUFFERPARAMETERI64VPROC] = Tag.materializeCFuncPtr3[GLenum, GLenum, Ptr[GLint64], Unit]
    inline def fromPtr(ptr: Ptr[Byte] | Ptr[?]): PFNGLGETBUFFERPARAMETERI64VPROC = CFuncPtr.fromPtr(ptr.asInstanceOf[Ptr[Byte]])
    inline def apply(inline o: CFuncPtr3[GLenum, GLenum, Ptr[GLint64], Unit]): PFNGLGETBUFFERPARAMETERI64VPROC = o
    extension (v: PFNGLGETBUFFERPARAMETERI64VPROC)
      inline def value: CFuncPtr3[GLenum, GLenum, Ptr[GLint64], Unit] = v
      inline def toPtr: Ptr[?] = CFuncPtr.toPtr(v)

  opaque type PFNGLGETBUFFERPARAMETERIVARBPROC = CFuncPtr3[GLenum, GLenum, Ptr[GLint], Unit]
  object PFNGLGETBUFFERPARAMETERIVARBPROC:
    given _tag: Tag[PFNGLGETBUFFERPARAMETERIVARBPROC] = Tag.materializeCFuncPtr3[GLenum, GLenum, Ptr[GLint], Unit]
    inline def fromPtr(ptr: Ptr[Byte] | Ptr[?]): PFNGLGETBUFFERPARAMETERIVARBPROC = CFuncPtr.fromPtr(ptr.asInstanceOf[Ptr[Byte]])
    inline def apply(inline o: CFuncPtr3[GLenum, GLenum, Ptr[GLint], Unit]): PFNGLGETBUFFERPARAMETERIVARBPROC = o
    extension (v: PFNGLGETBUFFERPARAMETERIVARBPROC)
      inline def value: CFuncPtr3[GLenum, GLenum, Ptr[GLint], Unit] = v
      inline def toPtr: Ptr[?] = CFuncPtr.toPtr(v)

  opaque type PFNGLGETBUFFERPARAMETERIVPROC = CFuncPtr3[GLenum, GLenum, Ptr[GLint], Unit]
  object PFNGLGETBUFFERPARAMETERIVPROC:
    given _tag: Tag[PFNGLGETBUFFERPARAMETERIVPROC] = Tag.materializeCFuncPtr3[GLenum, GLenum, Ptr[GLint], Unit]
    inline def fromPtr(ptr: Ptr[Byte] | Ptr[?]): PFNGLGETBUFFERPARAMETERIVPROC = CFuncPtr.fromPtr(ptr.asInstanceOf[Ptr[Byte]])
    inline def apply(inline o: CFuncPtr3[GLenum, GLenum, Ptr[GLint], Unit]): PFNGLGETBUFFERPARAMETERIVPROC = o
    extension (v: PFNGLGETBUFFERPARAMETERIVPROC)
      inline def value: CFuncPtr3[GLenum, GLenum, Ptr[GLint], Unit] = v
      inline def toPtr: Ptr[?] = CFuncPtr.toPtr(v)

  opaque type PFNGLGETBUFFERPARAMETERUI64VNVPROC = CFuncPtr3[GLenum, GLenum, Ptr[GLuint64EXT], Unit]
  object PFNGLGETBUFFERPARAMETERUI64VNVPROC:
    given _tag: Tag[PFNGLGETBUFFERPARAMETERUI64VNVPROC] = Tag.materializeCFuncPtr3[GLenum, GLenum, Ptr[GLuint64EXT], Unit]
    inline def fromPtr(ptr: Ptr[Byte] | Ptr[?]): PFNGLGETBUFFERPARAMETERUI64VNVPROC = CFuncPtr.fromPtr(ptr.asInstanceOf[Ptr[Byte]])
    inline def apply(inline o: CFuncPtr3[GLenum, GLenum, Ptr[GLuint64EXT], Unit]): PFNGLGETBUFFERPARAMETERUI64VNVPROC = o
    extension (v: PFNGLGETBUFFERPARAMETERUI64VNVPROC)
      inline def value: CFuncPtr3[GLenum, GLenum, Ptr[GLuint64EXT], Unit] = v
      inline def toPtr: Ptr[?] = CFuncPtr.toPtr(v)

  opaque type PFNGLGETBUFFERPOINTERVARBPROC = CFuncPtr3[GLenum, GLenum, Ptr[Ptr[Byte]], Unit]
  object PFNGLGETBUFFERPOINTERVARBPROC:
    given _tag: Tag[PFNGLGETBUFFERPOINTERVARBPROC] = Tag.materializeCFuncPtr3[GLenum, GLenum, Ptr[Ptr[Byte]], Unit]
    inline def fromPtr(ptr: Ptr[Byte] | Ptr[?]): PFNGLGETBUFFERPOINTERVARBPROC = CFuncPtr.fromPtr(ptr.asInstanceOf[Ptr[Byte]])
    inline def apply(inline o: CFuncPtr3[GLenum, GLenum, Ptr[Ptr[Byte]], Unit]): PFNGLGETBUFFERPOINTERVARBPROC = o
    extension (v: PFNGLGETBUFFERPOINTERVARBPROC)
      inline def value: CFuncPtr3[GLenum, GLenum, Ptr[Ptr[Byte]], Unit] = v
      inline def toPtr: Ptr[?] = CFuncPtr.toPtr(v)

  opaque type PFNGLGETBUFFERPOINTERVOESPROC = CFuncPtr3[GLenum, GLenum, Ptr[Ptr[Byte]], Unit]
  object PFNGLGETBUFFERPOINTERVOESPROC:
    given _tag: Tag[PFNGLGETBUFFERPOINTERVOESPROC] = Tag.materializeCFuncPtr3[GLenum, GLenum, Ptr[Ptr[Byte]], Unit]
    inline def fromPtr(ptr: Ptr[Byte] | Ptr[?]): PFNGLGETBUFFERPOINTERVOESPROC = CFuncPtr.fromPtr(ptr.asInstanceOf[Ptr[Byte]])
    inline def apply(inline o: CFuncPtr3[GLenum, GLenum, Ptr[Ptr[Byte]], Unit]): PFNGLGETBUFFERPOINTERVOESPROC = o
    extension (v: PFNGLGETBUFFERPOINTERVOESPROC)
      inline def value: CFuncPtr3[GLenum, GLenum, Ptr[Ptr[Byte]], Unit] = v
      inline def toPtr: Ptr[?] = CFuncPtr.toPtr(v)

  opaque type PFNGLGETBUFFERPOINTERVPROC = CFuncPtr3[GLenum, GLenum, Ptr[Ptr[Byte]], Unit]
  object PFNGLGETBUFFERPOINTERVPROC:
    given _tag: Tag[PFNGLGETBUFFERPOINTERVPROC] = Tag.materializeCFuncPtr3[GLenum, GLenum, Ptr[Ptr[Byte]], Unit]
    inline def fromPtr(ptr: Ptr[Byte] | Ptr[?]): PFNGLGETBUFFERPOINTERVPROC = CFuncPtr.fromPtr(ptr.asInstanceOf[Ptr[Byte]])
    inline def apply(inline o: CFuncPtr3[GLenum, GLenum, Ptr[Ptr[Byte]], Unit]): PFNGLGETBUFFERPOINTERVPROC = o
    extension (v: PFNGLGETBUFFERPOINTERVPROC)
      inline def value: CFuncPtr3[GLenum, GLenum, Ptr[Ptr[Byte]], Unit] = v
      inline def toPtr: Ptr[?] = CFuncPtr.toPtr(v)

  opaque type PFNGLGETBUFFERSUBDATAARBPROC = CFuncPtr4[GLenum, GLintptrARB, GLsizeiptrARB, Ptr[Byte], Unit]
  object PFNGLGETBUFFERSUBDATAARBPROC:
    given _tag: Tag[PFNGLGETBUFFERSUBDATAARBPROC] = Tag.materializeCFuncPtr4[GLenum, GLintptrARB, GLsizeiptrARB, Ptr[Byte], Unit]
    inline def fromPtr(ptr: Ptr[Byte] | Ptr[?]): PFNGLGETBUFFERSUBDATAARBPROC = CFuncPtr.fromPtr(ptr.asInstanceOf[Ptr[Byte]])
    inline def apply(inline o: CFuncPtr4[GLenum, GLintptrARB, GLsizeiptrARB, Ptr[Byte], Unit]): PFNGLGETBUFFERSUBDATAARBPROC = o
    extension (v: PFNGLGETBUFFERSUBDATAARBPROC)
      inline def value: CFuncPtr4[GLenum, GLintptrARB, GLsizeiptrARB, Ptr[Byte], Unit] = v
      inline def toPtr: Ptr[?] = CFuncPtr.toPtr(v)

  opaque type PFNGLGETBUFFERSUBDATAPROC = CFuncPtr4[GLenum, GLintptr, GLsizeiptr, Ptr[Byte], Unit]
  object PFNGLGETBUFFERSUBDATAPROC:
    given _tag: Tag[PFNGLGETBUFFERSUBDATAPROC] = Tag.materializeCFuncPtr4[GLenum, GLintptr, GLsizeiptr, Ptr[Byte], Unit]
    inline def fromPtr(ptr: Ptr[Byte] | Ptr[?]): PFNGLGETBUFFERSUBDATAPROC = CFuncPtr.fromPtr(ptr.asInstanceOf[Ptr[Byte]])
    inline def apply(inline o: CFuncPtr4[GLenum, GLintptr, GLsizeiptr, Ptr[Byte], Unit]): PFNGLGETBUFFERSUBDATAPROC = o
    extension (v: PFNGLGETBUFFERSUBDATAPROC)
      inline def value: CFuncPtr4[GLenum, GLintptr, GLsizeiptr, Ptr[Byte], Unit] = v
      inline def toPtr: Ptr[?] = CFuncPtr.toPtr(v)

  opaque type PFNGLGETCLIPPLANEFOESPROC = CFuncPtr2[GLenum, Ptr[GLfloat], Unit]
  object PFNGLGETCLIPPLANEFOESPROC:
    given _tag: Tag[PFNGLGETCLIPPLANEFOESPROC] = Tag.materializeCFuncPtr2[GLenum, Ptr[GLfloat], Unit]
    inline def fromPtr(ptr: Ptr[Byte] | Ptr[?]): PFNGLGETCLIPPLANEFOESPROC = CFuncPtr.fromPtr(ptr.asInstanceOf[Ptr[Byte]])
    inline def apply(inline o: CFuncPtr2[GLenum, Ptr[GLfloat], Unit]): PFNGLGETCLIPPLANEFOESPROC = o
    extension (v: PFNGLGETCLIPPLANEFOESPROC)
      inline def value: CFuncPtr2[GLenum, Ptr[GLfloat], Unit] = v
      inline def toPtr: Ptr[?] = CFuncPtr.toPtr(v)

  opaque type PFNGLGETCLIPPLANEFPROC = CFuncPtr2[GLenum, CArray[GLfloat, Nat._4], Unit]
  object PFNGLGETCLIPPLANEFPROC:
    given _tag: Tag[PFNGLGETCLIPPLANEFPROC] = Tag.materializeCFuncPtr2[GLenum, CArray[GLfloat, Nat._4], Unit]
    inline def fromPtr(ptr: Ptr[Byte] | Ptr[?]): PFNGLGETCLIPPLANEFPROC = CFuncPtr.fromPtr(ptr.asInstanceOf[Ptr[Byte]])
    inline def apply(inline o: CFuncPtr2[GLenum, CArray[GLfloat, Nat._4], Unit]): PFNGLGETCLIPPLANEFPROC = o
    extension (v: PFNGLGETCLIPPLANEFPROC)
      inline def value: CFuncPtr2[GLenum, CArray[GLfloat, Nat._4], Unit] = v
      inline def toPtr: Ptr[?] = CFuncPtr.toPtr(v)

  opaque type PFNGLGETCLIPPLANEXPROC = CFuncPtr2[GLenum, CArray[GLfixed, Nat._4], Unit]
  object PFNGLGETCLIPPLANEXPROC:
    given _tag: Tag[PFNGLGETCLIPPLANEXPROC] = Tag.materializeCFuncPtr2[GLenum, CArray[GLfixed, Nat._4], Unit]
    inline def fromPtr(ptr: Ptr[Byte] | Ptr[?]): PFNGLGETCLIPPLANEXPROC = CFuncPtr.fromPtr(ptr.asInstanceOf[Ptr[Byte]])
    inline def apply(inline o: CFuncPtr2[GLenum, CArray[GLfixed, Nat._4], Unit]): PFNGLGETCLIPPLANEXPROC = o
    extension (v: PFNGLGETCLIPPLANEXPROC)
      inline def value: CFuncPtr2[GLenum, CArray[GLfixed, Nat._4], Unit] = v
      inline def toPtr: Ptr[?] = CFuncPtr.toPtr(v)

  opaque type PFNGLGETCOLORTABLEEXTPROC = CFuncPtr4[GLenum, GLenum, GLenum, Ptr[Byte], Unit]
  object PFNGLGETCOLORTABLEEXTPROC:
    given _tag: Tag[PFNGLGETCOLORTABLEEXTPROC] = Tag.materializeCFuncPtr4[GLenum, GLenum, GLenum, Ptr[Byte], Unit]
    inline def fromPtr(ptr: Ptr[Byte] | Ptr[?]): PFNGLGETCOLORTABLEEXTPROC = CFuncPtr.fromPtr(ptr.asInstanceOf[Ptr[Byte]])
    inline def apply(inline o: CFuncPtr4[GLenum, GLenum, GLenum, Ptr[Byte], Unit]): PFNGLGETCOLORTABLEEXTPROC = o
    extension (v: PFNGLGETCOLORTABLEEXTPROC)
      inline def value: CFuncPtr4[GLenum, GLenum, GLenum, Ptr[Byte], Unit] = v
      inline def toPtr: Ptr[?] = CFuncPtr.toPtr(v)

  opaque type PFNGLGETCOLORTABLEPARAMETERFVEXTPROC = CFuncPtr3[GLenum, GLenum, Ptr[GLfloat], Unit]
  object PFNGLGETCOLORTABLEPARAMETERFVEXTPROC:
    given _tag: Tag[PFNGLGETCOLORTABLEPARAMETERFVEXTPROC] = Tag.materializeCFuncPtr3[GLenum, GLenum, Ptr[GLfloat], Unit]
    inline def fromPtr(ptr: Ptr[Byte] | Ptr[?]): PFNGLGETCOLORTABLEPARAMETERFVEXTPROC = CFuncPtr.fromPtr(ptr.asInstanceOf[Ptr[Byte]])
    inline def apply(inline o: CFuncPtr3[GLenum, GLenum, Ptr[GLfloat], Unit]): PFNGLGETCOLORTABLEPARAMETERFVEXTPROC = o
    extension (v: PFNGLGETCOLORTABLEPARAMETERFVEXTPROC)
      inline def value: CFuncPtr3[GLenum, GLenum, Ptr[GLfloat], Unit] = v
      inline def toPtr: Ptr[?] = CFuncPtr.toPtr(v)

  opaque type PFNGLGETCOLORTABLEPARAMETERFVPROC = CFuncPtr3[GLenum, GLenum, Ptr[GLfloat], Unit]
  object PFNGLGETCOLORTABLEPARAMETERFVPROC:
    given _tag: Tag[PFNGLGETCOLORTABLEPARAMETERFVPROC] = Tag.materializeCFuncPtr3[GLenum, GLenum, Ptr[GLfloat], Unit]
    inline def fromPtr(ptr: Ptr[Byte] | Ptr[?]): PFNGLGETCOLORTABLEPARAMETERFVPROC = CFuncPtr.fromPtr(ptr.asInstanceOf[Ptr[Byte]])
    inline def apply(inline o: CFuncPtr3[GLenum, GLenum, Ptr[GLfloat], Unit]): PFNGLGETCOLORTABLEPARAMETERFVPROC = o
    extension (v: PFNGLGETCOLORTABLEPARAMETERFVPROC)
      inline def value: CFuncPtr3[GLenum, GLenum, Ptr[GLfloat], Unit] = v
      inline def toPtr: Ptr[?] = CFuncPtr.toPtr(v)

  opaque type PFNGLGETCOLORTABLEPARAMETERFVSGIPROC = CFuncPtr3[GLenum, GLenum, Ptr[GLfloat], Unit]
  object PFNGLGETCOLORTABLEPARAMETERFVSGIPROC:
    given _tag: Tag[PFNGLGETCOLORTABLEPARAMETERFVSGIPROC] = Tag.materializeCFuncPtr3[GLenum, GLenum, Ptr[GLfloat], Unit]
    inline def fromPtr(ptr: Ptr[Byte] | Ptr[?]): PFNGLGETCOLORTABLEPARAMETERFVSGIPROC = CFuncPtr.fromPtr(ptr.asInstanceOf[Ptr[Byte]])
    inline def apply(inline o: CFuncPtr3[GLenum, GLenum, Ptr[GLfloat], Unit]): PFNGLGETCOLORTABLEPARAMETERFVSGIPROC = o
    extension (v: PFNGLGETCOLORTABLEPARAMETERFVSGIPROC)
      inline def value: CFuncPtr3[GLenum, GLenum, Ptr[GLfloat], Unit] = v
      inline def toPtr: Ptr[?] = CFuncPtr.toPtr(v)

  opaque type PFNGLGETCOLORTABLEPARAMETERIVEXTPROC = CFuncPtr3[GLenum, GLenum, Ptr[GLint], Unit]
  object PFNGLGETCOLORTABLEPARAMETERIVEXTPROC:
    given _tag: Tag[PFNGLGETCOLORTABLEPARAMETERIVEXTPROC] = Tag.materializeCFuncPtr3[GLenum, GLenum, Ptr[GLint], Unit]
    inline def fromPtr(ptr: Ptr[Byte] | Ptr[?]): PFNGLGETCOLORTABLEPARAMETERIVEXTPROC = CFuncPtr.fromPtr(ptr.asInstanceOf[Ptr[Byte]])
    inline def apply(inline o: CFuncPtr3[GLenum, GLenum, Ptr[GLint], Unit]): PFNGLGETCOLORTABLEPARAMETERIVEXTPROC = o
    extension (v: PFNGLGETCOLORTABLEPARAMETERIVEXTPROC)
      inline def value: CFuncPtr3[GLenum, GLenum, Ptr[GLint], Unit] = v
      inline def toPtr: Ptr[?] = CFuncPtr.toPtr(v)

  opaque type PFNGLGETCOLORTABLEPARAMETERIVPROC = CFuncPtr3[GLenum, GLenum, Ptr[GLint], Unit]
  object PFNGLGETCOLORTABLEPARAMETERIVPROC:
    given _tag: Tag[PFNGLGETCOLORTABLEPARAMETERIVPROC] = Tag.materializeCFuncPtr3[GLenum, GLenum, Ptr[GLint], Unit]
    inline def fromPtr(ptr: Ptr[Byte] | Ptr[?]): PFNGLGETCOLORTABLEPARAMETERIVPROC = CFuncPtr.fromPtr(ptr.asInstanceOf[Ptr[Byte]])
    inline def apply(inline o: CFuncPtr3[GLenum, GLenum, Ptr[GLint], Unit]): PFNGLGETCOLORTABLEPARAMETERIVPROC = o
    extension (v: PFNGLGETCOLORTABLEPARAMETERIVPROC)
      inline def value: CFuncPtr3[GLenum, GLenum, Ptr[GLint], Unit] = v
      inline def toPtr: Ptr[?] = CFuncPtr.toPtr(v)

  opaque type PFNGLGETCOLORTABLEPARAMETERIVSGIPROC = CFuncPtr3[GLenum, GLenum, Ptr[GLint], Unit]
  object PFNGLGETCOLORTABLEPARAMETERIVSGIPROC:
    given _tag: Tag[PFNGLGETCOLORTABLEPARAMETERIVSGIPROC] = Tag.materializeCFuncPtr3[GLenum, GLenum, Ptr[GLint], Unit]
    inline def fromPtr(ptr: Ptr[Byte] | Ptr[?]): PFNGLGETCOLORTABLEPARAMETERIVSGIPROC = CFuncPtr.fromPtr(ptr.asInstanceOf[Ptr[Byte]])
    inline def apply(inline o: CFuncPtr3[GLenum, GLenum, Ptr[GLint], Unit]): PFNGLGETCOLORTABLEPARAMETERIVSGIPROC = o
    extension (v: PFNGLGETCOLORTABLEPARAMETERIVSGIPROC)
      inline def value: CFuncPtr3[GLenum, GLenum, Ptr[GLint], Unit] = v
      inline def toPtr: Ptr[?] = CFuncPtr.toPtr(v)

  opaque type PFNGLGETCOLORTABLEPROC = CFuncPtr4[GLenum, GLenum, GLenum, Ptr[Byte], Unit]
  object PFNGLGETCOLORTABLEPROC:
    given _tag: Tag[PFNGLGETCOLORTABLEPROC] = Tag.materializeCFuncPtr4[GLenum, GLenum, GLenum, Ptr[Byte], Unit]
    inline def fromPtr(ptr: Ptr[Byte] | Ptr[?]): PFNGLGETCOLORTABLEPROC = CFuncPtr.fromPtr(ptr.asInstanceOf[Ptr[Byte]])
    inline def apply(inline o: CFuncPtr4[GLenum, GLenum, GLenum, Ptr[Byte], Unit]): PFNGLGETCOLORTABLEPROC = o
    extension (v: PFNGLGETCOLORTABLEPROC)
      inline def value: CFuncPtr4[GLenum, GLenum, GLenum, Ptr[Byte], Unit] = v
      inline def toPtr: Ptr[?] = CFuncPtr.toPtr(v)

  opaque type PFNGLGETCOLORTABLESGIPROC = CFuncPtr4[GLenum, GLenum, GLenum, Ptr[Byte], Unit]
  object PFNGLGETCOLORTABLESGIPROC:
    given _tag: Tag[PFNGLGETCOLORTABLESGIPROC] = Tag.materializeCFuncPtr4[GLenum, GLenum, GLenum, Ptr[Byte], Unit]
    inline def fromPtr(ptr: Ptr[Byte] | Ptr[?]): PFNGLGETCOLORTABLESGIPROC = CFuncPtr.fromPtr(ptr.asInstanceOf[Ptr[Byte]])
    inline def apply(inline o: CFuncPtr4[GLenum, GLenum, GLenum, Ptr[Byte], Unit]): PFNGLGETCOLORTABLESGIPROC = o
    extension (v: PFNGLGETCOLORTABLESGIPROC)
      inline def value: CFuncPtr4[GLenum, GLenum, GLenum, Ptr[Byte], Unit] = v
      inline def toPtr: Ptr[?] = CFuncPtr.toPtr(v)

  opaque type PFNGLGETCOMBINERINPUTPARAMETERFVNVPROC = CFuncPtr5[GLenum, GLenum, GLenum, GLenum, Ptr[GLfloat], Unit]
  object PFNGLGETCOMBINERINPUTPARAMETERFVNVPROC:
    given _tag: Tag[PFNGLGETCOMBINERINPUTPARAMETERFVNVPROC] = Tag.materializeCFuncPtr5[GLenum, GLenum, GLenum, GLenum, Ptr[GLfloat], Unit]
    inline def fromPtr(ptr: Ptr[Byte] | Ptr[?]): PFNGLGETCOMBINERINPUTPARAMETERFVNVPROC = CFuncPtr.fromPtr(ptr.asInstanceOf[Ptr[Byte]])
    inline def apply(inline o: CFuncPtr5[GLenum, GLenum, GLenum, GLenum, Ptr[GLfloat], Unit]): PFNGLGETCOMBINERINPUTPARAMETERFVNVPROC = o
    extension (v: PFNGLGETCOMBINERINPUTPARAMETERFVNVPROC)
      inline def value: CFuncPtr5[GLenum, GLenum, GLenum, GLenum, Ptr[GLfloat], Unit] = v
      inline def toPtr: Ptr[?] = CFuncPtr.toPtr(v)

  opaque type PFNGLGETCOMBINERINPUTPARAMETERIVNVPROC = CFuncPtr5[GLenum, GLenum, GLenum, GLenum, Ptr[GLint], Unit]
  object PFNGLGETCOMBINERINPUTPARAMETERIVNVPROC:
    given _tag: Tag[PFNGLGETCOMBINERINPUTPARAMETERIVNVPROC] = Tag.materializeCFuncPtr5[GLenum, GLenum, GLenum, GLenum, Ptr[GLint], Unit]
    inline def fromPtr(ptr: Ptr[Byte] | Ptr[?]): PFNGLGETCOMBINERINPUTPARAMETERIVNVPROC = CFuncPtr.fromPtr(ptr.asInstanceOf[Ptr[Byte]])
    inline def apply(inline o: CFuncPtr5[GLenum, GLenum, GLenum, GLenum, Ptr[GLint], Unit]): PFNGLGETCOMBINERINPUTPARAMETERIVNVPROC = o
    extension (v: PFNGLGETCOMBINERINPUTPARAMETERIVNVPROC)
      inline def value: CFuncPtr5[GLenum, GLenum, GLenum, GLenum, Ptr[GLint], Unit] = v
      inline def toPtr: Ptr[?] = CFuncPtr.toPtr(v)

  opaque type PFNGLGETCOMBINEROUTPUTPARAMETERFVNVPROC = CFuncPtr4[GLenum, GLenum, GLenum, Ptr[GLfloat], Unit]
  object PFNGLGETCOMBINEROUTPUTPARAMETERFVNVPROC:
    given _tag: Tag[PFNGLGETCOMBINEROUTPUTPARAMETERFVNVPROC] = Tag.materializeCFuncPtr4[GLenum, GLenum, GLenum, Ptr[GLfloat], Unit]
    inline def fromPtr(ptr: Ptr[Byte] | Ptr[?]): PFNGLGETCOMBINEROUTPUTPARAMETERFVNVPROC = CFuncPtr.fromPtr(ptr.asInstanceOf[Ptr[Byte]])
    inline def apply(inline o: CFuncPtr4[GLenum, GLenum, GLenum, Ptr[GLfloat], Unit]): PFNGLGETCOMBINEROUTPUTPARAMETERFVNVPROC = o
    extension (v: PFNGLGETCOMBINEROUTPUTPARAMETERFVNVPROC)
      inline def value: CFuncPtr4[GLenum, GLenum, GLenum, Ptr[GLfloat], Unit] = v
      inline def toPtr: Ptr[?] = CFuncPtr.toPtr(v)

  opaque type PFNGLGETCOMBINEROUTPUTPARAMETERIVNVPROC = CFuncPtr4[GLenum, GLenum, GLenum, Ptr[GLint], Unit]
  object PFNGLGETCOMBINEROUTPUTPARAMETERIVNVPROC:
    given _tag: Tag[PFNGLGETCOMBINEROUTPUTPARAMETERIVNVPROC] = Tag.materializeCFuncPtr4[GLenum, GLenum, GLenum, Ptr[GLint], Unit]
    inline def fromPtr(ptr: Ptr[Byte] | Ptr[?]): PFNGLGETCOMBINEROUTPUTPARAMETERIVNVPROC = CFuncPtr.fromPtr(ptr.asInstanceOf[Ptr[Byte]])
    inline def apply(inline o: CFuncPtr4[GLenum, GLenum, GLenum, Ptr[GLint], Unit]): PFNGLGETCOMBINEROUTPUTPARAMETERIVNVPROC = o
    extension (v: PFNGLGETCOMBINEROUTPUTPARAMETERIVNVPROC)
      inline def value: CFuncPtr4[GLenum, GLenum, GLenum, Ptr[GLint], Unit] = v
      inline def toPtr: Ptr[?] = CFuncPtr.toPtr(v)

  opaque type PFNGLGETCOMBINERSTAGEPARAMETERFVNVPROC = CFuncPtr3[GLenum, GLenum, Ptr[GLfloat], Unit]
  object PFNGLGETCOMBINERSTAGEPARAMETERFVNVPROC:
    given _tag: Tag[PFNGLGETCOMBINERSTAGEPARAMETERFVNVPROC] = Tag.materializeCFuncPtr3[GLenum, GLenum, Ptr[GLfloat], Unit]
    inline def fromPtr(ptr: Ptr[Byte] | Ptr[?]): PFNGLGETCOMBINERSTAGEPARAMETERFVNVPROC = CFuncPtr.fromPtr(ptr.asInstanceOf[Ptr[Byte]])
    inline def apply(inline o: CFuncPtr3[GLenum, GLenum, Ptr[GLfloat], Unit]): PFNGLGETCOMBINERSTAGEPARAMETERFVNVPROC = o
    extension (v: PFNGLGETCOMBINERSTAGEPARAMETERFVNVPROC)
      inline def value: CFuncPtr3[GLenum, GLenum, Ptr[GLfloat], Unit] = v
      inline def toPtr: Ptr[?] = CFuncPtr.toPtr(v)

  opaque type PFNGLGETCOMMANDHEADERNVPROC = CFuncPtr2[GLenum, GLuint, GLuint]
  object PFNGLGETCOMMANDHEADERNVPROC:
    given _tag: Tag[PFNGLGETCOMMANDHEADERNVPROC] = Tag.materializeCFuncPtr2[GLenum, GLuint, GLuint]
    inline def fromPtr(ptr: Ptr[Byte] | Ptr[?]): PFNGLGETCOMMANDHEADERNVPROC = CFuncPtr.fromPtr(ptr.asInstanceOf[Ptr[Byte]])
    inline def apply(inline o: CFuncPtr2[GLenum, GLuint, GLuint]): PFNGLGETCOMMANDHEADERNVPROC = o
    extension (v: PFNGLGETCOMMANDHEADERNVPROC)
      inline def value: CFuncPtr2[GLenum, GLuint, GLuint] = v
      inline def toPtr: Ptr[?] = CFuncPtr.toPtr(v)

  opaque type PFNGLGETCOMPRESSEDMULTITEXIMAGEEXTPROC = CFuncPtr4[GLenum, GLenum, GLint, Ptr[Byte], Unit]
  object PFNGLGETCOMPRESSEDMULTITEXIMAGEEXTPROC:
    given _tag: Tag[PFNGLGETCOMPRESSEDMULTITEXIMAGEEXTPROC] = Tag.materializeCFuncPtr4[GLenum, GLenum, GLint, Ptr[Byte], Unit]
    inline def fromPtr(ptr: Ptr[Byte] | Ptr[?]): PFNGLGETCOMPRESSEDMULTITEXIMAGEEXTPROC = CFuncPtr.fromPtr(ptr.asInstanceOf[Ptr[Byte]])
    inline def apply(inline o: CFuncPtr4[GLenum, GLenum, GLint, Ptr[Byte], Unit]): PFNGLGETCOMPRESSEDMULTITEXIMAGEEXTPROC = o
    extension (v: PFNGLGETCOMPRESSEDMULTITEXIMAGEEXTPROC)
      inline def value: CFuncPtr4[GLenum, GLenum, GLint, Ptr[Byte], Unit] = v
      inline def toPtr: Ptr[?] = CFuncPtr.toPtr(v)

  opaque type PFNGLGETCOMPRESSEDTEXIMAGEARBPROC = CFuncPtr3[GLenum, GLint, Ptr[Byte], Unit]
  object PFNGLGETCOMPRESSEDTEXIMAGEARBPROC:
    given _tag: Tag[PFNGLGETCOMPRESSEDTEXIMAGEARBPROC] = Tag.materializeCFuncPtr3[GLenum, GLint, Ptr[Byte], Unit]
    inline def fromPtr(ptr: Ptr[Byte] | Ptr[?]): PFNGLGETCOMPRESSEDTEXIMAGEARBPROC = CFuncPtr.fromPtr(ptr.asInstanceOf[Ptr[Byte]])
    inline def apply(inline o: CFuncPtr3[GLenum, GLint, Ptr[Byte], Unit]): PFNGLGETCOMPRESSEDTEXIMAGEARBPROC = o
    extension (v: PFNGLGETCOMPRESSEDTEXIMAGEARBPROC)
      inline def value: CFuncPtr3[GLenum, GLint, Ptr[Byte], Unit] = v
      inline def toPtr: Ptr[?] = CFuncPtr.toPtr(v)

  opaque type PFNGLGETCOMPRESSEDTEXIMAGEPROC = CFuncPtr3[GLenum, GLint, Ptr[Byte], Unit]
  object PFNGLGETCOMPRESSEDTEXIMAGEPROC:
    given _tag: Tag[PFNGLGETCOMPRESSEDTEXIMAGEPROC] = Tag.materializeCFuncPtr3[GLenum, GLint, Ptr[Byte], Unit]
    inline def fromPtr(ptr: Ptr[Byte] | Ptr[?]): PFNGLGETCOMPRESSEDTEXIMAGEPROC = CFuncPtr.fromPtr(ptr.asInstanceOf[Ptr[Byte]])
    inline def apply(inline o: CFuncPtr3[GLenum, GLint, Ptr[Byte], Unit]): PFNGLGETCOMPRESSEDTEXIMAGEPROC = o
    extension (v: PFNGLGETCOMPRESSEDTEXIMAGEPROC)
      inline def value: CFuncPtr3[GLenum, GLint, Ptr[Byte], Unit] = v
      inline def toPtr: Ptr[?] = CFuncPtr.toPtr(v)

  opaque type PFNGLGETCOMPRESSEDTEXTUREIMAGEEXTPROC = CFuncPtr4[GLuint, GLenum, GLint, Ptr[Byte], Unit]
  object PFNGLGETCOMPRESSEDTEXTUREIMAGEEXTPROC:
    given _tag: Tag[PFNGLGETCOMPRESSEDTEXTUREIMAGEEXTPROC] = Tag.materializeCFuncPtr4[GLuint, GLenum, GLint, Ptr[Byte], Unit]
    inline def fromPtr(ptr: Ptr[Byte] | Ptr[?]): PFNGLGETCOMPRESSEDTEXTUREIMAGEEXTPROC = CFuncPtr.fromPtr(ptr.asInstanceOf[Ptr[Byte]])
    inline def apply(inline o: CFuncPtr4[GLuint, GLenum, GLint, Ptr[Byte], Unit]): PFNGLGETCOMPRESSEDTEXTUREIMAGEEXTPROC = o
    extension (v: PFNGLGETCOMPRESSEDTEXTUREIMAGEEXTPROC)
      inline def value: CFuncPtr4[GLuint, GLenum, GLint, Ptr[Byte], Unit] = v
      inline def toPtr: Ptr[?] = CFuncPtr.toPtr(v)

  opaque type PFNGLGETCOMPRESSEDTEXTUREIMAGEPROC = CFuncPtr4[GLuint, GLint, GLsizei, Ptr[Byte], Unit]
  object PFNGLGETCOMPRESSEDTEXTUREIMAGEPROC:
    given _tag: Tag[PFNGLGETCOMPRESSEDTEXTUREIMAGEPROC] = Tag.materializeCFuncPtr4[GLuint, GLint, GLsizei, Ptr[Byte], Unit]
    inline def fromPtr(ptr: Ptr[Byte] | Ptr[?]): PFNGLGETCOMPRESSEDTEXTUREIMAGEPROC = CFuncPtr.fromPtr(ptr.asInstanceOf[Ptr[Byte]])
    inline def apply(inline o: CFuncPtr4[GLuint, GLint, GLsizei, Ptr[Byte], Unit]): PFNGLGETCOMPRESSEDTEXTUREIMAGEPROC = o
    extension (v: PFNGLGETCOMPRESSEDTEXTUREIMAGEPROC)
      inline def value: CFuncPtr4[GLuint, GLint, GLsizei, Ptr[Byte], Unit] = v
      inline def toPtr: Ptr[?] = CFuncPtr.toPtr(v)

  opaque type PFNGLGETCOMPRESSEDTEXTURESUBIMAGEPROC = CFuncPtr10[GLuint, GLint, GLint, GLint, GLint, GLsizei, GLsizei, GLsizei, GLsizei, Ptr[Byte], Unit]
  object PFNGLGETCOMPRESSEDTEXTURESUBIMAGEPROC:
    given _tag: Tag[PFNGLGETCOMPRESSEDTEXTURESUBIMAGEPROC] = Tag.materializeCFuncPtr10[GLuint, GLint, GLint, GLint, GLint, GLsizei, GLsizei, GLsizei, GLsizei, Ptr[Byte], Unit]
    inline def fromPtr(ptr: Ptr[Byte] | Ptr[?]): PFNGLGETCOMPRESSEDTEXTURESUBIMAGEPROC = CFuncPtr.fromPtr(ptr.asInstanceOf[Ptr[Byte]])
    inline def apply(inline o: CFuncPtr10[GLuint, GLint, GLint, GLint, GLint, GLsizei, GLsizei, GLsizei, GLsizei, Ptr[Byte], Unit]): PFNGLGETCOMPRESSEDTEXTURESUBIMAGEPROC = o
    extension (v: PFNGLGETCOMPRESSEDTEXTURESUBIMAGEPROC)
      inline def value: CFuncPtr10[GLuint, GLint, GLint, GLint, GLint, GLsizei, GLsizei, GLsizei, GLsizei, Ptr[Byte], Unit] = v
      inline def toPtr: Ptr[?] = CFuncPtr.toPtr(v)

  opaque type PFNGLGETCONVOLUTIONFILTEREXTPROC = CFuncPtr4[GLenum, GLenum, GLenum, Ptr[Byte], Unit]
  object PFNGLGETCONVOLUTIONFILTEREXTPROC:
    given _tag: Tag[PFNGLGETCONVOLUTIONFILTEREXTPROC] = Tag.materializeCFuncPtr4[GLenum, GLenum, GLenum, Ptr[Byte], Unit]
    inline def fromPtr(ptr: Ptr[Byte] | Ptr[?]): PFNGLGETCONVOLUTIONFILTEREXTPROC = CFuncPtr.fromPtr(ptr.asInstanceOf[Ptr[Byte]])
    inline def apply(inline o: CFuncPtr4[GLenum, GLenum, GLenum, Ptr[Byte], Unit]): PFNGLGETCONVOLUTIONFILTEREXTPROC = o
    extension (v: PFNGLGETCONVOLUTIONFILTEREXTPROC)
      inline def value: CFuncPtr4[GLenum, GLenum, GLenum, Ptr[Byte], Unit] = v
      inline def toPtr: Ptr[?] = CFuncPtr.toPtr(v)

  opaque type PFNGLGETCONVOLUTIONFILTERPROC = CFuncPtr4[GLenum, GLenum, GLenum, Ptr[Byte], Unit]
  object PFNGLGETCONVOLUTIONFILTERPROC:
    given _tag: Tag[PFNGLGETCONVOLUTIONFILTERPROC] = Tag.materializeCFuncPtr4[GLenum, GLenum, GLenum, Ptr[Byte], Unit]
    inline def fromPtr(ptr: Ptr[Byte] | Ptr[?]): PFNGLGETCONVOLUTIONFILTERPROC = CFuncPtr.fromPtr(ptr.asInstanceOf[Ptr[Byte]])
    inline def apply(inline o: CFuncPtr4[GLenum, GLenum, GLenum, Ptr[Byte], Unit]): PFNGLGETCONVOLUTIONFILTERPROC = o
    extension (v: PFNGLGETCONVOLUTIONFILTERPROC)
      inline def value: CFuncPtr4[GLenum, GLenum, GLenum, Ptr[Byte], Unit] = v
      inline def toPtr: Ptr[?] = CFuncPtr.toPtr(v)

  opaque type PFNGLGETCONVOLUTIONPARAMETERFVEXTPROC = CFuncPtr3[GLenum, GLenum, Ptr[GLfloat], Unit]
  object PFNGLGETCONVOLUTIONPARAMETERFVEXTPROC:
    given _tag: Tag[PFNGLGETCONVOLUTIONPARAMETERFVEXTPROC] = Tag.materializeCFuncPtr3[GLenum, GLenum, Ptr[GLfloat], Unit]
    inline def fromPtr(ptr: Ptr[Byte] | Ptr[?]): PFNGLGETCONVOLUTIONPARAMETERFVEXTPROC = CFuncPtr.fromPtr(ptr.asInstanceOf[Ptr[Byte]])
    inline def apply(inline o: CFuncPtr3[GLenum, GLenum, Ptr[GLfloat], Unit]): PFNGLGETCONVOLUTIONPARAMETERFVEXTPROC = o
    extension (v: PFNGLGETCONVOLUTIONPARAMETERFVEXTPROC)
      inline def value: CFuncPtr3[GLenum, GLenum, Ptr[GLfloat], Unit] = v
      inline def toPtr: Ptr[?] = CFuncPtr.toPtr(v)

  opaque type PFNGLGETCONVOLUTIONPARAMETERFVPROC = CFuncPtr3[GLenum, GLenum, Ptr[GLfloat], Unit]
  object PFNGLGETCONVOLUTIONPARAMETERFVPROC:
    given _tag: Tag[PFNGLGETCONVOLUTIONPARAMETERFVPROC] = Tag.materializeCFuncPtr3[GLenum, GLenum, Ptr[GLfloat], Unit]
    inline def fromPtr(ptr: Ptr[Byte] | Ptr[?]): PFNGLGETCONVOLUTIONPARAMETERFVPROC = CFuncPtr.fromPtr(ptr.asInstanceOf[Ptr[Byte]])
    inline def apply(inline o: CFuncPtr3[GLenum, GLenum, Ptr[GLfloat], Unit]): PFNGLGETCONVOLUTIONPARAMETERFVPROC = o
    extension (v: PFNGLGETCONVOLUTIONPARAMETERFVPROC)
      inline def value: CFuncPtr3[GLenum, GLenum, Ptr[GLfloat], Unit] = v
      inline def toPtr: Ptr[?] = CFuncPtr.toPtr(v)

  opaque type PFNGLGETCONVOLUTIONPARAMETERIVEXTPROC = CFuncPtr3[GLenum, GLenum, Ptr[GLint], Unit]
  object PFNGLGETCONVOLUTIONPARAMETERIVEXTPROC:
    given _tag: Tag[PFNGLGETCONVOLUTIONPARAMETERIVEXTPROC] = Tag.materializeCFuncPtr3[GLenum, GLenum, Ptr[GLint], Unit]
    inline def fromPtr(ptr: Ptr[Byte] | Ptr[?]): PFNGLGETCONVOLUTIONPARAMETERIVEXTPROC = CFuncPtr.fromPtr(ptr.asInstanceOf[Ptr[Byte]])
    inline def apply(inline o: CFuncPtr3[GLenum, GLenum, Ptr[GLint], Unit]): PFNGLGETCONVOLUTIONPARAMETERIVEXTPROC = o
    extension (v: PFNGLGETCONVOLUTIONPARAMETERIVEXTPROC)
      inline def value: CFuncPtr3[GLenum, GLenum, Ptr[GLint], Unit] = v
      inline def toPtr: Ptr[?] = CFuncPtr.toPtr(v)

  opaque type PFNGLGETCONVOLUTIONPARAMETERIVPROC = CFuncPtr3[GLenum, GLenum, Ptr[GLint], Unit]
  object PFNGLGETCONVOLUTIONPARAMETERIVPROC:
    given _tag: Tag[PFNGLGETCONVOLUTIONPARAMETERIVPROC] = Tag.materializeCFuncPtr3[GLenum, GLenum, Ptr[GLint], Unit]
    inline def fromPtr(ptr: Ptr[Byte] | Ptr[?]): PFNGLGETCONVOLUTIONPARAMETERIVPROC = CFuncPtr.fromPtr(ptr.asInstanceOf[Ptr[Byte]])
    inline def apply(inline o: CFuncPtr3[GLenum, GLenum, Ptr[GLint], Unit]): PFNGLGETCONVOLUTIONPARAMETERIVPROC = o
    extension (v: PFNGLGETCONVOLUTIONPARAMETERIVPROC)
      inline def value: CFuncPtr3[GLenum, GLenum, Ptr[GLint], Unit] = v
      inline def toPtr: Ptr[?] = CFuncPtr.toPtr(v)

  opaque type PFNGLGETCOVERAGEMODULATIONTABLENVPROC = CFuncPtr2[GLsizei, Ptr[GLfloat], Unit]
  object PFNGLGETCOVERAGEMODULATIONTABLENVPROC:
    given _tag: Tag[PFNGLGETCOVERAGEMODULATIONTABLENVPROC] = Tag.materializeCFuncPtr2[GLsizei, Ptr[GLfloat], Unit]
    inline def fromPtr(ptr: Ptr[Byte] | Ptr[?]): PFNGLGETCOVERAGEMODULATIONTABLENVPROC = CFuncPtr.fromPtr(ptr.asInstanceOf[Ptr[Byte]])
    inline def apply(inline o: CFuncPtr2[GLsizei, Ptr[GLfloat], Unit]): PFNGLGETCOVERAGEMODULATIONTABLENVPROC = o
    extension (v: PFNGLGETCOVERAGEMODULATIONTABLENVPROC)
      inline def value: CFuncPtr2[GLsizei, Ptr[GLfloat], Unit] = v
      inline def toPtr: Ptr[?] = CFuncPtr.toPtr(v)

  opaque type PFNGLGETDEBUGMESSAGELOGAMDPROC = CFuncPtr7[GLuint, GLsizei, Ptr[GLenum], Ptr[GLuint], Ptr[GLuint], Ptr[GLsizei], Ptr[GLchar], GLuint]
  object PFNGLGETDEBUGMESSAGELOGAMDPROC:
    given _tag: Tag[PFNGLGETDEBUGMESSAGELOGAMDPROC] = Tag.materializeCFuncPtr7[GLuint, GLsizei, Ptr[GLenum], Ptr[GLuint], Ptr[GLuint], Ptr[GLsizei], Ptr[GLchar], GLuint]
    inline def fromPtr(ptr: Ptr[Byte] | Ptr[?]): PFNGLGETDEBUGMESSAGELOGAMDPROC = CFuncPtr.fromPtr(ptr.asInstanceOf[Ptr[Byte]])
    inline def apply(inline o: CFuncPtr7[GLuint, GLsizei, Ptr[GLenum], Ptr[GLuint], Ptr[GLuint], Ptr[GLsizei], Ptr[GLchar], GLuint]): PFNGLGETDEBUGMESSAGELOGAMDPROC = o
    extension (v: PFNGLGETDEBUGMESSAGELOGAMDPROC)
      inline def value: CFuncPtr7[GLuint, GLsizei, Ptr[GLenum], Ptr[GLuint], Ptr[GLuint], Ptr[GLsizei], Ptr[GLchar], GLuint] = v
      inline def toPtr: Ptr[?] = CFuncPtr.toPtr(v)

  opaque type PFNGLGETDEBUGMESSAGELOGARBPROC = CFuncPtr8[GLuint, GLsizei, Ptr[GLenum], Ptr[GLenum], Ptr[GLuint], Ptr[GLenum], Ptr[GLsizei], Ptr[GLchar], GLuint]
  object PFNGLGETDEBUGMESSAGELOGARBPROC:
    given _tag: Tag[PFNGLGETDEBUGMESSAGELOGARBPROC] = Tag.materializeCFuncPtr8[GLuint, GLsizei, Ptr[GLenum], Ptr[GLenum], Ptr[GLuint], Ptr[GLenum], Ptr[GLsizei], Ptr[GLchar], GLuint]
    inline def fromPtr(ptr: Ptr[Byte] | Ptr[?]): PFNGLGETDEBUGMESSAGELOGARBPROC = CFuncPtr.fromPtr(ptr.asInstanceOf[Ptr[Byte]])
    inline def apply(inline o: CFuncPtr8[GLuint, GLsizei, Ptr[GLenum], Ptr[GLenum], Ptr[GLuint], Ptr[GLenum], Ptr[GLsizei], Ptr[GLchar], GLuint]): PFNGLGETDEBUGMESSAGELOGARBPROC = o
    extension (v: PFNGLGETDEBUGMESSAGELOGARBPROC)
      inline def value: CFuncPtr8[GLuint, GLsizei, Ptr[GLenum], Ptr[GLenum], Ptr[GLuint], Ptr[GLenum], Ptr[GLsizei], Ptr[GLchar], GLuint] = v
      inline def toPtr: Ptr[?] = CFuncPtr.toPtr(v)

  opaque type PFNGLGETDEBUGMESSAGELOGPROC = CFuncPtr8[GLuint, GLsizei, Ptr[GLenum], Ptr[GLenum], Ptr[GLuint], Ptr[GLenum], Ptr[GLsizei], Ptr[GLchar], GLuint]
  object PFNGLGETDEBUGMESSAGELOGPROC:
    given _tag: Tag[PFNGLGETDEBUGMESSAGELOGPROC] = Tag.materializeCFuncPtr8[GLuint, GLsizei, Ptr[GLenum], Ptr[GLenum], Ptr[GLuint], Ptr[GLenum], Ptr[GLsizei], Ptr[GLchar], GLuint]
    inline def fromPtr(ptr: Ptr[Byte] | Ptr[?]): PFNGLGETDEBUGMESSAGELOGPROC = CFuncPtr.fromPtr(ptr.asInstanceOf[Ptr[Byte]])
    inline def apply(inline o: CFuncPtr8[GLuint, GLsizei, Ptr[GLenum], Ptr[GLenum], Ptr[GLuint], Ptr[GLenum], Ptr[GLsizei], Ptr[GLchar], GLuint]): PFNGLGETDEBUGMESSAGELOGPROC = o
    extension (v: PFNGLGETDEBUGMESSAGELOGPROC)
      inline def value: CFuncPtr8[GLuint, GLsizei, Ptr[GLenum], Ptr[GLenum], Ptr[GLuint], Ptr[GLenum], Ptr[GLsizei], Ptr[GLchar], GLuint] = v
      inline def toPtr: Ptr[?] = CFuncPtr.toPtr(v)

  opaque type PFNGLGETDETAILTEXFUNCSGISPROC = CFuncPtr2[GLenum, Ptr[GLfloat], Unit]
  object PFNGLGETDETAILTEXFUNCSGISPROC:
    given _tag: Tag[PFNGLGETDETAILTEXFUNCSGISPROC] = Tag.materializeCFuncPtr2[GLenum, Ptr[GLfloat], Unit]
    inline def fromPtr(ptr: Ptr[Byte] | Ptr[?]): PFNGLGETDETAILTEXFUNCSGISPROC = CFuncPtr.fromPtr(ptr.asInstanceOf[Ptr[Byte]])
    inline def apply(inline o: CFuncPtr2[GLenum, Ptr[GLfloat], Unit]): PFNGLGETDETAILTEXFUNCSGISPROC = o
    extension (v: PFNGLGETDETAILTEXFUNCSGISPROC)
      inline def value: CFuncPtr2[GLenum, Ptr[GLfloat], Unit] = v
      inline def toPtr: Ptr[?] = CFuncPtr.toPtr(v)

  opaque type PFNGLGETDOUBLEINDEXEDVEXTPROC = CFuncPtr3[GLenum, GLuint, Ptr[GLdouble], Unit]
  object PFNGLGETDOUBLEINDEXEDVEXTPROC:
    given _tag: Tag[PFNGLGETDOUBLEINDEXEDVEXTPROC] = Tag.materializeCFuncPtr3[GLenum, GLuint, Ptr[GLdouble], Unit]
    inline def fromPtr(ptr: Ptr[Byte] | Ptr[?]): PFNGLGETDOUBLEINDEXEDVEXTPROC = CFuncPtr.fromPtr(ptr.asInstanceOf[Ptr[Byte]])
    inline def apply(inline o: CFuncPtr3[GLenum, GLuint, Ptr[GLdouble], Unit]): PFNGLGETDOUBLEINDEXEDVEXTPROC = o
    extension (v: PFNGLGETDOUBLEINDEXEDVEXTPROC)
      inline def value: CFuncPtr3[GLenum, GLuint, Ptr[GLdouble], Unit] = v
      inline def toPtr: Ptr[?] = CFuncPtr.toPtr(v)

  opaque type PFNGLGETDOUBLEI_VEXTPROC = CFuncPtr3[GLenum, GLuint, Ptr[GLdouble], Unit]
  object PFNGLGETDOUBLEI_VEXTPROC:
    given _tag: Tag[PFNGLGETDOUBLEI_VEXTPROC] = Tag.materializeCFuncPtr3[GLenum, GLuint, Ptr[GLdouble], Unit]
    inline def fromPtr(ptr: Ptr[Byte] | Ptr[?]): PFNGLGETDOUBLEI_VEXTPROC = CFuncPtr.fromPtr(ptr.asInstanceOf[Ptr[Byte]])
    inline def apply(inline o: CFuncPtr3[GLenum, GLuint, Ptr[GLdouble], Unit]): PFNGLGETDOUBLEI_VEXTPROC = o
    extension (v: PFNGLGETDOUBLEI_VEXTPROC)
      inline def value: CFuncPtr3[GLenum, GLuint, Ptr[GLdouble], Unit] = v
      inline def toPtr: Ptr[?] = CFuncPtr.toPtr(v)

  opaque type PFNGLGETDOUBLEI_VPROC = CFuncPtr3[GLenum, GLuint, Ptr[GLdouble], Unit]
  object PFNGLGETDOUBLEI_VPROC:
    given _tag: Tag[PFNGLGETDOUBLEI_VPROC] = Tag.materializeCFuncPtr3[GLenum, GLuint, Ptr[GLdouble], Unit]
    inline def fromPtr(ptr: Ptr[Byte] | Ptr[?]): PFNGLGETDOUBLEI_VPROC = CFuncPtr.fromPtr(ptr.asInstanceOf[Ptr[Byte]])
    inline def apply(inline o: CFuncPtr3[GLenum, GLuint, Ptr[GLdouble], Unit]): PFNGLGETDOUBLEI_VPROC = o
    extension (v: PFNGLGETDOUBLEI_VPROC)
      inline def value: CFuncPtr3[GLenum, GLuint, Ptr[GLdouble], Unit] = v
      inline def toPtr: Ptr[?] = CFuncPtr.toPtr(v)

  opaque type PFNGLGETDRIVERCONTROLSQCOMPROC = CFuncPtr3[Ptr[GLint], GLsizei, Ptr[GLuint], Unit]
  object PFNGLGETDRIVERCONTROLSQCOMPROC:
    given _tag: Tag[PFNGLGETDRIVERCONTROLSQCOMPROC] = Tag.materializeCFuncPtr3[Ptr[GLint], GLsizei, Ptr[GLuint], Unit]
    inline def fromPtr(ptr: Ptr[Byte] | Ptr[?]): PFNGLGETDRIVERCONTROLSQCOMPROC = CFuncPtr.fromPtr(ptr.asInstanceOf[Ptr[Byte]])
    inline def apply(inline o: CFuncPtr3[Ptr[GLint], GLsizei, Ptr[GLuint], Unit]): PFNGLGETDRIVERCONTROLSQCOMPROC = o
    extension (v: PFNGLGETDRIVERCONTROLSQCOMPROC)
      inline def value: CFuncPtr3[Ptr[GLint], GLsizei, Ptr[GLuint], Unit] = v
      inline def toPtr: Ptr[?] = CFuncPtr.toPtr(v)

  opaque type PFNGLGETDRIVERCONTROLSTRINGQCOMPROC = CFuncPtr4[GLuint, GLsizei, Ptr[GLsizei], Ptr[GLchar], Unit]
  object PFNGLGETDRIVERCONTROLSTRINGQCOMPROC:
    given _tag: Tag[PFNGLGETDRIVERCONTROLSTRINGQCOMPROC] = Tag.materializeCFuncPtr4[GLuint, GLsizei, Ptr[GLsizei], Ptr[GLchar], Unit]
    inline def fromPtr(ptr: Ptr[Byte] | Ptr[?]): PFNGLGETDRIVERCONTROLSTRINGQCOMPROC = CFuncPtr.fromPtr(ptr.asInstanceOf[Ptr[Byte]])
    inline def apply(inline o: CFuncPtr4[GLuint, GLsizei, Ptr[GLsizei], Ptr[GLchar], Unit]): PFNGLGETDRIVERCONTROLSTRINGQCOMPROC = o
    extension (v: PFNGLGETDRIVERCONTROLSTRINGQCOMPROC)
      inline def value: CFuncPtr4[GLuint, GLsizei, Ptr[GLsizei], Ptr[GLchar], Unit] = v
      inline def toPtr: Ptr[?] = CFuncPtr.toPtr(v)

  opaque type PFNGLGETEXTENSIONREGALPROC = CFuncPtr1[Ptr[GLchar], GLboolean]
  object PFNGLGETEXTENSIONREGALPROC:
    given _tag: Tag[PFNGLGETEXTENSIONREGALPROC] = Tag.materializeCFuncPtr1[Ptr[GLchar], GLboolean]
    inline def fromPtr(ptr: Ptr[Byte] | Ptr[?]): PFNGLGETEXTENSIONREGALPROC = CFuncPtr.fromPtr(ptr.asInstanceOf[Ptr[Byte]])
    inline def apply(inline o: CFuncPtr1[Ptr[GLchar], GLboolean]): PFNGLGETEXTENSIONREGALPROC = o
    extension (v: PFNGLGETEXTENSIONREGALPROC)
      inline def value: CFuncPtr1[Ptr[GLchar], GLboolean] = v
      inline def toPtr: Ptr[?] = CFuncPtr.toPtr(v)

  opaque type PFNGLGETFENCEIVNVPROC = CFuncPtr3[GLuint, GLenum, Ptr[GLint], Unit]
  object PFNGLGETFENCEIVNVPROC:
    given _tag: Tag[PFNGLGETFENCEIVNVPROC] = Tag.materializeCFuncPtr3[GLuint, GLenum, Ptr[GLint], Unit]
    inline def fromPtr(ptr: Ptr[Byte] | Ptr[?]): PFNGLGETFENCEIVNVPROC = CFuncPtr.fromPtr(ptr.asInstanceOf[Ptr[Byte]])
    inline def apply(inline o: CFuncPtr3[GLuint, GLenum, Ptr[GLint], Unit]): PFNGLGETFENCEIVNVPROC = o
    extension (v: PFNGLGETFENCEIVNVPROC)
      inline def value: CFuncPtr3[GLuint, GLenum, Ptr[GLint], Unit] = v
      inline def toPtr: Ptr[?] = CFuncPtr.toPtr(v)

  opaque type PFNGLGETFINALCOMBINERINPUTPARAMETERFVNVPROC = CFuncPtr3[GLenum, GLenum, Ptr[GLfloat], Unit]
  object PFNGLGETFINALCOMBINERINPUTPARAMETERFVNVPROC:
    given _tag: Tag[PFNGLGETFINALCOMBINERINPUTPARAMETERFVNVPROC] = Tag.materializeCFuncPtr3[GLenum, GLenum, Ptr[GLfloat], Unit]
    inline def fromPtr(ptr: Ptr[Byte] | Ptr[?]): PFNGLGETFINALCOMBINERINPUTPARAMETERFVNVPROC = CFuncPtr.fromPtr(ptr.asInstanceOf[Ptr[Byte]])
    inline def apply(inline o: CFuncPtr3[GLenum, GLenum, Ptr[GLfloat], Unit]): PFNGLGETFINALCOMBINERINPUTPARAMETERFVNVPROC = o
    extension (v: PFNGLGETFINALCOMBINERINPUTPARAMETERFVNVPROC)
      inline def value: CFuncPtr3[GLenum, GLenum, Ptr[GLfloat], Unit] = v
      inline def toPtr: Ptr[?] = CFuncPtr.toPtr(v)

  opaque type PFNGLGETFINALCOMBINERINPUTPARAMETERIVNVPROC = CFuncPtr3[GLenum, GLenum, Ptr[GLint], Unit]
  object PFNGLGETFINALCOMBINERINPUTPARAMETERIVNVPROC:
    given _tag: Tag[PFNGLGETFINALCOMBINERINPUTPARAMETERIVNVPROC] = Tag.materializeCFuncPtr3[GLenum, GLenum, Ptr[GLint], Unit]
    inline def fromPtr(ptr: Ptr[Byte] | Ptr[?]): PFNGLGETFINALCOMBINERINPUTPARAMETERIVNVPROC = CFuncPtr.fromPtr(ptr.asInstanceOf[Ptr[Byte]])
    inline def apply(inline o: CFuncPtr3[GLenum, GLenum, Ptr[GLint], Unit]): PFNGLGETFINALCOMBINERINPUTPARAMETERIVNVPROC = o
    extension (v: PFNGLGETFINALCOMBINERINPUTPARAMETERIVNVPROC)
      inline def value: CFuncPtr3[GLenum, GLenum, Ptr[GLint], Unit] = v
      inline def toPtr: Ptr[?] = CFuncPtr.toPtr(v)

  opaque type PFNGLGETFIRSTPERFQUERYIDINTELPROC = CFuncPtr1[Ptr[GLuint], Unit]
  object PFNGLGETFIRSTPERFQUERYIDINTELPROC:
    given _tag: Tag[PFNGLGETFIRSTPERFQUERYIDINTELPROC] = Tag.materializeCFuncPtr1[Ptr[GLuint], Unit]
    inline def fromPtr(ptr: Ptr[Byte] | Ptr[?]): PFNGLGETFIRSTPERFQUERYIDINTELPROC = CFuncPtr.fromPtr(ptr.asInstanceOf[Ptr[Byte]])
    inline def apply(inline o: CFuncPtr1[Ptr[GLuint], Unit]): PFNGLGETFIRSTPERFQUERYIDINTELPROC = o
    extension (v: PFNGLGETFIRSTPERFQUERYIDINTELPROC)
      inline def value: CFuncPtr1[Ptr[GLuint], Unit] = v
      inline def toPtr: Ptr[?] = CFuncPtr.toPtr(v)

  opaque type PFNGLGETFIXEDVPROC = CFuncPtr2[GLenum, Ptr[GLfixed], Unit]
  object PFNGLGETFIXEDVPROC:
    given _tag: Tag[PFNGLGETFIXEDVPROC] = Tag.materializeCFuncPtr2[GLenum, Ptr[GLfixed], Unit]
    inline def fromPtr(ptr: Ptr[Byte] | Ptr[?]): PFNGLGETFIXEDVPROC = CFuncPtr.fromPtr(ptr.asInstanceOf[Ptr[Byte]])
    inline def apply(inline o: CFuncPtr2[GLenum, Ptr[GLfixed], Unit]): PFNGLGETFIXEDVPROC = o
    extension (v: PFNGLGETFIXEDVPROC)
      inline def value: CFuncPtr2[GLenum, Ptr[GLfixed], Unit] = v
      inline def toPtr: Ptr[?] = CFuncPtr.toPtr(v)

  opaque type PFNGLGETFLOATINDEXEDVEXTPROC = CFuncPtr3[GLenum, GLuint, Ptr[GLfloat], Unit]
  object PFNGLGETFLOATINDEXEDVEXTPROC:
    given _tag: Tag[PFNGLGETFLOATINDEXEDVEXTPROC] = Tag.materializeCFuncPtr3[GLenum, GLuint, Ptr[GLfloat], Unit]
    inline def fromPtr(ptr: Ptr[Byte] | Ptr[?]): PFNGLGETFLOATINDEXEDVEXTPROC = CFuncPtr.fromPtr(ptr.asInstanceOf[Ptr[Byte]])
    inline def apply(inline o: CFuncPtr3[GLenum, GLuint, Ptr[GLfloat], Unit]): PFNGLGETFLOATINDEXEDVEXTPROC = o
    extension (v: PFNGLGETFLOATINDEXEDVEXTPROC)
      inline def value: CFuncPtr3[GLenum, GLuint, Ptr[GLfloat], Unit] = v
      inline def toPtr: Ptr[?] = CFuncPtr.toPtr(v)

  opaque type PFNGLGETFLOATI_VEXTPROC = CFuncPtr3[GLenum, GLuint, Ptr[GLfloat], Unit]
  object PFNGLGETFLOATI_VEXTPROC:
    given _tag: Tag[PFNGLGETFLOATI_VEXTPROC] = Tag.materializeCFuncPtr3[GLenum, GLuint, Ptr[GLfloat], Unit]
    inline def fromPtr(ptr: Ptr[Byte] | Ptr[?]): PFNGLGETFLOATI_VEXTPROC = CFuncPtr.fromPtr(ptr.asInstanceOf[Ptr[Byte]])
    inline def apply(inline o: CFuncPtr3[GLenum, GLuint, Ptr[GLfloat], Unit]): PFNGLGETFLOATI_VEXTPROC = o
    extension (v: PFNGLGETFLOATI_VEXTPROC)
      inline def value: CFuncPtr3[GLenum, GLuint, Ptr[GLfloat], Unit] = v
      inline def toPtr: Ptr[?] = CFuncPtr.toPtr(v)

  opaque type PFNGLGETFLOATI_VNVPROC = CFuncPtr3[GLenum, GLuint, Ptr[GLfloat], Unit]
  object PFNGLGETFLOATI_VNVPROC:
    given _tag: Tag[PFNGLGETFLOATI_VNVPROC] = Tag.materializeCFuncPtr3[GLenum, GLuint, Ptr[GLfloat], Unit]
    inline def fromPtr(ptr: Ptr[Byte] | Ptr[?]): PFNGLGETFLOATI_VNVPROC = CFuncPtr.fromPtr(ptr.asInstanceOf[Ptr[Byte]])
    inline def apply(inline o: CFuncPtr3[GLenum, GLuint, Ptr[GLfloat], Unit]): PFNGLGETFLOATI_VNVPROC = o
    extension (v: PFNGLGETFLOATI_VNVPROC)
      inline def value: CFuncPtr3[GLenum, GLuint, Ptr[GLfloat], Unit] = v
      inline def toPtr: Ptr[?] = CFuncPtr.toPtr(v)

  opaque type PFNGLGETFLOATI_VPROC = CFuncPtr3[GLenum, GLuint, Ptr[GLfloat], Unit]
  object PFNGLGETFLOATI_VPROC:
    given _tag: Tag[PFNGLGETFLOATI_VPROC] = Tag.materializeCFuncPtr3[GLenum, GLuint, Ptr[GLfloat], Unit]
    inline def fromPtr(ptr: Ptr[Byte] | Ptr[?]): PFNGLGETFLOATI_VPROC = CFuncPtr.fromPtr(ptr.asInstanceOf[Ptr[Byte]])
    inline def apply(inline o: CFuncPtr3[GLenum, GLuint, Ptr[GLfloat], Unit]): PFNGLGETFLOATI_VPROC = o
    extension (v: PFNGLGETFLOATI_VPROC)
      inline def value: CFuncPtr3[GLenum, GLuint, Ptr[GLfloat], Unit] = v
      inline def toPtr: Ptr[?] = CFuncPtr.toPtr(v)

  opaque type PFNGLGETFOGFUNCSGISPROC = CFuncPtr1[Ptr[GLfloat], Unit]
  object PFNGLGETFOGFUNCSGISPROC:
    given _tag: Tag[PFNGLGETFOGFUNCSGISPROC] = Tag.materializeCFuncPtr1[Ptr[GLfloat], Unit]
    inline def fromPtr(ptr: Ptr[Byte] | Ptr[?]): PFNGLGETFOGFUNCSGISPROC = CFuncPtr.fromPtr(ptr.asInstanceOf[Ptr[Byte]])
    inline def apply(inline o: CFuncPtr1[Ptr[GLfloat], Unit]): PFNGLGETFOGFUNCSGISPROC = o
    extension (v: PFNGLGETFOGFUNCSGISPROC)
      inline def value: CFuncPtr1[Ptr[GLfloat], Unit] = v
      inline def toPtr: Ptr[?] = CFuncPtr.toPtr(v)

  opaque type PFNGLGETFOGLAYERSSGIXPROC = CFuncPtr1[Ptr[GLfloat], Unit]
  object PFNGLGETFOGLAYERSSGIXPROC:
    given _tag: Tag[PFNGLGETFOGLAYERSSGIXPROC] = Tag.materializeCFuncPtr1[Ptr[GLfloat], Unit]
    inline def fromPtr(ptr: Ptr[Byte] | Ptr[?]): PFNGLGETFOGLAYERSSGIXPROC = CFuncPtr.fromPtr(ptr.asInstanceOf[Ptr[Byte]])
    inline def apply(inline o: CFuncPtr1[Ptr[GLfloat], Unit]): PFNGLGETFOGLAYERSSGIXPROC = o
    extension (v: PFNGLGETFOGLAYERSSGIXPROC)
      inline def value: CFuncPtr1[Ptr[GLfloat], Unit] = v
      inline def toPtr: Ptr[?] = CFuncPtr.toPtr(v)

  opaque type PFNGLGETFRAGDATAINDEXEXTPROC = CFuncPtr2[GLuint, Ptr[GLchar], GLint]
  object PFNGLGETFRAGDATAINDEXEXTPROC:
    given _tag: Tag[PFNGLGETFRAGDATAINDEXEXTPROC] = Tag.materializeCFuncPtr2[GLuint, Ptr[GLchar], GLint]
    inline def fromPtr(ptr: Ptr[Byte] | Ptr[?]): PFNGLGETFRAGDATAINDEXEXTPROC = CFuncPtr.fromPtr(ptr.asInstanceOf[Ptr[Byte]])
    inline def apply(inline o: CFuncPtr2[GLuint, Ptr[GLchar], GLint]): PFNGLGETFRAGDATAINDEXEXTPROC = o
    extension (v: PFNGLGETFRAGDATAINDEXEXTPROC)
      inline def value: CFuncPtr2[GLuint, Ptr[GLchar], GLint] = v
      inline def toPtr: Ptr[?] = CFuncPtr.toPtr(v)

  opaque type PFNGLGETFRAGDATAINDEXPROC = CFuncPtr2[GLuint, Ptr[GLchar], GLint]
  object PFNGLGETFRAGDATAINDEXPROC:
    given _tag: Tag[PFNGLGETFRAGDATAINDEXPROC] = Tag.materializeCFuncPtr2[GLuint, Ptr[GLchar], GLint]
    inline def fromPtr(ptr: Ptr[Byte] | Ptr[?]): PFNGLGETFRAGDATAINDEXPROC = CFuncPtr.fromPtr(ptr.asInstanceOf[Ptr[Byte]])
    inline def apply(inline o: CFuncPtr2[GLuint, Ptr[GLchar], GLint]): PFNGLGETFRAGDATAINDEXPROC = o
    extension (v: PFNGLGETFRAGDATAINDEXPROC)
      inline def value: CFuncPtr2[GLuint, Ptr[GLchar], GLint] = v
      inline def toPtr: Ptr[?] = CFuncPtr.toPtr(v)

  opaque type PFNGLGETFRAGDATALOCATIONEXTPROC = CFuncPtr2[GLuint, Ptr[GLchar], GLint]
  object PFNGLGETFRAGDATALOCATIONEXTPROC:
    given _tag: Tag[PFNGLGETFRAGDATALOCATIONEXTPROC] = Tag.materializeCFuncPtr2[GLuint, Ptr[GLchar], GLint]
    inline def fromPtr(ptr: Ptr[Byte] | Ptr[?]): PFNGLGETFRAGDATALOCATIONEXTPROC = CFuncPtr.fromPtr(ptr.asInstanceOf[Ptr[Byte]])
    inline def apply(inline o: CFuncPtr2[GLuint, Ptr[GLchar], GLint]): PFNGLGETFRAGDATALOCATIONEXTPROC = o
    extension (v: PFNGLGETFRAGDATALOCATIONEXTPROC)
      inline def value: CFuncPtr2[GLuint, Ptr[GLchar], GLint] = v
      inline def toPtr: Ptr[?] = CFuncPtr.toPtr(v)

  opaque type PFNGLGETFRAGDATALOCATIONPROC = CFuncPtr2[GLuint, Ptr[GLchar], GLint]
  object PFNGLGETFRAGDATALOCATIONPROC:
    given _tag: Tag[PFNGLGETFRAGDATALOCATIONPROC] = Tag.materializeCFuncPtr2[GLuint, Ptr[GLchar], GLint]
    inline def fromPtr(ptr: Ptr[Byte] | Ptr[?]): PFNGLGETFRAGDATALOCATIONPROC = CFuncPtr.fromPtr(ptr.asInstanceOf[Ptr[Byte]])
    inline def apply(inline o: CFuncPtr2[GLuint, Ptr[GLchar], GLint]): PFNGLGETFRAGDATALOCATIONPROC = o
    extension (v: PFNGLGETFRAGDATALOCATIONPROC)
      inline def value: CFuncPtr2[GLuint, Ptr[GLchar], GLint] = v
      inline def toPtr: Ptr[?] = CFuncPtr.toPtr(v)

  opaque type PFNGLGETFRAGMENTLIGHTFVEXTPROC = CFuncPtr3[GLenum, GLenum, Ptr[GLfloat], Unit]
  object PFNGLGETFRAGMENTLIGHTFVEXTPROC:
    given _tag: Tag[PFNGLGETFRAGMENTLIGHTFVEXTPROC] = Tag.materializeCFuncPtr3[GLenum, GLenum, Ptr[GLfloat], Unit]
    inline def fromPtr(ptr: Ptr[Byte] | Ptr[?]): PFNGLGETFRAGMENTLIGHTFVEXTPROC = CFuncPtr.fromPtr(ptr.asInstanceOf[Ptr[Byte]])
    inline def apply(inline o: CFuncPtr3[GLenum, GLenum, Ptr[GLfloat], Unit]): PFNGLGETFRAGMENTLIGHTFVEXTPROC = o
    extension (v: PFNGLGETFRAGMENTLIGHTFVEXTPROC)
      inline def value: CFuncPtr3[GLenum, GLenum, Ptr[GLfloat], Unit] = v
      inline def toPtr: Ptr[?] = CFuncPtr.toPtr(v)

  opaque type PFNGLGETFRAGMENTLIGHTFVSGIXPROC = CFuncPtr3[GLenum, GLenum, Ptr[GLfloat], Unit]
  object PFNGLGETFRAGMENTLIGHTFVSGIXPROC:
    given _tag: Tag[PFNGLGETFRAGMENTLIGHTFVSGIXPROC] = Tag.materializeCFuncPtr3[GLenum, GLenum, Ptr[GLfloat], Unit]
    inline def fromPtr(ptr: Ptr[Byte] | Ptr[?]): PFNGLGETFRAGMENTLIGHTFVSGIXPROC = CFuncPtr.fromPtr(ptr.asInstanceOf[Ptr[Byte]])
    inline def apply(inline o: CFuncPtr3[GLenum, GLenum, Ptr[GLfloat], Unit]): PFNGLGETFRAGMENTLIGHTFVSGIXPROC = o
    extension (v: PFNGLGETFRAGMENTLIGHTFVSGIXPROC)
      inline def value: CFuncPtr3[GLenum, GLenum, Ptr[GLfloat], Unit] = v
      inline def toPtr: Ptr[?] = CFuncPtr.toPtr(v)

  opaque type PFNGLGETFRAGMENTLIGHTIVEXTPROC = CFuncPtr3[GLenum, GLenum, Ptr[GLint], Unit]
  object PFNGLGETFRAGMENTLIGHTIVEXTPROC:
    given _tag: Tag[PFNGLGETFRAGMENTLIGHTIVEXTPROC] = Tag.materializeCFuncPtr3[GLenum, GLenum, Ptr[GLint], Unit]
    inline def fromPtr(ptr: Ptr[Byte] | Ptr[?]): PFNGLGETFRAGMENTLIGHTIVEXTPROC = CFuncPtr.fromPtr(ptr.asInstanceOf[Ptr[Byte]])
    inline def apply(inline o: CFuncPtr3[GLenum, GLenum, Ptr[GLint], Unit]): PFNGLGETFRAGMENTLIGHTIVEXTPROC = o
    extension (v: PFNGLGETFRAGMENTLIGHTIVEXTPROC)
      inline def value: CFuncPtr3[GLenum, GLenum, Ptr[GLint], Unit] = v
      inline def toPtr: Ptr[?] = CFuncPtr.toPtr(v)

  opaque type PFNGLGETFRAGMENTLIGHTIVSGIXPROC = CFuncPtr3[GLenum, GLenum, Ptr[GLint], Unit]
  object PFNGLGETFRAGMENTLIGHTIVSGIXPROC:
    given _tag: Tag[PFNGLGETFRAGMENTLIGHTIVSGIXPROC] = Tag.materializeCFuncPtr3[GLenum, GLenum, Ptr[GLint], Unit]
    inline def fromPtr(ptr: Ptr[Byte] | Ptr[?]): PFNGLGETFRAGMENTLIGHTIVSGIXPROC = CFuncPtr.fromPtr(ptr.asInstanceOf[Ptr[Byte]])
    inline def apply(inline o: CFuncPtr3[GLenum, GLenum, Ptr[GLint], Unit]): PFNGLGETFRAGMENTLIGHTIVSGIXPROC = o
    extension (v: PFNGLGETFRAGMENTLIGHTIVSGIXPROC)
      inline def value: CFuncPtr3[GLenum, GLenum, Ptr[GLint], Unit] = v
      inline def toPtr: Ptr[?] = CFuncPtr.toPtr(v)

  opaque type PFNGLGETFRAGMENTMATERIALFVEXTPROC = CFuncPtr3[GLenum, GLenum, Ptr[GLfloat], Unit]
  object PFNGLGETFRAGMENTMATERIALFVEXTPROC:
    given _tag: Tag[PFNGLGETFRAGMENTMATERIALFVEXTPROC] = Tag.materializeCFuncPtr3[GLenum, GLenum, Ptr[GLfloat], Unit]
    inline def fromPtr(ptr: Ptr[Byte] | Ptr[?]): PFNGLGETFRAGMENTMATERIALFVEXTPROC = CFuncPtr.fromPtr(ptr.asInstanceOf[Ptr[Byte]])
    inline def apply(inline o: CFuncPtr3[GLenum, GLenum, Ptr[GLfloat], Unit]): PFNGLGETFRAGMENTMATERIALFVEXTPROC = o
    extension (v: PFNGLGETFRAGMENTMATERIALFVEXTPROC)
      inline def value: CFuncPtr3[GLenum, GLenum, Ptr[GLfloat], Unit] = v
      inline def toPtr: Ptr[?] = CFuncPtr.toPtr(v)

  opaque type PFNGLGETFRAGMENTMATERIALFVSGIXPROC = CFuncPtr3[GLenum, GLenum, Ptr[GLfloat], Unit]
  object PFNGLGETFRAGMENTMATERIALFVSGIXPROC:
    given _tag: Tag[PFNGLGETFRAGMENTMATERIALFVSGIXPROC] = Tag.materializeCFuncPtr3[GLenum, GLenum, Ptr[GLfloat], Unit]
    inline def fromPtr(ptr: Ptr[Byte] | Ptr[?]): PFNGLGETFRAGMENTMATERIALFVSGIXPROC = CFuncPtr.fromPtr(ptr.asInstanceOf[Ptr[Byte]])
    inline def apply(inline o: CFuncPtr3[GLenum, GLenum, Ptr[GLfloat], Unit]): PFNGLGETFRAGMENTMATERIALFVSGIXPROC = o
    extension (v: PFNGLGETFRAGMENTMATERIALFVSGIXPROC)
      inline def value: CFuncPtr3[GLenum, GLenum, Ptr[GLfloat], Unit] = v
      inline def toPtr: Ptr[?] = CFuncPtr.toPtr(v)

  opaque type PFNGLGETFRAGMENTMATERIALIVEXTPROC = CFuncPtr3[GLenum, GLenum, Ptr[GLint], Unit]
  object PFNGLGETFRAGMENTMATERIALIVEXTPROC:
    given _tag: Tag[PFNGLGETFRAGMENTMATERIALIVEXTPROC] = Tag.materializeCFuncPtr3[GLenum, GLenum, Ptr[GLint], Unit]
    inline def fromPtr(ptr: Ptr[Byte] | Ptr[?]): PFNGLGETFRAGMENTMATERIALIVEXTPROC = CFuncPtr.fromPtr(ptr.asInstanceOf[Ptr[Byte]])
    inline def apply(inline o: CFuncPtr3[GLenum, GLenum, Ptr[GLint], Unit]): PFNGLGETFRAGMENTMATERIALIVEXTPROC = o
    extension (v: PFNGLGETFRAGMENTMATERIALIVEXTPROC)
      inline def value: CFuncPtr3[GLenum, GLenum, Ptr[GLint], Unit] = v
      inline def toPtr: Ptr[?] = CFuncPtr.toPtr(v)

  opaque type PFNGLGETFRAGMENTMATERIALIVSGIXPROC = CFuncPtr3[GLenum, GLenum, Ptr[GLint], Unit]
  object PFNGLGETFRAGMENTMATERIALIVSGIXPROC:
    given _tag: Tag[PFNGLGETFRAGMENTMATERIALIVSGIXPROC] = Tag.materializeCFuncPtr3[GLenum, GLenum, Ptr[GLint], Unit]
    inline def fromPtr(ptr: Ptr[Byte] | Ptr[?]): PFNGLGETFRAGMENTMATERIALIVSGIXPROC = CFuncPtr.fromPtr(ptr.asInstanceOf[Ptr[Byte]])
    inline def apply(inline o: CFuncPtr3[GLenum, GLenum, Ptr[GLint], Unit]): PFNGLGETFRAGMENTMATERIALIVSGIXPROC = o
    extension (v: PFNGLGETFRAGMENTMATERIALIVSGIXPROC)
      inline def value: CFuncPtr3[GLenum, GLenum, Ptr[GLint], Unit] = v
      inline def toPtr: Ptr[?] = CFuncPtr.toPtr(v)

  opaque type PFNGLGETFRAMEBUFFERATTACHMENTPARAMETERIVEXTPROC = CFuncPtr4[GLenum, GLenum, GLenum, Ptr[GLint], Unit]
  object PFNGLGETFRAMEBUFFERATTACHMENTPARAMETERIVEXTPROC:
    given _tag: Tag[PFNGLGETFRAMEBUFFERATTACHMENTPARAMETERIVEXTPROC] = Tag.materializeCFuncPtr4[GLenum, GLenum, GLenum, Ptr[GLint], Unit]
    inline def fromPtr(ptr: Ptr[Byte] | Ptr[?]): PFNGLGETFRAMEBUFFERATTACHMENTPARAMETERIVEXTPROC = CFuncPtr.fromPtr(ptr.asInstanceOf[Ptr[Byte]])
    inline def apply(inline o: CFuncPtr4[GLenum, GLenum, GLenum, Ptr[GLint], Unit]): PFNGLGETFRAMEBUFFERATTACHMENTPARAMETERIVEXTPROC = o
    extension (v: PFNGLGETFRAMEBUFFERATTACHMENTPARAMETERIVEXTPROC)
      inline def value: CFuncPtr4[GLenum, GLenum, GLenum, Ptr[GLint], Unit] = v
      inline def toPtr: Ptr[?] = CFuncPtr.toPtr(v)

  opaque type PFNGLGETFRAMEBUFFERATTACHMENTPARAMETERIVOESPROC = CFuncPtr4[GLenum, GLenum, GLenum, Ptr[GLint], Unit]
  object PFNGLGETFRAMEBUFFERATTACHMENTPARAMETERIVOESPROC:
    given _tag: Tag[PFNGLGETFRAMEBUFFERATTACHMENTPARAMETERIVOESPROC] = Tag.materializeCFuncPtr4[GLenum, GLenum, GLenum, Ptr[GLint], Unit]
    inline def fromPtr(ptr: Ptr[Byte] | Ptr[?]): PFNGLGETFRAMEBUFFERATTACHMENTPARAMETERIVOESPROC = CFuncPtr.fromPtr(ptr.asInstanceOf[Ptr[Byte]])
    inline def apply(inline o: CFuncPtr4[GLenum, GLenum, GLenum, Ptr[GLint], Unit]): PFNGLGETFRAMEBUFFERATTACHMENTPARAMETERIVOESPROC = o
    extension (v: PFNGLGETFRAMEBUFFERATTACHMENTPARAMETERIVOESPROC)
      inline def value: CFuncPtr4[GLenum, GLenum, GLenum, Ptr[GLint], Unit] = v
      inline def toPtr: Ptr[?] = CFuncPtr.toPtr(v)

  opaque type PFNGLGETFRAMEBUFFERATTACHMENTPARAMETERIVPROC = CFuncPtr4[GLenum, GLenum, GLenum, Ptr[GLint], Unit]
  object PFNGLGETFRAMEBUFFERATTACHMENTPARAMETERIVPROC:
    given _tag: Tag[PFNGLGETFRAMEBUFFERATTACHMENTPARAMETERIVPROC] = Tag.materializeCFuncPtr4[GLenum, GLenum, GLenum, Ptr[GLint], Unit]
    inline def fromPtr(ptr: Ptr[Byte] | Ptr[?]): PFNGLGETFRAMEBUFFERATTACHMENTPARAMETERIVPROC = CFuncPtr.fromPtr(ptr.asInstanceOf[Ptr[Byte]])
    inline def apply(inline o: CFuncPtr4[GLenum, GLenum, GLenum, Ptr[GLint], Unit]): PFNGLGETFRAMEBUFFERATTACHMENTPARAMETERIVPROC = o
    extension (v: PFNGLGETFRAMEBUFFERATTACHMENTPARAMETERIVPROC)
      inline def value: CFuncPtr4[GLenum, GLenum, GLenum, Ptr[GLint], Unit] = v
      inline def toPtr: Ptr[?] = CFuncPtr.toPtr(v)

  opaque type PFNGLGETFRAMEBUFFERPARAMETERFVAMDPROC = CFuncPtr6[GLenum, GLenum, GLuint, GLuint, GLsizei, Ptr[GLfloat], Unit]
  object PFNGLGETFRAMEBUFFERPARAMETERFVAMDPROC:
    given _tag: Tag[PFNGLGETFRAMEBUFFERPARAMETERFVAMDPROC] = Tag.materializeCFuncPtr6[GLenum, GLenum, GLuint, GLuint, GLsizei, Ptr[GLfloat], Unit]
    inline def fromPtr(ptr: Ptr[Byte] | Ptr[?]): PFNGLGETFRAMEBUFFERPARAMETERFVAMDPROC = CFuncPtr.fromPtr(ptr.asInstanceOf[Ptr[Byte]])
    inline def apply(inline o: CFuncPtr6[GLenum, GLenum, GLuint, GLuint, GLsizei, Ptr[GLfloat], Unit]): PFNGLGETFRAMEBUFFERPARAMETERFVAMDPROC = o
    extension (v: PFNGLGETFRAMEBUFFERPARAMETERFVAMDPROC)
      inline def value: CFuncPtr6[GLenum, GLenum, GLuint, GLuint, GLsizei, Ptr[GLfloat], Unit] = v
      inline def toPtr: Ptr[?] = CFuncPtr.toPtr(v)

  opaque type PFNGLGETFRAMEBUFFERPARAMETERIVEXTPROC = CFuncPtr3[GLuint, GLenum, Ptr[GLint], Unit]
  object PFNGLGETFRAMEBUFFERPARAMETERIVEXTPROC:
    given _tag: Tag[PFNGLGETFRAMEBUFFERPARAMETERIVEXTPROC] = Tag.materializeCFuncPtr3[GLuint, GLenum, Ptr[GLint], Unit]
    inline def fromPtr(ptr: Ptr[Byte] | Ptr[?]): PFNGLGETFRAMEBUFFERPARAMETERIVEXTPROC = CFuncPtr.fromPtr(ptr.asInstanceOf[Ptr[Byte]])
    inline def apply(inline o: CFuncPtr3[GLuint, GLenum, Ptr[GLint], Unit]): PFNGLGETFRAMEBUFFERPARAMETERIVEXTPROC = o
    extension (v: PFNGLGETFRAMEBUFFERPARAMETERIVEXTPROC)
      inline def value: CFuncPtr3[GLuint, GLenum, Ptr[GLint], Unit] = v
      inline def toPtr: Ptr[?] = CFuncPtr.toPtr(v)

  opaque type PFNGLGETFRAMEBUFFERPARAMETERIVMESAPROC = CFuncPtr3[GLenum, GLenum, Ptr[GLint], Unit]
  object PFNGLGETFRAMEBUFFERPARAMETERIVMESAPROC:
    given _tag: Tag[PFNGLGETFRAMEBUFFERPARAMETERIVMESAPROC] = Tag.materializeCFuncPtr3[GLenum, GLenum, Ptr[GLint], Unit]
    inline def fromPtr(ptr: Ptr[Byte] | Ptr[?]): PFNGLGETFRAMEBUFFERPARAMETERIVMESAPROC = CFuncPtr.fromPtr(ptr.asInstanceOf[Ptr[Byte]])
    inline def apply(inline o: CFuncPtr3[GLenum, GLenum, Ptr[GLint], Unit]): PFNGLGETFRAMEBUFFERPARAMETERIVMESAPROC = o
    extension (v: PFNGLGETFRAMEBUFFERPARAMETERIVMESAPROC)
      inline def value: CFuncPtr3[GLenum, GLenum, Ptr[GLint], Unit] = v
      inline def toPtr: Ptr[?] = CFuncPtr.toPtr(v)

  opaque type PFNGLGETFRAMEBUFFERPARAMETERIVPROC = CFuncPtr3[GLenum, GLenum, Ptr[GLint], Unit]
  object PFNGLGETFRAMEBUFFERPARAMETERIVPROC:
    given _tag: Tag[PFNGLGETFRAMEBUFFERPARAMETERIVPROC] = Tag.materializeCFuncPtr3[GLenum, GLenum, Ptr[GLint], Unit]
    inline def fromPtr(ptr: Ptr[Byte] | Ptr[?]): PFNGLGETFRAMEBUFFERPARAMETERIVPROC = CFuncPtr.fromPtr(ptr.asInstanceOf[Ptr[Byte]])
    inline def apply(inline o: CFuncPtr3[GLenum, GLenum, Ptr[GLint], Unit]): PFNGLGETFRAMEBUFFERPARAMETERIVPROC = o
    extension (v: PFNGLGETFRAMEBUFFERPARAMETERIVPROC)
      inline def value: CFuncPtr3[GLenum, GLenum, Ptr[GLint], Unit] = v
      inline def toPtr: Ptr[?] = CFuncPtr.toPtr(v)

  opaque type PFNGLGETFRAMEBUFFERPIXELLOCALSTORAGESIZEEXTPROC = CFuncPtr1[GLuint, GLsizei]
  object PFNGLGETFRAMEBUFFERPIXELLOCALSTORAGESIZEEXTPROC:
    given _tag: Tag[PFNGLGETFRAMEBUFFERPIXELLOCALSTORAGESIZEEXTPROC] = Tag.materializeCFuncPtr1[GLuint, GLsizei]
    inline def fromPtr(ptr: Ptr[Byte] | Ptr[?]): PFNGLGETFRAMEBUFFERPIXELLOCALSTORAGESIZEEXTPROC = CFuncPtr.fromPtr(ptr.asInstanceOf[Ptr[Byte]])
    inline def apply(inline o: CFuncPtr1[GLuint, GLsizei]): PFNGLGETFRAMEBUFFERPIXELLOCALSTORAGESIZEEXTPROC = o
    extension (v: PFNGLGETFRAMEBUFFERPIXELLOCALSTORAGESIZEEXTPROC)
      inline def value: CFuncPtr1[GLuint, GLsizei] = v
      inline def toPtr: Ptr[?] = CFuncPtr.toPtr(v)

  opaque type PFNGLGETGRAPHICSRESETSTATUSARBPROC = CFuncPtr0[GLenum]
  object PFNGLGETGRAPHICSRESETSTATUSARBPROC:
    given _tag: Tag[PFNGLGETGRAPHICSRESETSTATUSARBPROC] = Tag.materializeCFuncPtr0[GLenum]
    inline def fromPtr(ptr: Ptr[Byte] | Ptr[?]): PFNGLGETGRAPHICSRESETSTATUSARBPROC = CFuncPtr.fromPtr(ptr.asInstanceOf[Ptr[Byte]])
    inline def apply(inline o: CFuncPtr0[GLenum]): PFNGLGETGRAPHICSRESETSTATUSARBPROC = o
    extension (v: PFNGLGETGRAPHICSRESETSTATUSARBPROC)
      inline def value: CFuncPtr0[GLenum] = v
      inline def toPtr: Ptr[?] = CFuncPtr.toPtr(v)

  opaque type PFNGLGETGRAPHICSRESETSTATUSPROC = CFuncPtr0[GLenum]
  object PFNGLGETGRAPHICSRESETSTATUSPROC:
    given _tag: Tag[PFNGLGETGRAPHICSRESETSTATUSPROC] = Tag.materializeCFuncPtr0[GLenum]
    inline def fromPtr(ptr: Ptr[Byte] | Ptr[?]): PFNGLGETGRAPHICSRESETSTATUSPROC = CFuncPtr.fromPtr(ptr.asInstanceOf[Ptr[Byte]])
    inline def apply(inline o: CFuncPtr0[GLenum]): PFNGLGETGRAPHICSRESETSTATUSPROC = o
    extension (v: PFNGLGETGRAPHICSRESETSTATUSPROC)
      inline def value: CFuncPtr0[GLenum] = v
      inline def toPtr: Ptr[?] = CFuncPtr.toPtr(v)

  opaque type PFNGLGETHANDLEARBPROC = CFuncPtr1[GLenum, GLhandleARB]
  object PFNGLGETHANDLEARBPROC:
    given _tag: Tag[PFNGLGETHANDLEARBPROC] = Tag.materializeCFuncPtr1[GLenum, GLhandleARB]
    inline def fromPtr(ptr: Ptr[Byte] | Ptr[?]): PFNGLGETHANDLEARBPROC = CFuncPtr.fromPtr(ptr.asInstanceOf[Ptr[Byte]])
    inline def apply(inline o: CFuncPtr1[GLenum, GLhandleARB]): PFNGLGETHANDLEARBPROC = o
    extension (v: PFNGLGETHANDLEARBPROC)
      inline def value: CFuncPtr1[GLenum, GLhandleARB] = v
      inline def toPtr: Ptr[?] = CFuncPtr.toPtr(v)

  opaque type PFNGLGETHISTOGRAMEXTPROC = CFuncPtr5[GLenum, GLboolean, GLenum, GLenum, Ptr[Byte], Unit]
  object PFNGLGETHISTOGRAMEXTPROC:
    given _tag: Tag[PFNGLGETHISTOGRAMEXTPROC] = Tag.materializeCFuncPtr5[GLenum, GLboolean, GLenum, GLenum, Ptr[Byte], Unit]
    inline def fromPtr(ptr: Ptr[Byte] | Ptr[?]): PFNGLGETHISTOGRAMEXTPROC = CFuncPtr.fromPtr(ptr.asInstanceOf[Ptr[Byte]])
    inline def apply(inline o: CFuncPtr5[GLenum, GLboolean, GLenum, GLenum, Ptr[Byte], Unit]): PFNGLGETHISTOGRAMEXTPROC = o
    extension (v: PFNGLGETHISTOGRAMEXTPROC)
      inline def value: CFuncPtr5[GLenum, GLboolean, GLenum, GLenum, Ptr[Byte], Unit] = v
      inline def toPtr: Ptr[?] = CFuncPtr.toPtr(v)

  opaque type PFNGLGETHISTOGRAMPARAMETERFVEXTPROC = CFuncPtr3[GLenum, GLenum, Ptr[GLfloat], Unit]
  object PFNGLGETHISTOGRAMPARAMETERFVEXTPROC:
    given _tag: Tag[PFNGLGETHISTOGRAMPARAMETERFVEXTPROC] = Tag.materializeCFuncPtr3[GLenum, GLenum, Ptr[GLfloat], Unit]
    inline def fromPtr(ptr: Ptr[Byte] | Ptr[?]): PFNGLGETHISTOGRAMPARAMETERFVEXTPROC = CFuncPtr.fromPtr(ptr.asInstanceOf[Ptr[Byte]])
    inline def apply(inline o: CFuncPtr3[GLenum, GLenum, Ptr[GLfloat], Unit]): PFNGLGETHISTOGRAMPARAMETERFVEXTPROC = o
    extension (v: PFNGLGETHISTOGRAMPARAMETERFVEXTPROC)
      inline def value: CFuncPtr3[GLenum, GLenum, Ptr[GLfloat], Unit] = v
      inline def toPtr: Ptr[?] = CFuncPtr.toPtr(v)

  opaque type PFNGLGETHISTOGRAMPARAMETERFVPROC = CFuncPtr3[GLenum, GLenum, Ptr[GLfloat], Unit]
  object PFNGLGETHISTOGRAMPARAMETERFVPROC:
    given _tag: Tag[PFNGLGETHISTOGRAMPARAMETERFVPROC] = Tag.materializeCFuncPtr3[GLenum, GLenum, Ptr[GLfloat], Unit]
    inline def fromPtr(ptr: Ptr[Byte] | Ptr[?]): PFNGLGETHISTOGRAMPARAMETERFVPROC = CFuncPtr.fromPtr(ptr.asInstanceOf[Ptr[Byte]])
    inline def apply(inline o: CFuncPtr3[GLenum, GLenum, Ptr[GLfloat], Unit]): PFNGLGETHISTOGRAMPARAMETERFVPROC = o
    extension (v: PFNGLGETHISTOGRAMPARAMETERFVPROC)
      inline def value: CFuncPtr3[GLenum, GLenum, Ptr[GLfloat], Unit] = v
      inline def toPtr: Ptr[?] = CFuncPtr.toPtr(v)

  opaque type PFNGLGETHISTOGRAMPARAMETERIVEXTPROC = CFuncPtr3[GLenum, GLenum, Ptr[GLint], Unit]
  object PFNGLGETHISTOGRAMPARAMETERIVEXTPROC:
    given _tag: Tag[PFNGLGETHISTOGRAMPARAMETERIVEXTPROC] = Tag.materializeCFuncPtr3[GLenum, GLenum, Ptr[GLint], Unit]
    inline def fromPtr(ptr: Ptr[Byte] | Ptr[?]): PFNGLGETHISTOGRAMPARAMETERIVEXTPROC = CFuncPtr.fromPtr(ptr.asInstanceOf[Ptr[Byte]])
    inline def apply(inline o: CFuncPtr3[GLenum, GLenum, Ptr[GLint], Unit]): PFNGLGETHISTOGRAMPARAMETERIVEXTPROC = o
    extension (v: PFNGLGETHISTOGRAMPARAMETERIVEXTPROC)
      inline def value: CFuncPtr3[GLenum, GLenum, Ptr[GLint], Unit] = v
      inline def toPtr: Ptr[?] = CFuncPtr.toPtr(v)

  opaque type PFNGLGETHISTOGRAMPARAMETERIVPROC = CFuncPtr3[GLenum, GLenum, Ptr[GLint], Unit]
  object PFNGLGETHISTOGRAMPARAMETERIVPROC:
    given _tag: Tag[PFNGLGETHISTOGRAMPARAMETERIVPROC] = Tag.materializeCFuncPtr3[GLenum, GLenum, Ptr[GLint], Unit]
    inline def fromPtr(ptr: Ptr[Byte] | Ptr[?]): PFNGLGETHISTOGRAMPARAMETERIVPROC = CFuncPtr.fromPtr(ptr.asInstanceOf[Ptr[Byte]])
    inline def apply(inline o: CFuncPtr3[GLenum, GLenum, Ptr[GLint], Unit]): PFNGLGETHISTOGRAMPARAMETERIVPROC = o
    extension (v: PFNGLGETHISTOGRAMPARAMETERIVPROC)
      inline def value: CFuncPtr3[GLenum, GLenum, Ptr[GLint], Unit] = v
      inline def toPtr: Ptr[?] = CFuncPtr.toPtr(v)

  opaque type PFNGLGETHISTOGRAMPROC = CFuncPtr5[GLenum, GLboolean, GLenum, GLenum, Ptr[Byte], Unit]
  object PFNGLGETHISTOGRAMPROC:
    given _tag: Tag[PFNGLGETHISTOGRAMPROC] = Tag.materializeCFuncPtr5[GLenum, GLboolean, GLenum, GLenum, Ptr[Byte], Unit]
    inline def fromPtr(ptr: Ptr[Byte] | Ptr[?]): PFNGLGETHISTOGRAMPROC = CFuncPtr.fromPtr(ptr.asInstanceOf[Ptr[Byte]])
    inline def apply(inline o: CFuncPtr5[GLenum, GLboolean, GLenum, GLenum, Ptr[Byte], Unit]): PFNGLGETHISTOGRAMPROC = o
    extension (v: PFNGLGETHISTOGRAMPROC)
      inline def value: CFuncPtr5[GLenum, GLboolean, GLenum, GLenum, Ptr[Byte], Unit] = v
      inline def toPtr: Ptr[?] = CFuncPtr.toPtr(v)

  opaque type PFNGLGETIMAGEHANDLEARBPROC = CFuncPtr5[GLuint, GLint, GLboolean, GLint, GLenum, GLuint64]
  object PFNGLGETIMAGEHANDLEARBPROC:
    given _tag: Tag[PFNGLGETIMAGEHANDLEARBPROC] = Tag.materializeCFuncPtr5[GLuint, GLint, GLboolean, GLint, GLenum, GLuint64]
    inline def fromPtr(ptr: Ptr[Byte] | Ptr[?]): PFNGLGETIMAGEHANDLEARBPROC = CFuncPtr.fromPtr(ptr.asInstanceOf[Ptr[Byte]])
    inline def apply(inline o: CFuncPtr5[GLuint, GLint, GLboolean, GLint, GLenum, GLuint64]): PFNGLGETIMAGEHANDLEARBPROC = o
    extension (v: PFNGLGETIMAGEHANDLEARBPROC)
      inline def value: CFuncPtr5[GLuint, GLint, GLboolean, GLint, GLenum, GLuint64] = v
      inline def toPtr: Ptr[?] = CFuncPtr.toPtr(v)

  opaque type PFNGLGETIMAGEHANDLENVPROC = CFuncPtr5[GLuint, GLint, GLboolean, GLint, GLenum, GLuint64]
  object PFNGLGETIMAGEHANDLENVPROC:
    given _tag: Tag[PFNGLGETIMAGEHANDLENVPROC] = Tag.materializeCFuncPtr5[GLuint, GLint, GLboolean, GLint, GLenum, GLuint64]
    inline def fromPtr(ptr: Ptr[Byte] | Ptr[?]): PFNGLGETIMAGEHANDLENVPROC = CFuncPtr.fromPtr(ptr.asInstanceOf[Ptr[Byte]])
    inline def apply(inline o: CFuncPtr5[GLuint, GLint, GLboolean, GLint, GLenum, GLuint64]): PFNGLGETIMAGEHANDLENVPROC = o
    extension (v: PFNGLGETIMAGEHANDLENVPROC)
      inline def value: CFuncPtr5[GLuint, GLint, GLboolean, GLint, GLenum, GLuint64] = v
      inline def toPtr: Ptr[?] = CFuncPtr.toPtr(v)

  opaque type PFNGLGETIMAGETRANSFORMPARAMETERFVHPPROC = CFuncPtr3[GLenum, GLenum, Ptr[GLfloat], Unit]
  object PFNGLGETIMAGETRANSFORMPARAMETERFVHPPROC:
    given _tag: Tag[PFNGLGETIMAGETRANSFORMPARAMETERFVHPPROC] = Tag.materializeCFuncPtr3[GLenum, GLenum, Ptr[GLfloat], Unit]
    inline def fromPtr(ptr: Ptr[Byte] | Ptr[?]): PFNGLGETIMAGETRANSFORMPARAMETERFVHPPROC = CFuncPtr.fromPtr(ptr.asInstanceOf[Ptr[Byte]])
    inline def apply(inline o: CFuncPtr3[GLenum, GLenum, Ptr[GLfloat], Unit]): PFNGLGETIMAGETRANSFORMPARAMETERFVHPPROC = o
    extension (v: PFNGLGETIMAGETRANSFORMPARAMETERFVHPPROC)
      inline def value: CFuncPtr3[GLenum, GLenum, Ptr[GLfloat], Unit] = v
      inline def toPtr: Ptr[?] = CFuncPtr.toPtr(v)

  opaque type PFNGLGETIMAGETRANSFORMPARAMETERIVHPPROC = CFuncPtr3[GLenum, GLenum, Ptr[GLint], Unit]
  object PFNGLGETIMAGETRANSFORMPARAMETERIVHPPROC:
    given _tag: Tag[PFNGLGETIMAGETRANSFORMPARAMETERIVHPPROC] = Tag.materializeCFuncPtr3[GLenum, GLenum, Ptr[GLint], Unit]
    inline def fromPtr(ptr: Ptr[Byte] | Ptr[?]): PFNGLGETIMAGETRANSFORMPARAMETERIVHPPROC = CFuncPtr.fromPtr(ptr.asInstanceOf[Ptr[Byte]])
    inline def apply(inline o: CFuncPtr3[GLenum, GLenum, Ptr[GLint], Unit]): PFNGLGETIMAGETRANSFORMPARAMETERIVHPPROC = o
    extension (v: PFNGLGETIMAGETRANSFORMPARAMETERIVHPPROC)
      inline def value: CFuncPtr3[GLenum, GLenum, Ptr[GLint], Unit] = v
      inline def toPtr: Ptr[?] = CFuncPtr.toPtr(v)

  opaque type PFNGLGETINFOLOGARBPROC = CFuncPtr4[GLhandleARB, GLsizei, Ptr[GLsizei], Ptr[GLcharARB], Unit]
  object PFNGLGETINFOLOGARBPROC:
    given _tag: Tag[PFNGLGETINFOLOGARBPROC] = Tag.materializeCFuncPtr4[GLhandleARB, GLsizei, Ptr[GLsizei], Ptr[GLcharARB], Unit]
    inline def fromPtr(ptr: Ptr[Byte] | Ptr[?]): PFNGLGETINFOLOGARBPROC = CFuncPtr.fromPtr(ptr.asInstanceOf[Ptr[Byte]])
    inline def apply(inline o: CFuncPtr4[GLhandleARB, GLsizei, Ptr[GLsizei], Ptr[GLcharARB], Unit]): PFNGLGETINFOLOGARBPROC = o
    extension (v: PFNGLGETINFOLOGARBPROC)
      inline def value: CFuncPtr4[GLhandleARB, GLsizei, Ptr[GLsizei], Ptr[GLcharARB], Unit] = v
      inline def toPtr: Ptr[?] = CFuncPtr.toPtr(v)

  opaque type PFNGLGETINTEGER64I_VPROC = CFuncPtr3[GLenum, GLuint, Ptr[GLint64], Unit]
  object PFNGLGETINTEGER64I_VPROC:
    given _tag: Tag[PFNGLGETINTEGER64I_VPROC] = Tag.materializeCFuncPtr3[GLenum, GLuint, Ptr[GLint64], Unit]
    inline def fromPtr(ptr: Ptr[Byte] | Ptr[?]): PFNGLGETINTEGER64I_VPROC = CFuncPtr.fromPtr(ptr.asInstanceOf[Ptr[Byte]])
    inline def apply(inline o: CFuncPtr3[GLenum, GLuint, Ptr[GLint64], Unit]): PFNGLGETINTEGER64I_VPROC = o
    extension (v: PFNGLGETINTEGER64I_VPROC)
      inline def value: CFuncPtr3[GLenum, GLuint, Ptr[GLint64], Unit] = v
      inline def toPtr: Ptr[?] = CFuncPtr.toPtr(v)

  opaque type PFNGLGETINTEGER64VAPPLEPROC = CFuncPtr2[GLenum, Ptr[GLint64], Unit]
  object PFNGLGETINTEGER64VAPPLEPROC:
    given _tag: Tag[PFNGLGETINTEGER64VAPPLEPROC] = Tag.materializeCFuncPtr2[GLenum, Ptr[GLint64], Unit]
    inline def fromPtr(ptr: Ptr[Byte] | Ptr[?]): PFNGLGETINTEGER64VAPPLEPROC = CFuncPtr.fromPtr(ptr.asInstanceOf[Ptr[Byte]])
    inline def apply(inline o: CFuncPtr2[GLenum, Ptr[GLint64], Unit]): PFNGLGETINTEGER64VAPPLEPROC = o
    extension (v: PFNGLGETINTEGER64VAPPLEPROC)
      inline def value: CFuncPtr2[GLenum, Ptr[GLint64], Unit] = v
      inline def toPtr: Ptr[?] = CFuncPtr.toPtr(v)

  opaque type PFNGLGETINTEGER64VEXTPROC = CFuncPtr2[GLenum, Ptr[GLint64], Unit]
  object PFNGLGETINTEGER64VEXTPROC:
    given _tag: Tag[PFNGLGETINTEGER64VEXTPROC] = Tag.materializeCFuncPtr2[GLenum, Ptr[GLint64], Unit]
    inline def fromPtr(ptr: Ptr[Byte] | Ptr[?]): PFNGLGETINTEGER64VEXTPROC = CFuncPtr.fromPtr(ptr.asInstanceOf[Ptr[Byte]])
    inline def apply(inline o: CFuncPtr2[GLenum, Ptr[GLint64], Unit]): PFNGLGETINTEGER64VEXTPROC = o
    extension (v: PFNGLGETINTEGER64VEXTPROC)
      inline def value: CFuncPtr2[GLenum, Ptr[GLint64], Unit] = v
      inline def toPtr: Ptr[?] = CFuncPtr.toPtr(v)

  opaque type PFNGLGETINTEGER64VPROC = CFuncPtr2[GLenum, Ptr[GLint64], Unit]
  object PFNGLGETINTEGER64VPROC:
    given _tag: Tag[PFNGLGETINTEGER64VPROC] = Tag.materializeCFuncPtr2[GLenum, Ptr[GLint64], Unit]
    inline def fromPtr(ptr: Ptr[Byte] | Ptr[?]): PFNGLGETINTEGER64VPROC = CFuncPtr.fromPtr(ptr.asInstanceOf[Ptr[Byte]])
    inline def apply(inline o: CFuncPtr2[GLenum, Ptr[GLint64], Unit]): PFNGLGETINTEGER64VPROC = o
    extension (v: PFNGLGETINTEGER64VPROC)
      inline def value: CFuncPtr2[GLenum, Ptr[GLint64], Unit] = v
      inline def toPtr: Ptr[?] = CFuncPtr.toPtr(v)

  opaque type PFNGLGETINTEGERINDEXEDVEXTPROC = CFuncPtr3[GLenum, GLuint, Ptr[GLint], Unit]
  object PFNGLGETINTEGERINDEXEDVEXTPROC:
    given _tag: Tag[PFNGLGETINTEGERINDEXEDVEXTPROC] = Tag.materializeCFuncPtr3[GLenum, GLuint, Ptr[GLint], Unit]
    inline def fromPtr(ptr: Ptr[Byte] | Ptr[?]): PFNGLGETINTEGERINDEXEDVEXTPROC = CFuncPtr.fromPtr(ptr.asInstanceOf[Ptr[Byte]])
    inline def apply(inline o: CFuncPtr3[GLenum, GLuint, Ptr[GLint], Unit]): PFNGLGETINTEGERINDEXEDVEXTPROC = o
    extension (v: PFNGLGETINTEGERINDEXEDVEXTPROC)
      inline def value: CFuncPtr3[GLenum, GLuint, Ptr[GLint], Unit] = v
      inline def toPtr: Ptr[?] = CFuncPtr.toPtr(v)

  opaque type PFNGLGETINTEGERI_VEXTPROC = CFuncPtr3[GLenum, GLuint, Ptr[GLint], Unit]
  object PFNGLGETINTEGERI_VEXTPROC:
    given _tag: Tag[PFNGLGETINTEGERI_VEXTPROC] = Tag.materializeCFuncPtr3[GLenum, GLuint, Ptr[GLint], Unit]
    inline def fromPtr(ptr: Ptr[Byte] | Ptr[?]): PFNGLGETINTEGERI_VEXTPROC = CFuncPtr.fromPtr(ptr.asInstanceOf[Ptr[Byte]])
    inline def apply(inline o: CFuncPtr3[GLenum, GLuint, Ptr[GLint], Unit]): PFNGLGETINTEGERI_VEXTPROC = o
    extension (v: PFNGLGETINTEGERI_VEXTPROC)
      inline def value: CFuncPtr3[GLenum, GLuint, Ptr[GLint], Unit] = v
      inline def toPtr: Ptr[?] = CFuncPtr.toPtr(v)

  opaque type PFNGLGETINTEGERI_VPROC = CFuncPtr3[GLenum, GLuint, Ptr[GLint], Unit]
  object PFNGLGETINTEGERI_VPROC:
    given _tag: Tag[PFNGLGETINTEGERI_VPROC] = Tag.materializeCFuncPtr3[GLenum, GLuint, Ptr[GLint], Unit]
    inline def fromPtr(ptr: Ptr[Byte] | Ptr[?]): PFNGLGETINTEGERI_VPROC = CFuncPtr.fromPtr(ptr.asInstanceOf[Ptr[Byte]])
    inline def apply(inline o: CFuncPtr3[GLenum, GLuint, Ptr[GLint], Unit]): PFNGLGETINTEGERI_VPROC = o
    extension (v: PFNGLGETINTEGERI_VPROC)
      inline def value: CFuncPtr3[GLenum, GLuint, Ptr[GLint], Unit] = v
      inline def toPtr: Ptr[?] = CFuncPtr.toPtr(v)

  opaque type PFNGLGETINTEGERUI64I_VNVPROC = CFuncPtr3[GLenum, GLuint, Ptr[GLuint64EXT], Unit]
  object PFNGLGETINTEGERUI64I_VNVPROC:
    given _tag: Tag[PFNGLGETINTEGERUI64I_VNVPROC] = Tag.materializeCFuncPtr3[GLenum, GLuint, Ptr[GLuint64EXT], Unit]
    inline def fromPtr(ptr: Ptr[Byte] | Ptr[?]): PFNGLGETINTEGERUI64I_VNVPROC = CFuncPtr.fromPtr(ptr.asInstanceOf[Ptr[Byte]])
    inline def apply(inline o: CFuncPtr3[GLenum, GLuint, Ptr[GLuint64EXT], Unit]): PFNGLGETINTEGERUI64I_VNVPROC = o
    extension (v: PFNGLGETINTEGERUI64I_VNVPROC)
      inline def value: CFuncPtr3[GLenum, GLuint, Ptr[GLuint64EXT], Unit] = v
      inline def toPtr: Ptr[?] = CFuncPtr.toPtr(v)

  opaque type PFNGLGETINTEGERUI64VNVPROC = CFuncPtr2[GLenum, Ptr[GLuint64EXT], Unit]
  object PFNGLGETINTEGERUI64VNVPROC:
    given _tag: Tag[PFNGLGETINTEGERUI64VNVPROC] = Tag.materializeCFuncPtr2[GLenum, Ptr[GLuint64EXT], Unit]
    inline def fromPtr(ptr: Ptr[Byte] | Ptr[?]): PFNGLGETINTEGERUI64VNVPROC = CFuncPtr.fromPtr(ptr.asInstanceOf[Ptr[Byte]])
    inline def apply(inline o: CFuncPtr2[GLenum, Ptr[GLuint64EXT], Unit]): PFNGLGETINTEGERUI64VNVPROC = o
    extension (v: PFNGLGETINTEGERUI64VNVPROC)
      inline def value: CFuncPtr2[GLenum, Ptr[GLuint64EXT], Unit] = v
      inline def toPtr: Ptr[?] = CFuncPtr.toPtr(v)

  opaque type PFNGLGETINTERNALFORMATI64VPROC = CFuncPtr5[GLenum, GLenum, GLenum, GLsizei, Ptr[GLint64], Unit]
  object PFNGLGETINTERNALFORMATI64VPROC:
    given _tag: Tag[PFNGLGETINTERNALFORMATI64VPROC] = Tag.materializeCFuncPtr5[GLenum, GLenum, GLenum, GLsizei, Ptr[GLint64], Unit]
    inline def fromPtr(ptr: Ptr[Byte] | Ptr[?]): PFNGLGETINTERNALFORMATI64VPROC = CFuncPtr.fromPtr(ptr.asInstanceOf[Ptr[Byte]])
    inline def apply(inline o: CFuncPtr5[GLenum, GLenum, GLenum, GLsizei, Ptr[GLint64], Unit]): PFNGLGETINTERNALFORMATI64VPROC = o
    extension (v: PFNGLGETINTERNALFORMATI64VPROC)
      inline def value: CFuncPtr5[GLenum, GLenum, GLenum, GLsizei, Ptr[GLint64], Unit] = v
      inline def toPtr: Ptr[?] = CFuncPtr.toPtr(v)

  opaque type PFNGLGETINTERNALFORMATIVPROC = CFuncPtr5[GLenum, GLenum, GLenum, GLsizei, Ptr[GLint], Unit]
  object PFNGLGETINTERNALFORMATIVPROC:
    given _tag: Tag[PFNGLGETINTERNALFORMATIVPROC] = Tag.materializeCFuncPtr5[GLenum, GLenum, GLenum, GLsizei, Ptr[GLint], Unit]
    inline def fromPtr(ptr: Ptr[Byte] | Ptr[?]): PFNGLGETINTERNALFORMATIVPROC = CFuncPtr.fromPtr(ptr.asInstanceOf[Ptr[Byte]])
    inline def apply(inline o: CFuncPtr5[GLenum, GLenum, GLenum, GLsizei, Ptr[GLint], Unit]): PFNGLGETINTERNALFORMATIVPROC = o
    extension (v: PFNGLGETINTERNALFORMATIVPROC)
      inline def value: CFuncPtr5[GLenum, GLenum, GLenum, GLsizei, Ptr[GLint], Unit] = v
      inline def toPtr: Ptr[?] = CFuncPtr.toPtr(v)

  opaque type PFNGLGETINTERNALFORMATSAMPLEIVNVPROC = CFuncPtr6[GLenum, GLenum, GLsizei, GLenum, GLsizei, Ptr[GLint], Unit]
  object PFNGLGETINTERNALFORMATSAMPLEIVNVPROC:
    given _tag: Tag[PFNGLGETINTERNALFORMATSAMPLEIVNVPROC] = Tag.materializeCFuncPtr6[GLenum, GLenum, GLsizei, GLenum, GLsizei, Ptr[GLint], Unit]
    inline def fromPtr(ptr: Ptr[Byte] | Ptr[?]): PFNGLGETINTERNALFORMATSAMPLEIVNVPROC = CFuncPtr.fromPtr(ptr.asInstanceOf[Ptr[Byte]])
    inline def apply(inline o: CFuncPtr6[GLenum, GLenum, GLsizei, GLenum, GLsizei, Ptr[GLint], Unit]): PFNGLGETINTERNALFORMATSAMPLEIVNVPROC = o
    extension (v: PFNGLGETINTERNALFORMATSAMPLEIVNVPROC)
      inline def value: CFuncPtr6[GLenum, GLenum, GLsizei, GLenum, GLsizei, Ptr[GLint], Unit] = v
      inline def toPtr: Ptr[?] = CFuncPtr.toPtr(v)

  opaque type PFNGLGETINVARIANTBOOLEANVEXTPROC = CFuncPtr3[GLuint, GLenum, Ptr[GLboolean], Unit]
  object PFNGLGETINVARIANTBOOLEANVEXTPROC:
    given _tag: Tag[PFNGLGETINVARIANTBOOLEANVEXTPROC] = Tag.materializeCFuncPtr3[GLuint, GLenum, Ptr[GLboolean], Unit]
    inline def fromPtr(ptr: Ptr[Byte] | Ptr[?]): PFNGLGETINVARIANTBOOLEANVEXTPROC = CFuncPtr.fromPtr(ptr.asInstanceOf[Ptr[Byte]])
    inline def apply(inline o: CFuncPtr3[GLuint, GLenum, Ptr[GLboolean], Unit]): PFNGLGETINVARIANTBOOLEANVEXTPROC = o
    extension (v: PFNGLGETINVARIANTBOOLEANVEXTPROC)
      inline def value: CFuncPtr3[GLuint, GLenum, Ptr[GLboolean], Unit] = v
      inline def toPtr: Ptr[?] = CFuncPtr.toPtr(v)

  opaque type PFNGLGETINVARIANTFLOATVEXTPROC = CFuncPtr3[GLuint, GLenum, Ptr[GLfloat], Unit]
  object PFNGLGETINVARIANTFLOATVEXTPROC:
    given _tag: Tag[PFNGLGETINVARIANTFLOATVEXTPROC] = Tag.materializeCFuncPtr3[GLuint, GLenum, Ptr[GLfloat], Unit]
    inline def fromPtr(ptr: Ptr[Byte] | Ptr[?]): PFNGLGETINVARIANTFLOATVEXTPROC = CFuncPtr.fromPtr(ptr.asInstanceOf[Ptr[Byte]])
    inline def apply(inline o: CFuncPtr3[GLuint, GLenum, Ptr[GLfloat], Unit]): PFNGLGETINVARIANTFLOATVEXTPROC = o
    extension (v: PFNGLGETINVARIANTFLOATVEXTPROC)
      inline def value: CFuncPtr3[GLuint, GLenum, Ptr[GLfloat], Unit] = v
      inline def toPtr: Ptr[?] = CFuncPtr.toPtr(v)

  opaque type PFNGLGETINVARIANTINTEGERVEXTPROC = CFuncPtr3[GLuint, GLenum, Ptr[GLint], Unit]
  object PFNGLGETINVARIANTINTEGERVEXTPROC:
    given _tag: Tag[PFNGLGETINVARIANTINTEGERVEXTPROC] = Tag.materializeCFuncPtr3[GLuint, GLenum, Ptr[GLint], Unit]
    inline def fromPtr(ptr: Ptr[Byte] | Ptr[?]): PFNGLGETINVARIANTINTEGERVEXTPROC = CFuncPtr.fromPtr(ptr.asInstanceOf[Ptr[Byte]])
    inline def apply(inline o: CFuncPtr3[GLuint, GLenum, Ptr[GLint], Unit]): PFNGLGETINVARIANTINTEGERVEXTPROC = o
    extension (v: PFNGLGETINVARIANTINTEGERVEXTPROC)
      inline def value: CFuncPtr3[GLuint, GLenum, Ptr[GLint], Unit] = v
      inline def toPtr: Ptr[?] = CFuncPtr.toPtr(v)

  opaque type PFNGLGETLIGHTXVPROC = CFuncPtr3[GLenum, GLenum, Ptr[GLfixed], Unit]
  object PFNGLGETLIGHTXVPROC:
    given _tag: Tag[PFNGLGETLIGHTXVPROC] = Tag.materializeCFuncPtr3[GLenum, GLenum, Ptr[GLfixed], Unit]
    inline def fromPtr(ptr: Ptr[Byte] | Ptr[?]): PFNGLGETLIGHTXVPROC = CFuncPtr.fromPtr(ptr.asInstanceOf[Ptr[Byte]])
    inline def apply(inline o: CFuncPtr3[GLenum, GLenum, Ptr[GLfixed], Unit]): PFNGLGETLIGHTXVPROC = o
    extension (v: PFNGLGETLIGHTXVPROC)
      inline def value: CFuncPtr3[GLenum, GLenum, Ptr[GLfixed], Unit] = v
      inline def toPtr: Ptr[?] = CFuncPtr.toPtr(v)

  opaque type PFNGLGETLOCALCONSTANTBOOLEANVEXTPROC = CFuncPtr3[GLuint, GLenum, Ptr[GLboolean], Unit]
  object PFNGLGETLOCALCONSTANTBOOLEANVEXTPROC:
    given _tag: Tag[PFNGLGETLOCALCONSTANTBOOLEANVEXTPROC] = Tag.materializeCFuncPtr3[GLuint, GLenum, Ptr[GLboolean], Unit]
    inline def fromPtr(ptr: Ptr[Byte] | Ptr[?]): PFNGLGETLOCALCONSTANTBOOLEANVEXTPROC = CFuncPtr.fromPtr(ptr.asInstanceOf[Ptr[Byte]])
    inline def apply(inline o: CFuncPtr3[GLuint, GLenum, Ptr[GLboolean], Unit]): PFNGLGETLOCALCONSTANTBOOLEANVEXTPROC = o
    extension (v: PFNGLGETLOCALCONSTANTBOOLEANVEXTPROC)
      inline def value: CFuncPtr3[GLuint, GLenum, Ptr[GLboolean], Unit] = v
      inline def toPtr: Ptr[?] = CFuncPtr.toPtr(v)

  opaque type PFNGLGETLOCALCONSTANTFLOATVEXTPROC = CFuncPtr3[GLuint, GLenum, Ptr[GLfloat], Unit]
  object PFNGLGETLOCALCONSTANTFLOATVEXTPROC:
    given _tag: Tag[PFNGLGETLOCALCONSTANTFLOATVEXTPROC] = Tag.materializeCFuncPtr3[GLuint, GLenum, Ptr[GLfloat], Unit]
    inline def fromPtr(ptr: Ptr[Byte] | Ptr[?]): PFNGLGETLOCALCONSTANTFLOATVEXTPROC = CFuncPtr.fromPtr(ptr.asInstanceOf[Ptr[Byte]])
    inline def apply(inline o: CFuncPtr3[GLuint, GLenum, Ptr[GLfloat], Unit]): PFNGLGETLOCALCONSTANTFLOATVEXTPROC = o
    extension (v: PFNGLGETLOCALCONSTANTFLOATVEXTPROC)
      inline def value: CFuncPtr3[GLuint, GLenum, Ptr[GLfloat], Unit] = v
      inline def toPtr: Ptr[?] = CFuncPtr.toPtr(v)

  opaque type PFNGLGETLOCALCONSTANTINTEGERVEXTPROC = CFuncPtr3[GLuint, GLenum, Ptr[GLint], Unit]
  object PFNGLGETLOCALCONSTANTINTEGERVEXTPROC:
    given _tag: Tag[PFNGLGETLOCALCONSTANTINTEGERVEXTPROC] = Tag.materializeCFuncPtr3[GLuint, GLenum, Ptr[GLint], Unit]
    inline def fromPtr(ptr: Ptr[Byte] | Ptr[?]): PFNGLGETLOCALCONSTANTINTEGERVEXTPROC = CFuncPtr.fromPtr(ptr.asInstanceOf[Ptr[Byte]])
    inline def apply(inline o: CFuncPtr3[GLuint, GLenum, Ptr[GLint], Unit]): PFNGLGETLOCALCONSTANTINTEGERVEXTPROC = o
    extension (v: PFNGLGETLOCALCONSTANTINTEGERVEXTPROC)
      inline def value: CFuncPtr3[GLuint, GLenum, Ptr[GLint], Unit] = v
      inline def toPtr: Ptr[?] = CFuncPtr.toPtr(v)

  opaque type PFNGLGETMAPATTRIBPARAMETERFVNVPROC = CFuncPtr4[GLenum, GLuint, GLenum, Ptr[GLfloat], Unit]
  object PFNGLGETMAPATTRIBPARAMETERFVNVPROC:
    given _tag: Tag[PFNGLGETMAPATTRIBPARAMETERFVNVPROC] = Tag.materializeCFuncPtr4[GLenum, GLuint, GLenum, Ptr[GLfloat], Unit]
    inline def fromPtr(ptr: Ptr[Byte] | Ptr[?]): PFNGLGETMAPATTRIBPARAMETERFVNVPROC = CFuncPtr.fromPtr(ptr.asInstanceOf[Ptr[Byte]])
    inline def apply(inline o: CFuncPtr4[GLenum, GLuint, GLenum, Ptr[GLfloat], Unit]): PFNGLGETMAPATTRIBPARAMETERFVNVPROC = o
    extension (v: PFNGLGETMAPATTRIBPARAMETERFVNVPROC)
      inline def value: CFuncPtr4[GLenum, GLuint, GLenum, Ptr[GLfloat], Unit] = v
      inline def toPtr: Ptr[?] = CFuncPtr.toPtr(v)

  opaque type PFNGLGETMAPATTRIBPARAMETERIVNVPROC = CFuncPtr4[GLenum, GLuint, GLenum, Ptr[GLint], Unit]
  object PFNGLGETMAPATTRIBPARAMETERIVNVPROC:
    given _tag: Tag[PFNGLGETMAPATTRIBPARAMETERIVNVPROC] = Tag.materializeCFuncPtr4[GLenum, GLuint, GLenum, Ptr[GLint], Unit]
    inline def fromPtr(ptr: Ptr[Byte] | Ptr[?]): PFNGLGETMAPATTRIBPARAMETERIVNVPROC = CFuncPtr.fromPtr(ptr.asInstanceOf[Ptr[Byte]])
    inline def apply(inline o: CFuncPtr4[GLenum, GLuint, GLenum, Ptr[GLint], Unit]): PFNGLGETMAPATTRIBPARAMETERIVNVPROC = o
    extension (v: PFNGLGETMAPATTRIBPARAMETERIVNVPROC)
      inline def value: CFuncPtr4[GLenum, GLuint, GLenum, Ptr[GLint], Unit] = v
      inline def toPtr: Ptr[?] = CFuncPtr.toPtr(v)

  opaque type PFNGLGETMAPCONTROLPOINTSNVPROC = CFuncPtr7[GLenum, GLuint, GLenum, GLsizei, GLsizei, GLboolean, Ptr[Byte], Unit]
  object PFNGLGETMAPCONTROLPOINTSNVPROC:
    given _tag: Tag[PFNGLGETMAPCONTROLPOINTSNVPROC] = Tag.materializeCFuncPtr7[GLenum, GLuint, GLenum, GLsizei, GLsizei, GLboolean, Ptr[Byte], Unit]
    inline def fromPtr(ptr: Ptr[Byte] | Ptr[?]): PFNGLGETMAPCONTROLPOINTSNVPROC = CFuncPtr.fromPtr(ptr.asInstanceOf[Ptr[Byte]])
    inline def apply(inline o: CFuncPtr7[GLenum, GLuint, GLenum, GLsizei, GLsizei, GLboolean, Ptr[Byte], Unit]): PFNGLGETMAPCONTROLPOINTSNVPROC = o
    extension (v: PFNGLGETMAPCONTROLPOINTSNVPROC)
      inline def value: CFuncPtr7[GLenum, GLuint, GLenum, GLsizei, GLsizei, GLboolean, Ptr[Byte], Unit] = v
      inline def toPtr: Ptr[?] = CFuncPtr.toPtr(v)

  opaque type PFNGLGETMAPPARAMETERFVNVPROC = CFuncPtr3[GLenum, GLenum, Ptr[GLfloat], Unit]
  object PFNGLGETMAPPARAMETERFVNVPROC:
    given _tag: Tag[PFNGLGETMAPPARAMETERFVNVPROC] = Tag.materializeCFuncPtr3[GLenum, GLenum, Ptr[GLfloat], Unit]
    inline def fromPtr(ptr: Ptr[Byte] | Ptr[?]): PFNGLGETMAPPARAMETERFVNVPROC = CFuncPtr.fromPtr(ptr.asInstanceOf[Ptr[Byte]])
    inline def apply(inline o: CFuncPtr3[GLenum, GLenum, Ptr[GLfloat], Unit]): PFNGLGETMAPPARAMETERFVNVPROC = o
    extension (v: PFNGLGETMAPPARAMETERFVNVPROC)
      inline def value: CFuncPtr3[GLenum, GLenum, Ptr[GLfloat], Unit] = v
      inline def toPtr: Ptr[?] = CFuncPtr.toPtr(v)

  opaque type PFNGLGETMAPPARAMETERIVNVPROC = CFuncPtr3[GLenum, GLenum, Ptr[GLint], Unit]
  object PFNGLGETMAPPARAMETERIVNVPROC:
    given _tag: Tag[PFNGLGETMAPPARAMETERIVNVPROC] = Tag.materializeCFuncPtr3[GLenum, GLenum, Ptr[GLint], Unit]
    inline def fromPtr(ptr: Ptr[Byte] | Ptr[?]): PFNGLGETMAPPARAMETERIVNVPROC = CFuncPtr.fromPtr(ptr.asInstanceOf[Ptr[Byte]])
    inline def apply(inline o: CFuncPtr3[GLenum, GLenum, Ptr[GLint], Unit]): PFNGLGETMAPPARAMETERIVNVPROC = o
    extension (v: PFNGLGETMAPPARAMETERIVNVPROC)
      inline def value: CFuncPtr3[GLenum, GLenum, Ptr[GLint], Unit] = v
      inline def toPtr: Ptr[?] = CFuncPtr.toPtr(v)

  opaque type PFNGLGETMATERIALXVPROC = CFuncPtr3[GLenum, GLenum, Ptr[GLfixed], Unit]
  object PFNGLGETMATERIALXVPROC:
    given _tag: Tag[PFNGLGETMATERIALXVPROC] = Tag.materializeCFuncPtr3[GLenum, GLenum, Ptr[GLfixed], Unit]
    inline def fromPtr(ptr: Ptr[Byte] | Ptr[?]): PFNGLGETMATERIALXVPROC = CFuncPtr.fromPtr(ptr.asInstanceOf[Ptr[Byte]])
    inline def apply(inline o: CFuncPtr3[GLenum, GLenum, Ptr[GLfixed], Unit]): PFNGLGETMATERIALXVPROC = o
    extension (v: PFNGLGETMATERIALXVPROC)
      inline def value: CFuncPtr3[GLenum, GLenum, Ptr[GLfixed], Unit] = v
      inline def toPtr: Ptr[?] = CFuncPtr.toPtr(v)

  opaque type PFNGLGETMEMORYOBJECTDETACHEDRESOURCESUIVNVPROC = CFuncPtr5[GLuint, GLenum, GLint, GLsizei, Ptr[GLuint], Unit]
  object PFNGLGETMEMORYOBJECTDETACHEDRESOURCESUIVNVPROC:
    given _tag: Tag[PFNGLGETMEMORYOBJECTDETACHEDRESOURCESUIVNVPROC] = Tag.materializeCFuncPtr5[GLuint, GLenum, GLint, GLsizei, Ptr[GLuint], Unit]
    inline def fromPtr(ptr: Ptr[Byte] | Ptr[?]): PFNGLGETMEMORYOBJECTDETACHEDRESOURCESUIVNVPROC = CFuncPtr.fromPtr(ptr.asInstanceOf[Ptr[Byte]])
    inline def apply(inline o: CFuncPtr5[GLuint, GLenum, GLint, GLsizei, Ptr[GLuint], Unit]): PFNGLGETMEMORYOBJECTDETACHEDRESOURCESUIVNVPROC = o
    extension (v: PFNGLGETMEMORYOBJECTDETACHEDRESOURCESUIVNVPROC)
      inline def value: CFuncPtr5[GLuint, GLenum, GLint, GLsizei, Ptr[GLuint], Unit] = v
      inline def toPtr: Ptr[?] = CFuncPtr.toPtr(v)

  opaque type PFNGLGETMEMORYOBJECTPARAMETERIVEXTPROC = CFuncPtr3[GLuint, GLenum, Ptr[GLint], Unit]
  object PFNGLGETMEMORYOBJECTPARAMETERIVEXTPROC:
    given _tag: Tag[PFNGLGETMEMORYOBJECTPARAMETERIVEXTPROC] = Tag.materializeCFuncPtr3[GLuint, GLenum, Ptr[GLint], Unit]
    inline def fromPtr(ptr: Ptr[Byte] | Ptr[?]): PFNGLGETMEMORYOBJECTPARAMETERIVEXTPROC = CFuncPtr.fromPtr(ptr.asInstanceOf[Ptr[Byte]])
    inline def apply(inline o: CFuncPtr3[GLuint, GLenum, Ptr[GLint], Unit]): PFNGLGETMEMORYOBJECTPARAMETERIVEXTPROC = o
    extension (v: PFNGLGETMEMORYOBJECTPARAMETERIVEXTPROC)
      inline def value: CFuncPtr3[GLuint, GLenum, Ptr[GLint], Unit] = v
      inline def toPtr: Ptr[?] = CFuncPtr.toPtr(v)

  opaque type PFNGLGETMINMAXEXTPROC = CFuncPtr5[GLenum, GLboolean, GLenum, GLenum, Ptr[Byte], Unit]
  object PFNGLGETMINMAXEXTPROC:
    given _tag: Tag[PFNGLGETMINMAXEXTPROC] = Tag.materializeCFuncPtr5[GLenum, GLboolean, GLenum, GLenum, Ptr[Byte], Unit]
    inline def fromPtr(ptr: Ptr[Byte] | Ptr[?]): PFNGLGETMINMAXEXTPROC = CFuncPtr.fromPtr(ptr.asInstanceOf[Ptr[Byte]])
    inline def apply(inline o: CFuncPtr5[GLenum, GLboolean, GLenum, GLenum, Ptr[Byte], Unit]): PFNGLGETMINMAXEXTPROC = o
    extension (v: PFNGLGETMINMAXEXTPROC)
      inline def value: CFuncPtr5[GLenum, GLboolean, GLenum, GLenum, Ptr[Byte], Unit] = v
      inline def toPtr: Ptr[?] = CFuncPtr.toPtr(v)

  opaque type PFNGLGETMINMAXPARAMETERFVEXTPROC = CFuncPtr3[GLenum, GLenum, Ptr[GLfloat], Unit]
  object PFNGLGETMINMAXPARAMETERFVEXTPROC:
    given _tag: Tag[PFNGLGETMINMAXPARAMETERFVEXTPROC] = Tag.materializeCFuncPtr3[GLenum, GLenum, Ptr[GLfloat], Unit]
    inline def fromPtr(ptr: Ptr[Byte] | Ptr[?]): PFNGLGETMINMAXPARAMETERFVEXTPROC = CFuncPtr.fromPtr(ptr.asInstanceOf[Ptr[Byte]])
    inline def apply(inline o: CFuncPtr3[GLenum, GLenum, Ptr[GLfloat], Unit]): PFNGLGETMINMAXPARAMETERFVEXTPROC = o
    extension (v: PFNGLGETMINMAXPARAMETERFVEXTPROC)
      inline def value: CFuncPtr3[GLenum, GLenum, Ptr[GLfloat], Unit] = v
      inline def toPtr: Ptr[?] = CFuncPtr.toPtr(v)

  opaque type PFNGLGETMINMAXPARAMETERFVPROC = CFuncPtr3[GLenum, GLenum, Ptr[GLfloat], Unit]
  object PFNGLGETMINMAXPARAMETERFVPROC:
    given _tag: Tag[PFNGLGETMINMAXPARAMETERFVPROC] = Tag.materializeCFuncPtr3[GLenum, GLenum, Ptr[GLfloat], Unit]
    inline def fromPtr(ptr: Ptr[Byte] | Ptr[?]): PFNGLGETMINMAXPARAMETERFVPROC = CFuncPtr.fromPtr(ptr.asInstanceOf[Ptr[Byte]])
    inline def apply(inline o: CFuncPtr3[GLenum, GLenum, Ptr[GLfloat], Unit]): PFNGLGETMINMAXPARAMETERFVPROC = o
    extension (v: PFNGLGETMINMAXPARAMETERFVPROC)
      inline def value: CFuncPtr3[GLenum, GLenum, Ptr[GLfloat], Unit] = v
      inline def toPtr: Ptr[?] = CFuncPtr.toPtr(v)

  opaque type PFNGLGETMINMAXPARAMETERIVEXTPROC = CFuncPtr3[GLenum, GLenum, Ptr[GLint], Unit]
  object PFNGLGETMINMAXPARAMETERIVEXTPROC:
    given _tag: Tag[PFNGLGETMINMAXPARAMETERIVEXTPROC] = Tag.materializeCFuncPtr3[GLenum, GLenum, Ptr[GLint], Unit]
    inline def fromPtr(ptr: Ptr[Byte] | Ptr[?]): PFNGLGETMINMAXPARAMETERIVEXTPROC = CFuncPtr.fromPtr(ptr.asInstanceOf[Ptr[Byte]])
    inline def apply(inline o: CFuncPtr3[GLenum, GLenum, Ptr[GLint], Unit]): PFNGLGETMINMAXPARAMETERIVEXTPROC = o
    extension (v: PFNGLGETMINMAXPARAMETERIVEXTPROC)
      inline def value: CFuncPtr3[GLenum, GLenum, Ptr[GLint], Unit] = v
      inline def toPtr: Ptr[?] = CFuncPtr.toPtr(v)

  opaque type PFNGLGETMINMAXPARAMETERIVPROC = CFuncPtr3[GLenum, GLenum, Ptr[GLint], Unit]
  object PFNGLGETMINMAXPARAMETERIVPROC:
    given _tag: Tag[PFNGLGETMINMAXPARAMETERIVPROC] = Tag.materializeCFuncPtr3[GLenum, GLenum, Ptr[GLint], Unit]
    inline def fromPtr(ptr: Ptr[Byte] | Ptr[?]): PFNGLGETMINMAXPARAMETERIVPROC = CFuncPtr.fromPtr(ptr.asInstanceOf[Ptr[Byte]])
    inline def apply(inline o: CFuncPtr3[GLenum, GLenum, Ptr[GLint], Unit]): PFNGLGETMINMAXPARAMETERIVPROC = o
    extension (v: PFNGLGETMINMAXPARAMETERIVPROC)
      inline def value: CFuncPtr3[GLenum, GLenum, Ptr[GLint], Unit] = v
      inline def toPtr: Ptr[?] = CFuncPtr.toPtr(v)

  opaque type PFNGLGETMINMAXPROC = CFuncPtr5[GLenum, GLboolean, GLenum, GLenum, Ptr[Byte], Unit]
  object PFNGLGETMINMAXPROC:
    given _tag: Tag[PFNGLGETMINMAXPROC] = Tag.materializeCFuncPtr5[GLenum, GLboolean, GLenum, GLenum, Ptr[Byte], Unit]
    inline def fromPtr(ptr: Ptr[Byte] | Ptr[?]): PFNGLGETMINMAXPROC = CFuncPtr.fromPtr(ptr.asInstanceOf[Ptr[Byte]])
    inline def apply(inline o: CFuncPtr5[GLenum, GLboolean, GLenum, GLenum, Ptr[Byte], Unit]): PFNGLGETMINMAXPROC = o
    extension (v: PFNGLGETMINMAXPROC)
      inline def value: CFuncPtr5[GLenum, GLboolean, GLenum, GLenum, Ptr[Byte], Unit] = v
      inline def toPtr: Ptr[?] = CFuncPtr.toPtr(v)

  opaque type PFNGLGETMPEGPARAMETERFVSGIXPROC = CFuncPtr3[GLenum, GLenum, Ptr[GLfloat], Unit]
  object PFNGLGETMPEGPARAMETERFVSGIXPROC:
    given _tag: Tag[PFNGLGETMPEGPARAMETERFVSGIXPROC] = Tag.materializeCFuncPtr3[GLenum, GLenum, Ptr[GLfloat], Unit]
    inline def fromPtr(ptr: Ptr[Byte] | Ptr[?]): PFNGLGETMPEGPARAMETERFVSGIXPROC = CFuncPtr.fromPtr(ptr.asInstanceOf[Ptr[Byte]])
    inline def apply(inline o: CFuncPtr3[GLenum, GLenum, Ptr[GLfloat], Unit]): PFNGLGETMPEGPARAMETERFVSGIXPROC = o
    extension (v: PFNGLGETMPEGPARAMETERFVSGIXPROC)
      inline def value: CFuncPtr3[GLenum, GLenum, Ptr[GLfloat], Unit] = v
      inline def toPtr: Ptr[?] = CFuncPtr.toPtr(v)

  opaque type PFNGLGETMPEGPARAMETERIVSGIXPROC = CFuncPtr3[GLenum, GLenum, Ptr[GLint], Unit]
  object PFNGLGETMPEGPARAMETERIVSGIXPROC:
    given _tag: Tag[PFNGLGETMPEGPARAMETERIVSGIXPROC] = Tag.materializeCFuncPtr3[GLenum, GLenum, Ptr[GLint], Unit]
    inline def fromPtr(ptr: Ptr[Byte] | Ptr[?]): PFNGLGETMPEGPARAMETERIVSGIXPROC = CFuncPtr.fromPtr(ptr.asInstanceOf[Ptr[Byte]])
    inline def apply(inline o: CFuncPtr3[GLenum, GLenum, Ptr[GLint], Unit]): PFNGLGETMPEGPARAMETERIVSGIXPROC = o
    extension (v: PFNGLGETMPEGPARAMETERIVSGIXPROC)
      inline def value: CFuncPtr3[GLenum, GLenum, Ptr[GLint], Unit] = v
      inline def toPtr: Ptr[?] = CFuncPtr.toPtr(v)

  opaque type PFNGLGETMPEGPREDICTORSGIXPROC = CFuncPtr4[GLenum, GLenum, GLenum, Ptr[Byte], Unit]
  object PFNGLGETMPEGPREDICTORSGIXPROC:
    given _tag: Tag[PFNGLGETMPEGPREDICTORSGIXPROC] = Tag.materializeCFuncPtr4[GLenum, GLenum, GLenum, Ptr[Byte], Unit]
    inline def fromPtr(ptr: Ptr[Byte] | Ptr[?]): PFNGLGETMPEGPREDICTORSGIXPROC = CFuncPtr.fromPtr(ptr.asInstanceOf[Ptr[Byte]])
    inline def apply(inline o: CFuncPtr4[GLenum, GLenum, GLenum, Ptr[Byte], Unit]): PFNGLGETMPEGPREDICTORSGIXPROC = o
    extension (v: PFNGLGETMPEGPREDICTORSGIXPROC)
      inline def value: CFuncPtr4[GLenum, GLenum, GLenum, Ptr[Byte], Unit] = v
      inline def toPtr: Ptr[?] = CFuncPtr.toPtr(v)

  opaque type PFNGLGETMPEGQUANTTABLEUBVPROC = CFuncPtr2[GLenum, Ptr[GLubyte], Unit]
  object PFNGLGETMPEGQUANTTABLEUBVPROC:
    given _tag: Tag[PFNGLGETMPEGQUANTTABLEUBVPROC] = Tag.materializeCFuncPtr2[GLenum, Ptr[GLubyte], Unit]
    inline def fromPtr(ptr: Ptr[Byte] | Ptr[?]): PFNGLGETMPEGQUANTTABLEUBVPROC = CFuncPtr.fromPtr(ptr.asInstanceOf[Ptr[Byte]])
    inline def apply(inline o: CFuncPtr2[GLenum, Ptr[GLubyte], Unit]): PFNGLGETMPEGQUANTTABLEUBVPROC = o
    extension (v: PFNGLGETMPEGQUANTTABLEUBVPROC)
      inline def value: CFuncPtr2[GLenum, Ptr[GLubyte], Unit] = v
      inline def toPtr: Ptr[?] = CFuncPtr.toPtr(v)

  opaque type PFNGLGETMULTISAMPLEFVNVPROC = CFuncPtr3[GLenum, GLuint, Ptr[GLfloat], Unit]
  object PFNGLGETMULTISAMPLEFVNVPROC:
    given _tag: Tag[PFNGLGETMULTISAMPLEFVNVPROC] = Tag.materializeCFuncPtr3[GLenum, GLuint, Ptr[GLfloat], Unit]
    inline def fromPtr(ptr: Ptr[Byte] | Ptr[?]): PFNGLGETMULTISAMPLEFVNVPROC = CFuncPtr.fromPtr(ptr.asInstanceOf[Ptr[Byte]])
    inline def apply(inline o: CFuncPtr3[GLenum, GLuint, Ptr[GLfloat], Unit]): PFNGLGETMULTISAMPLEFVNVPROC = o
    extension (v: PFNGLGETMULTISAMPLEFVNVPROC)
      inline def value: CFuncPtr3[GLenum, GLuint, Ptr[GLfloat], Unit] = v
      inline def toPtr: Ptr[?] = CFuncPtr.toPtr(v)

  opaque type PFNGLGETMULTISAMPLEFVPROC = CFuncPtr3[GLenum, GLuint, Ptr[GLfloat], Unit]
  object PFNGLGETMULTISAMPLEFVPROC:
    given _tag: Tag[PFNGLGETMULTISAMPLEFVPROC] = Tag.materializeCFuncPtr3[GLenum, GLuint, Ptr[GLfloat], Unit]
    inline def fromPtr(ptr: Ptr[Byte] | Ptr[?]): PFNGLGETMULTISAMPLEFVPROC = CFuncPtr.fromPtr(ptr.asInstanceOf[Ptr[Byte]])
    inline def apply(inline o: CFuncPtr3[GLenum, GLuint, Ptr[GLfloat], Unit]): PFNGLGETMULTISAMPLEFVPROC = o
    extension (v: PFNGLGETMULTISAMPLEFVPROC)
      inline def value: CFuncPtr3[GLenum, GLuint, Ptr[GLfloat], Unit] = v
      inline def toPtr: Ptr[?] = CFuncPtr.toPtr(v)

  opaque type PFNGLGETMULTITEXENVFVEXTPROC = CFuncPtr4[GLenum, GLenum, GLenum, Ptr[GLfloat], Unit]
  object PFNGLGETMULTITEXENVFVEXTPROC:
    given _tag: Tag[PFNGLGETMULTITEXENVFVEXTPROC] = Tag.materializeCFuncPtr4[GLenum, GLenum, GLenum, Ptr[GLfloat], Unit]
    inline def fromPtr(ptr: Ptr[Byte] | Ptr[?]): PFNGLGETMULTITEXENVFVEXTPROC = CFuncPtr.fromPtr(ptr.asInstanceOf[Ptr[Byte]])
    inline def apply(inline o: CFuncPtr4[GLenum, GLenum, GLenum, Ptr[GLfloat], Unit]): PFNGLGETMULTITEXENVFVEXTPROC = o
    extension (v: PFNGLGETMULTITEXENVFVEXTPROC)
      inline def value: CFuncPtr4[GLenum, GLenum, GLenum, Ptr[GLfloat], Unit] = v
      inline def toPtr: Ptr[?] = CFuncPtr.toPtr(v)

  opaque type PFNGLGETMULTITEXENVIVEXTPROC = CFuncPtr4[GLenum, GLenum, GLenum, Ptr[GLint], Unit]
  object PFNGLGETMULTITEXENVIVEXTPROC:
    given _tag: Tag[PFNGLGETMULTITEXENVIVEXTPROC] = Tag.materializeCFuncPtr4[GLenum, GLenum, GLenum, Ptr[GLint], Unit]
    inline def fromPtr(ptr: Ptr[Byte] | Ptr[?]): PFNGLGETMULTITEXENVIVEXTPROC = CFuncPtr.fromPtr(ptr.asInstanceOf[Ptr[Byte]])
    inline def apply(inline o: CFuncPtr4[GLenum, GLenum, GLenum, Ptr[GLint], Unit]): PFNGLGETMULTITEXENVIVEXTPROC = o
    extension (v: PFNGLGETMULTITEXENVIVEXTPROC)
      inline def value: CFuncPtr4[GLenum, GLenum, GLenum, Ptr[GLint], Unit] = v
      inline def toPtr: Ptr[?] = CFuncPtr.toPtr(v)

  opaque type PFNGLGETMULTITEXGENDVEXTPROC = CFuncPtr4[GLenum, GLenum, GLenum, Ptr[GLdouble], Unit]
  object PFNGLGETMULTITEXGENDVEXTPROC:
    given _tag: Tag[PFNGLGETMULTITEXGENDVEXTPROC] = Tag.materializeCFuncPtr4[GLenum, GLenum, GLenum, Ptr[GLdouble], Unit]
    inline def fromPtr(ptr: Ptr[Byte] | Ptr[?]): PFNGLGETMULTITEXGENDVEXTPROC = CFuncPtr.fromPtr(ptr.asInstanceOf[Ptr[Byte]])
    inline def apply(inline o: CFuncPtr4[GLenum, GLenum, GLenum, Ptr[GLdouble], Unit]): PFNGLGETMULTITEXGENDVEXTPROC = o
    extension (v: PFNGLGETMULTITEXGENDVEXTPROC)
      inline def value: CFuncPtr4[GLenum, GLenum, GLenum, Ptr[GLdouble], Unit] = v
      inline def toPtr: Ptr[?] = CFuncPtr.toPtr(v)

  opaque type PFNGLGETMULTITEXGENFVEXTPROC = CFuncPtr4[GLenum, GLenum, GLenum, Ptr[GLfloat], Unit]
  object PFNGLGETMULTITEXGENFVEXTPROC:
    given _tag: Tag[PFNGLGETMULTITEXGENFVEXTPROC] = Tag.materializeCFuncPtr4[GLenum, GLenum, GLenum, Ptr[GLfloat], Unit]
    inline def fromPtr(ptr: Ptr[Byte] | Ptr[?]): PFNGLGETMULTITEXGENFVEXTPROC = CFuncPtr.fromPtr(ptr.asInstanceOf[Ptr[Byte]])
    inline def apply(inline o: CFuncPtr4[GLenum, GLenum, GLenum, Ptr[GLfloat], Unit]): PFNGLGETMULTITEXGENFVEXTPROC = o
    extension (v: PFNGLGETMULTITEXGENFVEXTPROC)
      inline def value: CFuncPtr4[GLenum, GLenum, GLenum, Ptr[GLfloat], Unit] = v
      inline def toPtr: Ptr[?] = CFuncPtr.toPtr(v)

  opaque type PFNGLGETMULTITEXGENIVEXTPROC = CFuncPtr4[GLenum, GLenum, GLenum, Ptr[GLint], Unit]
  object PFNGLGETMULTITEXGENIVEXTPROC:
    given _tag: Tag[PFNGLGETMULTITEXGENIVEXTPROC] = Tag.materializeCFuncPtr4[GLenum, GLenum, GLenum, Ptr[GLint], Unit]
    inline def fromPtr(ptr: Ptr[Byte] | Ptr[?]): PFNGLGETMULTITEXGENIVEXTPROC = CFuncPtr.fromPtr(ptr.asInstanceOf[Ptr[Byte]])
    inline def apply(inline o: CFuncPtr4[GLenum, GLenum, GLenum, Ptr[GLint], Unit]): PFNGLGETMULTITEXGENIVEXTPROC = o
    extension (v: PFNGLGETMULTITEXGENIVEXTPROC)
      inline def value: CFuncPtr4[GLenum, GLenum, GLenum, Ptr[GLint], Unit] = v
      inline def toPtr: Ptr[?] = CFuncPtr.toPtr(v)

  opaque type PFNGLGETMULTITEXIMAGEEXTPROC = CFuncPtr6[GLenum, GLenum, GLint, GLenum, GLenum, Ptr[Byte], Unit]
  object PFNGLGETMULTITEXIMAGEEXTPROC:
    given _tag: Tag[PFNGLGETMULTITEXIMAGEEXTPROC] = Tag.materializeCFuncPtr6[GLenum, GLenum, GLint, GLenum, GLenum, Ptr[Byte], Unit]
    inline def fromPtr(ptr: Ptr[Byte] | Ptr[?]): PFNGLGETMULTITEXIMAGEEXTPROC = CFuncPtr.fromPtr(ptr.asInstanceOf[Ptr[Byte]])
    inline def apply(inline o: CFuncPtr6[GLenum, GLenum, GLint, GLenum, GLenum, Ptr[Byte], Unit]): PFNGLGETMULTITEXIMAGEEXTPROC = o
    extension (v: PFNGLGETMULTITEXIMAGEEXTPROC)
      inline def value: CFuncPtr6[GLenum, GLenum, GLint, GLenum, GLenum, Ptr[Byte], Unit] = v
      inline def toPtr: Ptr[?] = CFuncPtr.toPtr(v)

  opaque type PFNGLGETMULTITEXLEVELPARAMETERFVEXTPROC = CFuncPtr5[GLenum, GLenum, GLint, GLenum, Ptr[GLfloat], Unit]
  object PFNGLGETMULTITEXLEVELPARAMETERFVEXTPROC:
    given _tag: Tag[PFNGLGETMULTITEXLEVELPARAMETERFVEXTPROC] = Tag.materializeCFuncPtr5[GLenum, GLenum, GLint, GLenum, Ptr[GLfloat], Unit]
    inline def fromPtr(ptr: Ptr[Byte] | Ptr[?]): PFNGLGETMULTITEXLEVELPARAMETERFVEXTPROC = CFuncPtr.fromPtr(ptr.asInstanceOf[Ptr[Byte]])
    inline def apply(inline o: CFuncPtr5[GLenum, GLenum, GLint, GLenum, Ptr[GLfloat], Unit]): PFNGLGETMULTITEXLEVELPARAMETERFVEXTPROC = o
    extension (v: PFNGLGETMULTITEXLEVELPARAMETERFVEXTPROC)
      inline def value: CFuncPtr5[GLenum, GLenum, GLint, GLenum, Ptr[GLfloat], Unit] = v
      inline def toPtr: Ptr[?] = CFuncPtr.toPtr(v)

  opaque type PFNGLGETMULTITEXLEVELPARAMETERIVEXTPROC = CFuncPtr5[GLenum, GLenum, GLint, GLenum, Ptr[GLint], Unit]
  object PFNGLGETMULTITEXLEVELPARAMETERIVEXTPROC:
    given _tag: Tag[PFNGLGETMULTITEXLEVELPARAMETERIVEXTPROC] = Tag.materializeCFuncPtr5[GLenum, GLenum, GLint, GLenum, Ptr[GLint], Unit]
    inline def fromPtr(ptr: Ptr[Byte] | Ptr[?]): PFNGLGETMULTITEXLEVELPARAMETERIVEXTPROC = CFuncPtr.fromPtr(ptr.asInstanceOf[Ptr[Byte]])
    inline def apply(inline o: CFuncPtr5[GLenum, GLenum, GLint, GLenum, Ptr[GLint], Unit]): PFNGLGETMULTITEXLEVELPARAMETERIVEXTPROC = o
    extension (v: PFNGLGETMULTITEXLEVELPARAMETERIVEXTPROC)
      inline def value: CFuncPtr5[GLenum, GLenum, GLint, GLenum, Ptr[GLint], Unit] = v
      inline def toPtr: Ptr[?] = CFuncPtr.toPtr(v)

  opaque type PFNGLGETMULTITEXPARAMETERFVEXTPROC = CFuncPtr4[GLenum, GLenum, GLenum, Ptr[GLfloat], Unit]
  object PFNGLGETMULTITEXPARAMETERFVEXTPROC:
    given _tag: Tag[PFNGLGETMULTITEXPARAMETERFVEXTPROC] = Tag.materializeCFuncPtr4[GLenum, GLenum, GLenum, Ptr[GLfloat], Unit]
    inline def fromPtr(ptr: Ptr[Byte] | Ptr[?]): PFNGLGETMULTITEXPARAMETERFVEXTPROC = CFuncPtr.fromPtr(ptr.asInstanceOf[Ptr[Byte]])
    inline def apply(inline o: CFuncPtr4[GLenum, GLenum, GLenum, Ptr[GLfloat], Unit]): PFNGLGETMULTITEXPARAMETERFVEXTPROC = o
    extension (v: PFNGLGETMULTITEXPARAMETERFVEXTPROC)
      inline def value: CFuncPtr4[GLenum, GLenum, GLenum, Ptr[GLfloat], Unit] = v
      inline def toPtr: Ptr[?] = CFuncPtr.toPtr(v)

  opaque type PFNGLGETMULTITEXPARAMETERIIVEXTPROC = CFuncPtr4[GLenum, GLenum, GLenum, Ptr[GLint], Unit]
  object PFNGLGETMULTITEXPARAMETERIIVEXTPROC:
    given _tag: Tag[PFNGLGETMULTITEXPARAMETERIIVEXTPROC] = Tag.materializeCFuncPtr4[GLenum, GLenum, GLenum, Ptr[GLint], Unit]
    inline def fromPtr(ptr: Ptr[Byte] | Ptr[?]): PFNGLGETMULTITEXPARAMETERIIVEXTPROC = CFuncPtr.fromPtr(ptr.asInstanceOf[Ptr[Byte]])
    inline def apply(inline o: CFuncPtr4[GLenum, GLenum, GLenum, Ptr[GLint], Unit]): PFNGLGETMULTITEXPARAMETERIIVEXTPROC = o
    extension (v: PFNGLGETMULTITEXPARAMETERIIVEXTPROC)
      inline def value: CFuncPtr4[GLenum, GLenum, GLenum, Ptr[GLint], Unit] = v
      inline def toPtr: Ptr[?] = CFuncPtr.toPtr(v)

  opaque type PFNGLGETMULTITEXPARAMETERIUIVEXTPROC = CFuncPtr4[GLenum, GLenum, GLenum, Ptr[GLuint], Unit]
  object PFNGLGETMULTITEXPARAMETERIUIVEXTPROC:
    given _tag: Tag[PFNGLGETMULTITEXPARAMETERIUIVEXTPROC] = Tag.materializeCFuncPtr4[GLenum, GLenum, GLenum, Ptr[GLuint], Unit]
    inline def fromPtr(ptr: Ptr[Byte] | Ptr[?]): PFNGLGETMULTITEXPARAMETERIUIVEXTPROC = CFuncPtr.fromPtr(ptr.asInstanceOf[Ptr[Byte]])
    inline def apply(inline o: CFuncPtr4[GLenum, GLenum, GLenum, Ptr[GLuint], Unit]): PFNGLGETMULTITEXPARAMETERIUIVEXTPROC = o
    extension (v: PFNGLGETMULTITEXPARAMETERIUIVEXTPROC)
      inline def value: CFuncPtr4[GLenum, GLenum, GLenum, Ptr[GLuint], Unit] = v
      inline def toPtr: Ptr[?] = CFuncPtr.toPtr(v)

  opaque type PFNGLGETMULTITEXPARAMETERIVEXTPROC = CFuncPtr4[GLenum, GLenum, GLenum, Ptr[GLint], Unit]
  object PFNGLGETMULTITEXPARAMETERIVEXTPROC:
    given _tag: Tag[PFNGLGETMULTITEXPARAMETERIVEXTPROC] = Tag.materializeCFuncPtr4[GLenum, GLenum, GLenum, Ptr[GLint], Unit]
    inline def fromPtr(ptr: Ptr[Byte] | Ptr[?]): PFNGLGETMULTITEXPARAMETERIVEXTPROC = CFuncPtr.fromPtr(ptr.asInstanceOf[Ptr[Byte]])
    inline def apply(inline o: CFuncPtr4[GLenum, GLenum, GLenum, Ptr[GLint], Unit]): PFNGLGETMULTITEXPARAMETERIVEXTPROC = o
    extension (v: PFNGLGETMULTITEXPARAMETERIVEXTPROC)
      inline def value: CFuncPtr4[GLenum, GLenum, GLenum, Ptr[GLint], Unit] = v
      inline def toPtr: Ptr[?] = CFuncPtr.toPtr(v)

  opaque type PFNGLGETNAMEDBUFFERPARAMETERI64VPROC = CFuncPtr3[GLuint, GLenum, Ptr[GLint64], Unit]
  object PFNGLGETNAMEDBUFFERPARAMETERI64VPROC:
    given _tag: Tag[PFNGLGETNAMEDBUFFERPARAMETERI64VPROC] = Tag.materializeCFuncPtr3[GLuint, GLenum, Ptr[GLint64], Unit]
    inline def fromPtr(ptr: Ptr[Byte] | Ptr[?]): PFNGLGETNAMEDBUFFERPARAMETERI64VPROC = CFuncPtr.fromPtr(ptr.asInstanceOf[Ptr[Byte]])
    inline def apply(inline o: CFuncPtr3[GLuint, GLenum, Ptr[GLint64], Unit]): PFNGLGETNAMEDBUFFERPARAMETERI64VPROC = o
    extension (v: PFNGLGETNAMEDBUFFERPARAMETERI64VPROC)
      inline def value: CFuncPtr3[GLuint, GLenum, Ptr[GLint64], Unit] = v
      inline def toPtr: Ptr[?] = CFuncPtr.toPtr(v)

  opaque type PFNGLGETNAMEDBUFFERPARAMETERIVEXTPROC = CFuncPtr3[GLuint, GLenum, Ptr[GLint], Unit]
  object PFNGLGETNAMEDBUFFERPARAMETERIVEXTPROC:
    given _tag: Tag[PFNGLGETNAMEDBUFFERPARAMETERIVEXTPROC] = Tag.materializeCFuncPtr3[GLuint, GLenum, Ptr[GLint], Unit]
    inline def fromPtr(ptr: Ptr[Byte] | Ptr[?]): PFNGLGETNAMEDBUFFERPARAMETERIVEXTPROC = CFuncPtr.fromPtr(ptr.asInstanceOf[Ptr[Byte]])
    inline def apply(inline o: CFuncPtr3[GLuint, GLenum, Ptr[GLint], Unit]): PFNGLGETNAMEDBUFFERPARAMETERIVEXTPROC = o
    extension (v: PFNGLGETNAMEDBUFFERPARAMETERIVEXTPROC)
      inline def value: CFuncPtr3[GLuint, GLenum, Ptr[GLint], Unit] = v
      inline def toPtr: Ptr[?] = CFuncPtr.toPtr(v)

  opaque type PFNGLGETNAMEDBUFFERPARAMETERIVPROC = CFuncPtr3[GLuint, GLenum, Ptr[GLint], Unit]
  object PFNGLGETNAMEDBUFFERPARAMETERIVPROC:
    given _tag: Tag[PFNGLGETNAMEDBUFFERPARAMETERIVPROC] = Tag.materializeCFuncPtr3[GLuint, GLenum, Ptr[GLint], Unit]
    inline def fromPtr(ptr: Ptr[Byte] | Ptr[?]): PFNGLGETNAMEDBUFFERPARAMETERIVPROC = CFuncPtr.fromPtr(ptr.asInstanceOf[Ptr[Byte]])
    inline def apply(inline o: CFuncPtr3[GLuint, GLenum, Ptr[GLint], Unit]): PFNGLGETNAMEDBUFFERPARAMETERIVPROC = o
    extension (v: PFNGLGETNAMEDBUFFERPARAMETERIVPROC)
      inline def value: CFuncPtr3[GLuint, GLenum, Ptr[GLint], Unit] = v
      inline def toPtr: Ptr[?] = CFuncPtr.toPtr(v)

  opaque type PFNGLGETNAMEDBUFFERPARAMETERUI64VNVPROC = CFuncPtr3[GLuint, GLenum, Ptr[GLuint64EXT], Unit]
  object PFNGLGETNAMEDBUFFERPARAMETERUI64VNVPROC:
    given _tag: Tag[PFNGLGETNAMEDBUFFERPARAMETERUI64VNVPROC] = Tag.materializeCFuncPtr3[GLuint, GLenum, Ptr[GLuint64EXT], Unit]
    inline def fromPtr(ptr: Ptr[Byte] | Ptr[?]): PFNGLGETNAMEDBUFFERPARAMETERUI64VNVPROC = CFuncPtr.fromPtr(ptr.asInstanceOf[Ptr[Byte]])
    inline def apply(inline o: CFuncPtr3[GLuint, GLenum, Ptr[GLuint64EXT], Unit]): PFNGLGETNAMEDBUFFERPARAMETERUI64VNVPROC = o
    extension (v: PFNGLGETNAMEDBUFFERPARAMETERUI64VNVPROC)
      inline def value: CFuncPtr3[GLuint, GLenum, Ptr[GLuint64EXT], Unit] = v
      inline def toPtr: Ptr[?] = CFuncPtr.toPtr(v)

  opaque type PFNGLGETNAMEDBUFFERPOINTERVEXTPROC = CFuncPtr3[GLuint, GLenum, Ptr[Ptr[Byte]], Unit]
  object PFNGLGETNAMEDBUFFERPOINTERVEXTPROC:
    given _tag: Tag[PFNGLGETNAMEDBUFFERPOINTERVEXTPROC] = Tag.materializeCFuncPtr3[GLuint, GLenum, Ptr[Ptr[Byte]], Unit]
    inline def fromPtr(ptr: Ptr[Byte] | Ptr[?]): PFNGLGETNAMEDBUFFERPOINTERVEXTPROC = CFuncPtr.fromPtr(ptr.asInstanceOf[Ptr[Byte]])
    inline def apply(inline o: CFuncPtr3[GLuint, GLenum, Ptr[Ptr[Byte]], Unit]): PFNGLGETNAMEDBUFFERPOINTERVEXTPROC = o
    extension (v: PFNGLGETNAMEDBUFFERPOINTERVEXTPROC)
      inline def value: CFuncPtr3[GLuint, GLenum, Ptr[Ptr[Byte]], Unit] = v
      inline def toPtr: Ptr[?] = CFuncPtr.toPtr(v)

  opaque type PFNGLGETNAMEDBUFFERPOINTERVPROC = CFuncPtr3[GLuint, GLenum, Ptr[Ptr[Byte]], Unit]
  object PFNGLGETNAMEDBUFFERPOINTERVPROC:
    given _tag: Tag[PFNGLGETNAMEDBUFFERPOINTERVPROC] = Tag.materializeCFuncPtr3[GLuint, GLenum, Ptr[Ptr[Byte]], Unit]
    inline def fromPtr(ptr: Ptr[Byte] | Ptr[?]): PFNGLGETNAMEDBUFFERPOINTERVPROC = CFuncPtr.fromPtr(ptr.asInstanceOf[Ptr[Byte]])
    inline def apply(inline o: CFuncPtr3[GLuint, GLenum, Ptr[Ptr[Byte]], Unit]): PFNGLGETNAMEDBUFFERPOINTERVPROC = o
    extension (v: PFNGLGETNAMEDBUFFERPOINTERVPROC)
      inline def value: CFuncPtr3[GLuint, GLenum, Ptr[Ptr[Byte]], Unit] = v
      inline def toPtr: Ptr[?] = CFuncPtr.toPtr(v)

  opaque type PFNGLGETNAMEDBUFFERSUBDATAEXTPROC = CFuncPtr4[GLuint, GLintptr, GLsizeiptr, Ptr[Byte], Unit]
  object PFNGLGETNAMEDBUFFERSUBDATAEXTPROC:
    given _tag: Tag[PFNGLGETNAMEDBUFFERSUBDATAEXTPROC] = Tag.materializeCFuncPtr4[GLuint, GLintptr, GLsizeiptr, Ptr[Byte], Unit]
    inline def fromPtr(ptr: Ptr[Byte] | Ptr[?]): PFNGLGETNAMEDBUFFERSUBDATAEXTPROC = CFuncPtr.fromPtr(ptr.asInstanceOf[Ptr[Byte]])
    inline def apply(inline o: CFuncPtr4[GLuint, GLintptr, GLsizeiptr, Ptr[Byte], Unit]): PFNGLGETNAMEDBUFFERSUBDATAEXTPROC = o
    extension (v: PFNGLGETNAMEDBUFFERSUBDATAEXTPROC)
      inline def value: CFuncPtr4[GLuint, GLintptr, GLsizeiptr, Ptr[Byte], Unit] = v
      inline def toPtr: Ptr[?] = CFuncPtr.toPtr(v)

  opaque type PFNGLGETNAMEDBUFFERSUBDATAPROC = CFuncPtr4[GLuint, GLintptr, GLsizeiptr, Ptr[Byte], Unit]
  object PFNGLGETNAMEDBUFFERSUBDATAPROC:
    given _tag: Tag[PFNGLGETNAMEDBUFFERSUBDATAPROC] = Tag.materializeCFuncPtr4[GLuint, GLintptr, GLsizeiptr, Ptr[Byte], Unit]
    inline def fromPtr(ptr: Ptr[Byte] | Ptr[?]): PFNGLGETNAMEDBUFFERSUBDATAPROC = CFuncPtr.fromPtr(ptr.asInstanceOf[Ptr[Byte]])
    inline def apply(inline o: CFuncPtr4[GLuint, GLintptr, GLsizeiptr, Ptr[Byte], Unit]): PFNGLGETNAMEDBUFFERSUBDATAPROC = o
    extension (v: PFNGLGETNAMEDBUFFERSUBDATAPROC)
      inline def value: CFuncPtr4[GLuint, GLintptr, GLsizeiptr, Ptr[Byte], Unit] = v
      inline def toPtr: Ptr[?] = CFuncPtr.toPtr(v)

  opaque type PFNGLGETNAMEDFRAMEBUFFERATTACHMENTPARAMETERIVEXTPROC = CFuncPtr4[GLuint, GLenum, GLenum, Ptr[GLint], Unit]
  object PFNGLGETNAMEDFRAMEBUFFERATTACHMENTPARAMETERIVEXTPROC:
    given _tag: Tag[PFNGLGETNAMEDFRAMEBUFFERATTACHMENTPARAMETERIVEXTPROC] = Tag.materializeCFuncPtr4[GLuint, GLenum, GLenum, Ptr[GLint], Unit]
    inline def fromPtr(ptr: Ptr[Byte] | Ptr[?]): PFNGLGETNAMEDFRAMEBUFFERATTACHMENTPARAMETERIVEXTPROC = CFuncPtr.fromPtr(ptr.asInstanceOf[Ptr[Byte]])
    inline def apply(inline o: CFuncPtr4[GLuint, GLenum, GLenum, Ptr[GLint], Unit]): PFNGLGETNAMEDFRAMEBUFFERATTACHMENTPARAMETERIVEXTPROC = o
    extension (v: PFNGLGETNAMEDFRAMEBUFFERATTACHMENTPARAMETERIVEXTPROC)
      inline def value: CFuncPtr4[GLuint, GLenum, GLenum, Ptr[GLint], Unit] = v
      inline def toPtr: Ptr[?] = CFuncPtr.toPtr(v)

  opaque type PFNGLGETNAMEDFRAMEBUFFERATTACHMENTPARAMETERIVPROC = CFuncPtr4[GLuint, GLenum, GLenum, Ptr[GLint], Unit]
  object PFNGLGETNAMEDFRAMEBUFFERATTACHMENTPARAMETERIVPROC:
    given _tag: Tag[PFNGLGETNAMEDFRAMEBUFFERATTACHMENTPARAMETERIVPROC] = Tag.materializeCFuncPtr4[GLuint, GLenum, GLenum, Ptr[GLint], Unit]
    inline def fromPtr(ptr: Ptr[Byte] | Ptr[?]): PFNGLGETNAMEDFRAMEBUFFERATTACHMENTPARAMETERIVPROC = CFuncPtr.fromPtr(ptr.asInstanceOf[Ptr[Byte]])
    inline def apply(inline o: CFuncPtr4[GLuint, GLenum, GLenum, Ptr[GLint], Unit]): PFNGLGETNAMEDFRAMEBUFFERATTACHMENTPARAMETERIVPROC = o
    extension (v: PFNGLGETNAMEDFRAMEBUFFERATTACHMENTPARAMETERIVPROC)
      inline def value: CFuncPtr4[GLuint, GLenum, GLenum, Ptr[GLint], Unit] = v
      inline def toPtr: Ptr[?] = CFuncPtr.toPtr(v)

  opaque type PFNGLGETNAMEDFRAMEBUFFERPARAMETERFVAMDPROC = CFuncPtr6[GLuint, GLenum, GLuint, GLuint, GLsizei, Ptr[GLfloat], Unit]
  object PFNGLGETNAMEDFRAMEBUFFERPARAMETERFVAMDPROC:
    given _tag: Tag[PFNGLGETNAMEDFRAMEBUFFERPARAMETERFVAMDPROC] = Tag.materializeCFuncPtr6[GLuint, GLenum, GLuint, GLuint, GLsizei, Ptr[GLfloat], Unit]
    inline def fromPtr(ptr: Ptr[Byte] | Ptr[?]): PFNGLGETNAMEDFRAMEBUFFERPARAMETERFVAMDPROC = CFuncPtr.fromPtr(ptr.asInstanceOf[Ptr[Byte]])
    inline def apply(inline o: CFuncPtr6[GLuint, GLenum, GLuint, GLuint, GLsizei, Ptr[GLfloat], Unit]): PFNGLGETNAMEDFRAMEBUFFERPARAMETERFVAMDPROC = o
    extension (v: PFNGLGETNAMEDFRAMEBUFFERPARAMETERFVAMDPROC)
      inline def value: CFuncPtr6[GLuint, GLenum, GLuint, GLuint, GLsizei, Ptr[GLfloat], Unit] = v
      inline def toPtr: Ptr[?] = CFuncPtr.toPtr(v)

  opaque type PFNGLGETNAMEDFRAMEBUFFERPARAMETERIVEXTPROC = CFuncPtr3[GLuint, GLenum, Ptr[GLint], Unit]
  object PFNGLGETNAMEDFRAMEBUFFERPARAMETERIVEXTPROC:
    given _tag: Tag[PFNGLGETNAMEDFRAMEBUFFERPARAMETERIVEXTPROC] = Tag.materializeCFuncPtr3[GLuint, GLenum, Ptr[GLint], Unit]
    inline def fromPtr(ptr: Ptr[Byte] | Ptr[?]): PFNGLGETNAMEDFRAMEBUFFERPARAMETERIVEXTPROC = CFuncPtr.fromPtr(ptr.asInstanceOf[Ptr[Byte]])
    inline def apply(inline o: CFuncPtr3[GLuint, GLenum, Ptr[GLint], Unit]): PFNGLGETNAMEDFRAMEBUFFERPARAMETERIVEXTPROC = o
    extension (v: PFNGLGETNAMEDFRAMEBUFFERPARAMETERIVEXTPROC)
      inline def value: CFuncPtr3[GLuint, GLenum, Ptr[GLint], Unit] = v
      inline def toPtr: Ptr[?] = CFuncPtr.toPtr(v)

  opaque type PFNGLGETNAMEDFRAMEBUFFERPARAMETERIVPROC = CFuncPtr3[GLuint, GLenum, Ptr[GLint], Unit]
  object PFNGLGETNAMEDFRAMEBUFFERPARAMETERIVPROC:
    given _tag: Tag[PFNGLGETNAMEDFRAMEBUFFERPARAMETERIVPROC] = Tag.materializeCFuncPtr3[GLuint, GLenum, Ptr[GLint], Unit]
    inline def fromPtr(ptr: Ptr[Byte] | Ptr[?]): PFNGLGETNAMEDFRAMEBUFFERPARAMETERIVPROC = CFuncPtr.fromPtr(ptr.asInstanceOf[Ptr[Byte]])
    inline def apply(inline o: CFuncPtr3[GLuint, GLenum, Ptr[GLint], Unit]): PFNGLGETNAMEDFRAMEBUFFERPARAMETERIVPROC = o
    extension (v: PFNGLGETNAMEDFRAMEBUFFERPARAMETERIVPROC)
      inline def value: CFuncPtr3[GLuint, GLenum, Ptr[GLint], Unit] = v
      inline def toPtr: Ptr[?] = CFuncPtr.toPtr(v)

  opaque type PFNGLGETNAMEDPROGRAMIVEXTPROC = CFuncPtr4[GLuint, GLenum, GLenum, Ptr[GLint], Unit]
  object PFNGLGETNAMEDPROGRAMIVEXTPROC:
    given _tag: Tag[PFNGLGETNAMEDPROGRAMIVEXTPROC] = Tag.materializeCFuncPtr4[GLuint, GLenum, GLenum, Ptr[GLint], Unit]
    inline def fromPtr(ptr: Ptr[Byte] | Ptr[?]): PFNGLGETNAMEDPROGRAMIVEXTPROC = CFuncPtr.fromPtr(ptr.asInstanceOf[Ptr[Byte]])
    inline def apply(inline o: CFuncPtr4[GLuint, GLenum, GLenum, Ptr[GLint], Unit]): PFNGLGETNAMEDPROGRAMIVEXTPROC = o
    extension (v: PFNGLGETNAMEDPROGRAMIVEXTPROC)
      inline def value: CFuncPtr4[GLuint, GLenum, GLenum, Ptr[GLint], Unit] = v
      inline def toPtr: Ptr[?] = CFuncPtr.toPtr(v)

  opaque type PFNGLGETNAMEDPROGRAMLOCALPARAMETERDVEXTPROC = CFuncPtr4[GLuint, GLenum, GLuint, Ptr[GLdouble], Unit]
  object PFNGLGETNAMEDPROGRAMLOCALPARAMETERDVEXTPROC:
    given _tag: Tag[PFNGLGETNAMEDPROGRAMLOCALPARAMETERDVEXTPROC] = Tag.materializeCFuncPtr4[GLuint, GLenum, GLuint, Ptr[GLdouble], Unit]
    inline def fromPtr(ptr: Ptr[Byte] | Ptr[?]): PFNGLGETNAMEDPROGRAMLOCALPARAMETERDVEXTPROC = CFuncPtr.fromPtr(ptr.asInstanceOf[Ptr[Byte]])
    inline def apply(inline o: CFuncPtr4[GLuint, GLenum, GLuint, Ptr[GLdouble], Unit]): PFNGLGETNAMEDPROGRAMLOCALPARAMETERDVEXTPROC = o
    extension (v: PFNGLGETNAMEDPROGRAMLOCALPARAMETERDVEXTPROC)
      inline def value: CFuncPtr4[GLuint, GLenum, GLuint, Ptr[GLdouble], Unit] = v
      inline def toPtr: Ptr[?] = CFuncPtr.toPtr(v)

  opaque type PFNGLGETNAMEDPROGRAMLOCALPARAMETERFVEXTPROC = CFuncPtr4[GLuint, GLenum, GLuint, Ptr[GLfloat], Unit]
  object PFNGLGETNAMEDPROGRAMLOCALPARAMETERFVEXTPROC:
    given _tag: Tag[PFNGLGETNAMEDPROGRAMLOCALPARAMETERFVEXTPROC] = Tag.materializeCFuncPtr4[GLuint, GLenum, GLuint, Ptr[GLfloat], Unit]
    inline def fromPtr(ptr: Ptr[Byte] | Ptr[?]): PFNGLGETNAMEDPROGRAMLOCALPARAMETERFVEXTPROC = CFuncPtr.fromPtr(ptr.asInstanceOf[Ptr[Byte]])
    inline def apply(inline o: CFuncPtr4[GLuint, GLenum, GLuint, Ptr[GLfloat], Unit]): PFNGLGETNAMEDPROGRAMLOCALPARAMETERFVEXTPROC = o
    extension (v: PFNGLGETNAMEDPROGRAMLOCALPARAMETERFVEXTPROC)
      inline def value: CFuncPtr4[GLuint, GLenum, GLuint, Ptr[GLfloat], Unit] = v
      inline def toPtr: Ptr[?] = CFuncPtr.toPtr(v)

  opaque type PFNGLGETNAMEDPROGRAMLOCALPARAMETERIIVEXTPROC = CFuncPtr4[GLuint, GLenum, GLuint, Ptr[GLint], Unit]
  object PFNGLGETNAMEDPROGRAMLOCALPARAMETERIIVEXTPROC:
    given _tag: Tag[PFNGLGETNAMEDPROGRAMLOCALPARAMETERIIVEXTPROC] = Tag.materializeCFuncPtr4[GLuint, GLenum, GLuint, Ptr[GLint], Unit]
    inline def fromPtr(ptr: Ptr[Byte] | Ptr[?]): PFNGLGETNAMEDPROGRAMLOCALPARAMETERIIVEXTPROC = CFuncPtr.fromPtr(ptr.asInstanceOf[Ptr[Byte]])
    inline def apply(inline o: CFuncPtr4[GLuint, GLenum, GLuint, Ptr[GLint], Unit]): PFNGLGETNAMEDPROGRAMLOCALPARAMETERIIVEXTPROC = o
    extension (v: PFNGLGETNAMEDPROGRAMLOCALPARAMETERIIVEXTPROC)
      inline def value: CFuncPtr4[GLuint, GLenum, GLuint, Ptr[GLint], Unit] = v
      inline def toPtr: Ptr[?] = CFuncPtr.toPtr(v)

  opaque type PFNGLGETNAMEDPROGRAMLOCALPARAMETERIUIVEXTPROC = CFuncPtr4[GLuint, GLenum, GLuint, Ptr[GLuint], Unit]
  object PFNGLGETNAMEDPROGRAMLOCALPARAMETERIUIVEXTPROC:
    given _tag: Tag[PFNGLGETNAMEDPROGRAMLOCALPARAMETERIUIVEXTPROC] = Tag.materializeCFuncPtr4[GLuint, GLenum, GLuint, Ptr[GLuint], Unit]
    inline def fromPtr(ptr: Ptr[Byte] | Ptr[?]): PFNGLGETNAMEDPROGRAMLOCALPARAMETERIUIVEXTPROC = CFuncPtr.fromPtr(ptr.asInstanceOf[Ptr[Byte]])
    inline def apply(inline o: CFuncPtr4[GLuint, GLenum, GLuint, Ptr[GLuint], Unit]): PFNGLGETNAMEDPROGRAMLOCALPARAMETERIUIVEXTPROC = o
    extension (v: PFNGLGETNAMEDPROGRAMLOCALPARAMETERIUIVEXTPROC)
      inline def value: CFuncPtr4[GLuint, GLenum, GLuint, Ptr[GLuint], Unit] = v
      inline def toPtr: Ptr[?] = CFuncPtr.toPtr(v)

  opaque type PFNGLGETNAMEDPROGRAMSTRINGEXTPROC = CFuncPtr4[GLuint, GLenum, GLenum, Ptr[Byte], Unit]
  object PFNGLGETNAMEDPROGRAMSTRINGEXTPROC:
    given _tag: Tag[PFNGLGETNAMEDPROGRAMSTRINGEXTPROC] = Tag.materializeCFuncPtr4[GLuint, GLenum, GLenum, Ptr[Byte], Unit]
    inline def fromPtr(ptr: Ptr[Byte] | Ptr[?]): PFNGLGETNAMEDPROGRAMSTRINGEXTPROC = CFuncPtr.fromPtr(ptr.asInstanceOf[Ptr[Byte]])
    inline def apply(inline o: CFuncPtr4[GLuint, GLenum, GLenum, Ptr[Byte], Unit]): PFNGLGETNAMEDPROGRAMSTRINGEXTPROC = o
    extension (v: PFNGLGETNAMEDPROGRAMSTRINGEXTPROC)
      inline def value: CFuncPtr4[GLuint, GLenum, GLenum, Ptr[Byte], Unit] = v
      inline def toPtr: Ptr[?] = CFuncPtr.toPtr(v)

  opaque type PFNGLGETNAMEDRENDERBUFFERPARAMETERIVEXTPROC = CFuncPtr3[GLuint, GLenum, Ptr[GLint], Unit]
  object PFNGLGETNAMEDRENDERBUFFERPARAMETERIVEXTPROC:
    given _tag: Tag[PFNGLGETNAMEDRENDERBUFFERPARAMETERIVEXTPROC] = Tag.materializeCFuncPtr3[GLuint, GLenum, Ptr[GLint], Unit]
    inline def fromPtr(ptr: Ptr[Byte] | Ptr[?]): PFNGLGETNAMEDRENDERBUFFERPARAMETERIVEXTPROC = CFuncPtr.fromPtr(ptr.asInstanceOf[Ptr[Byte]])
    inline def apply(inline o: CFuncPtr3[GLuint, GLenum, Ptr[GLint], Unit]): PFNGLGETNAMEDRENDERBUFFERPARAMETERIVEXTPROC = o
    extension (v: PFNGLGETNAMEDRENDERBUFFERPARAMETERIVEXTPROC)
      inline def value: CFuncPtr3[GLuint, GLenum, Ptr[GLint], Unit] = v
      inline def toPtr: Ptr[?] = CFuncPtr.toPtr(v)

  opaque type PFNGLGETNAMEDRENDERBUFFERPARAMETERIVPROC = CFuncPtr3[GLuint, GLenum, Ptr[GLint], Unit]
  object PFNGLGETNAMEDRENDERBUFFERPARAMETERIVPROC:
    given _tag: Tag[PFNGLGETNAMEDRENDERBUFFERPARAMETERIVPROC] = Tag.materializeCFuncPtr3[GLuint, GLenum, Ptr[GLint], Unit]
    inline def fromPtr(ptr: Ptr[Byte] | Ptr[?]): PFNGLGETNAMEDRENDERBUFFERPARAMETERIVPROC = CFuncPtr.fromPtr(ptr.asInstanceOf[Ptr[Byte]])
    inline def apply(inline o: CFuncPtr3[GLuint, GLenum, Ptr[GLint], Unit]): PFNGLGETNAMEDRENDERBUFFERPARAMETERIVPROC = o
    extension (v: PFNGLGETNAMEDRENDERBUFFERPARAMETERIVPROC)
      inline def value: CFuncPtr3[GLuint, GLenum, Ptr[GLint], Unit] = v
      inline def toPtr: Ptr[?] = CFuncPtr.toPtr(v)

  opaque type PFNGLGETNAMEDSTRINGARBPROC = CFuncPtr5[GLint, Ptr[GLchar], GLsizei, Ptr[GLint], Ptr[GLchar], Unit]
  object PFNGLGETNAMEDSTRINGARBPROC:
    given _tag: Tag[PFNGLGETNAMEDSTRINGARBPROC] = Tag.materializeCFuncPtr5[GLint, Ptr[GLchar], GLsizei, Ptr[GLint], Ptr[GLchar], Unit]
    inline def fromPtr(ptr: Ptr[Byte] | Ptr[?]): PFNGLGETNAMEDSTRINGARBPROC = CFuncPtr.fromPtr(ptr.asInstanceOf[Ptr[Byte]])
    inline def apply(inline o: CFuncPtr5[GLint, Ptr[GLchar], GLsizei, Ptr[GLint], Ptr[GLchar], Unit]): PFNGLGETNAMEDSTRINGARBPROC = o
    extension (v: PFNGLGETNAMEDSTRINGARBPROC)
      inline def value: CFuncPtr5[GLint, Ptr[GLchar], GLsizei, Ptr[GLint], Ptr[GLchar], Unit] = v
      inline def toPtr: Ptr[?] = CFuncPtr.toPtr(v)

  opaque type PFNGLGETNAMEDSTRINGIVARBPROC = CFuncPtr4[GLint, Ptr[GLchar], GLenum, Ptr[GLint], Unit]
  object PFNGLGETNAMEDSTRINGIVARBPROC:
    given _tag: Tag[PFNGLGETNAMEDSTRINGIVARBPROC] = Tag.materializeCFuncPtr4[GLint, Ptr[GLchar], GLenum, Ptr[GLint], Unit]
    inline def fromPtr(ptr: Ptr[Byte] | Ptr[?]): PFNGLGETNAMEDSTRINGIVARBPROC = CFuncPtr.fromPtr(ptr.asInstanceOf[Ptr[Byte]])
    inline def apply(inline o: CFuncPtr4[GLint, Ptr[GLchar], GLenum, Ptr[GLint], Unit]): PFNGLGETNAMEDSTRINGIVARBPROC = o
    extension (v: PFNGLGETNAMEDSTRINGIVARBPROC)
      inline def value: CFuncPtr4[GLint, Ptr[GLchar], GLenum, Ptr[GLint], Unit] = v
      inline def toPtr: Ptr[?] = CFuncPtr.toPtr(v)

  opaque type PFNGLGETNCOLORTABLEARBPROC = CFuncPtr5[GLenum, GLenum, GLenum, GLsizei, Ptr[Byte], Unit]
  object PFNGLGETNCOLORTABLEARBPROC:
    given _tag: Tag[PFNGLGETNCOLORTABLEARBPROC] = Tag.materializeCFuncPtr5[GLenum, GLenum, GLenum, GLsizei, Ptr[Byte], Unit]
    inline def fromPtr(ptr: Ptr[Byte] | Ptr[?]): PFNGLGETNCOLORTABLEARBPROC = CFuncPtr.fromPtr(ptr.asInstanceOf[Ptr[Byte]])
    inline def apply(inline o: CFuncPtr5[GLenum, GLenum, GLenum, GLsizei, Ptr[Byte], Unit]): PFNGLGETNCOLORTABLEARBPROC = o
    extension (v: PFNGLGETNCOLORTABLEARBPROC)
      inline def value: CFuncPtr5[GLenum, GLenum, GLenum, GLsizei, Ptr[Byte], Unit] = v
      inline def toPtr: Ptr[?] = CFuncPtr.toPtr(v)

  opaque type PFNGLGETNCOMPRESSEDTEXIMAGEARBPROC = CFuncPtr4[GLenum, GLint, GLsizei, Ptr[Byte], Unit]
  object PFNGLGETNCOMPRESSEDTEXIMAGEARBPROC:
    given _tag: Tag[PFNGLGETNCOMPRESSEDTEXIMAGEARBPROC] = Tag.materializeCFuncPtr4[GLenum, GLint, GLsizei, Ptr[Byte], Unit]
    inline def fromPtr(ptr: Ptr[Byte] | Ptr[?]): PFNGLGETNCOMPRESSEDTEXIMAGEARBPROC = CFuncPtr.fromPtr(ptr.asInstanceOf[Ptr[Byte]])
    inline def apply(inline o: CFuncPtr4[GLenum, GLint, GLsizei, Ptr[Byte], Unit]): PFNGLGETNCOMPRESSEDTEXIMAGEARBPROC = o
    extension (v: PFNGLGETNCOMPRESSEDTEXIMAGEARBPROC)
      inline def value: CFuncPtr4[GLenum, GLint, GLsizei, Ptr[Byte], Unit] = v
      inline def toPtr: Ptr[?] = CFuncPtr.toPtr(v)

  opaque type PFNGLGETNCOMPRESSEDTEXIMAGEPROC = CFuncPtr4[GLenum, GLint, GLsizei, Ptr[GLvoid], Unit]
  object PFNGLGETNCOMPRESSEDTEXIMAGEPROC:
    given _tag: Tag[PFNGLGETNCOMPRESSEDTEXIMAGEPROC] = Tag.materializeCFuncPtr4[GLenum, GLint, GLsizei, Ptr[GLvoid], Unit]
    inline def fromPtr(ptr: Ptr[Byte] | Ptr[?]): PFNGLGETNCOMPRESSEDTEXIMAGEPROC = CFuncPtr.fromPtr(ptr.asInstanceOf[Ptr[Byte]])
    inline def apply(inline o: CFuncPtr4[GLenum, GLint, GLsizei, Ptr[GLvoid], Unit]): PFNGLGETNCOMPRESSEDTEXIMAGEPROC = o
    extension (v: PFNGLGETNCOMPRESSEDTEXIMAGEPROC)
      inline def value: CFuncPtr4[GLenum, GLint, GLsizei, Ptr[GLvoid], Unit] = v
      inline def toPtr: Ptr[?] = CFuncPtr.toPtr(v)

  opaque type PFNGLGETNCONVOLUTIONFILTERARBPROC = CFuncPtr5[GLenum, GLenum, GLenum, GLsizei, Ptr[Byte], Unit]
  object PFNGLGETNCONVOLUTIONFILTERARBPROC:
    given _tag: Tag[PFNGLGETNCONVOLUTIONFILTERARBPROC] = Tag.materializeCFuncPtr5[GLenum, GLenum, GLenum, GLsizei, Ptr[Byte], Unit]
    inline def fromPtr(ptr: Ptr[Byte] | Ptr[?]): PFNGLGETNCONVOLUTIONFILTERARBPROC = CFuncPtr.fromPtr(ptr.asInstanceOf[Ptr[Byte]])
    inline def apply(inline o: CFuncPtr5[GLenum, GLenum, GLenum, GLsizei, Ptr[Byte], Unit]): PFNGLGETNCONVOLUTIONFILTERARBPROC = o
    extension (v: PFNGLGETNCONVOLUTIONFILTERARBPROC)
      inline def value: CFuncPtr5[GLenum, GLenum, GLenum, GLsizei, Ptr[Byte], Unit] = v
      inline def toPtr: Ptr[?] = CFuncPtr.toPtr(v)

  opaque type PFNGLGETNEXTPERFQUERYIDINTELPROC = CFuncPtr2[GLuint, Ptr[GLuint], Unit]
  object PFNGLGETNEXTPERFQUERYIDINTELPROC:
    given _tag: Tag[PFNGLGETNEXTPERFQUERYIDINTELPROC] = Tag.materializeCFuncPtr2[GLuint, Ptr[GLuint], Unit]
    inline def fromPtr(ptr: Ptr[Byte] | Ptr[?]): PFNGLGETNEXTPERFQUERYIDINTELPROC = CFuncPtr.fromPtr(ptr.asInstanceOf[Ptr[Byte]])
    inline def apply(inline o: CFuncPtr2[GLuint, Ptr[GLuint], Unit]): PFNGLGETNEXTPERFQUERYIDINTELPROC = o
    extension (v: PFNGLGETNEXTPERFQUERYIDINTELPROC)
      inline def value: CFuncPtr2[GLuint, Ptr[GLuint], Unit] = v
      inline def toPtr: Ptr[?] = CFuncPtr.toPtr(v)

  opaque type PFNGLGETNHISTOGRAMARBPROC = CFuncPtr6[GLenum, GLboolean, GLenum, GLenum, GLsizei, Ptr[Byte], Unit]
  object PFNGLGETNHISTOGRAMARBPROC:
    given _tag: Tag[PFNGLGETNHISTOGRAMARBPROC] = Tag.materializeCFuncPtr6[GLenum, GLboolean, GLenum, GLenum, GLsizei, Ptr[Byte], Unit]
    inline def fromPtr(ptr: Ptr[Byte] | Ptr[?]): PFNGLGETNHISTOGRAMARBPROC = CFuncPtr.fromPtr(ptr.asInstanceOf[Ptr[Byte]])
    inline def apply(inline o: CFuncPtr6[GLenum, GLboolean, GLenum, GLenum, GLsizei, Ptr[Byte], Unit]): PFNGLGETNHISTOGRAMARBPROC = o
    extension (v: PFNGLGETNHISTOGRAMARBPROC)
      inline def value: CFuncPtr6[GLenum, GLboolean, GLenum, GLenum, GLsizei, Ptr[Byte], Unit] = v
      inline def toPtr: Ptr[?] = CFuncPtr.toPtr(v)

  opaque type PFNGLGETNMAPDVARBPROC = CFuncPtr4[GLenum, GLenum, GLsizei, Ptr[GLdouble], Unit]
  object PFNGLGETNMAPDVARBPROC:
    given _tag: Tag[PFNGLGETNMAPDVARBPROC] = Tag.materializeCFuncPtr4[GLenum, GLenum, GLsizei, Ptr[GLdouble], Unit]
    inline def fromPtr(ptr: Ptr[Byte] | Ptr[?]): PFNGLGETNMAPDVARBPROC = CFuncPtr.fromPtr(ptr.asInstanceOf[Ptr[Byte]])
    inline def apply(inline o: CFuncPtr4[GLenum, GLenum, GLsizei, Ptr[GLdouble], Unit]): PFNGLGETNMAPDVARBPROC = o
    extension (v: PFNGLGETNMAPDVARBPROC)
      inline def value: CFuncPtr4[GLenum, GLenum, GLsizei, Ptr[GLdouble], Unit] = v
      inline def toPtr: Ptr[?] = CFuncPtr.toPtr(v)

  opaque type PFNGLGETNMAPFVARBPROC = CFuncPtr4[GLenum, GLenum, GLsizei, Ptr[GLfloat], Unit]
  object PFNGLGETNMAPFVARBPROC:
    given _tag: Tag[PFNGLGETNMAPFVARBPROC] = Tag.materializeCFuncPtr4[GLenum, GLenum, GLsizei, Ptr[GLfloat], Unit]
    inline def fromPtr(ptr: Ptr[Byte] | Ptr[?]): PFNGLGETNMAPFVARBPROC = CFuncPtr.fromPtr(ptr.asInstanceOf[Ptr[Byte]])
    inline def apply(inline o: CFuncPtr4[GLenum, GLenum, GLsizei, Ptr[GLfloat], Unit]): PFNGLGETNMAPFVARBPROC = o
    extension (v: PFNGLGETNMAPFVARBPROC)
      inline def value: CFuncPtr4[GLenum, GLenum, GLsizei, Ptr[GLfloat], Unit] = v
      inline def toPtr: Ptr[?] = CFuncPtr.toPtr(v)

  opaque type PFNGLGETNMAPIVARBPROC = CFuncPtr4[GLenum, GLenum, GLsizei, Ptr[GLint], Unit]
  object PFNGLGETNMAPIVARBPROC:
    given _tag: Tag[PFNGLGETNMAPIVARBPROC] = Tag.materializeCFuncPtr4[GLenum, GLenum, GLsizei, Ptr[GLint], Unit]
    inline def fromPtr(ptr: Ptr[Byte] | Ptr[?]): PFNGLGETNMAPIVARBPROC = CFuncPtr.fromPtr(ptr.asInstanceOf[Ptr[Byte]])
    inline def apply(inline o: CFuncPtr4[GLenum, GLenum, GLsizei, Ptr[GLint], Unit]): PFNGLGETNMAPIVARBPROC = o
    extension (v: PFNGLGETNMAPIVARBPROC)
      inline def value: CFuncPtr4[GLenum, GLenum, GLsizei, Ptr[GLint], Unit] = v
      inline def toPtr: Ptr[?] = CFuncPtr.toPtr(v)

  opaque type PFNGLGETNMINMAXARBPROC = CFuncPtr6[GLenum, GLboolean, GLenum, GLenum, GLsizei, Ptr[Byte], Unit]
  object PFNGLGETNMINMAXARBPROC:
    given _tag: Tag[PFNGLGETNMINMAXARBPROC] = Tag.materializeCFuncPtr6[GLenum, GLboolean, GLenum, GLenum, GLsizei, Ptr[Byte], Unit]
    inline def fromPtr(ptr: Ptr[Byte] | Ptr[?]): PFNGLGETNMINMAXARBPROC = CFuncPtr.fromPtr(ptr.asInstanceOf[Ptr[Byte]])
    inline def apply(inline o: CFuncPtr6[GLenum, GLboolean, GLenum, GLenum, GLsizei, Ptr[Byte], Unit]): PFNGLGETNMINMAXARBPROC = o
    extension (v: PFNGLGETNMINMAXARBPROC)
      inline def value: CFuncPtr6[GLenum, GLboolean, GLenum, GLenum, GLsizei, Ptr[Byte], Unit] = v
      inline def toPtr: Ptr[?] = CFuncPtr.toPtr(v)

  opaque type PFNGLGETNONLINLIGHTFVSGIXPROC = CFuncPtr4[GLenum, GLenum, Ptr[GLint], Ptr[GLfloat], Unit]
  object PFNGLGETNONLINLIGHTFVSGIXPROC:
    given _tag: Tag[PFNGLGETNONLINLIGHTFVSGIXPROC] = Tag.materializeCFuncPtr4[GLenum, GLenum, Ptr[GLint], Ptr[GLfloat], Unit]
    inline def fromPtr(ptr: Ptr[Byte] | Ptr[?]): PFNGLGETNONLINLIGHTFVSGIXPROC = CFuncPtr.fromPtr(ptr.asInstanceOf[Ptr[Byte]])
    inline def apply(inline o: CFuncPtr4[GLenum, GLenum, Ptr[GLint], Ptr[GLfloat], Unit]): PFNGLGETNONLINLIGHTFVSGIXPROC = o
    extension (v: PFNGLGETNONLINLIGHTFVSGIXPROC)
      inline def value: CFuncPtr4[GLenum, GLenum, Ptr[GLint], Ptr[GLfloat], Unit] = v
      inline def toPtr: Ptr[?] = CFuncPtr.toPtr(v)

  opaque type PFNGLGETNONLINMATERIALFVSGIXPROC = CFuncPtr4[GLenum, GLenum, Ptr[GLint], Ptr[GLfloat], Unit]
  object PFNGLGETNONLINMATERIALFVSGIXPROC:
    given _tag: Tag[PFNGLGETNONLINMATERIALFVSGIXPROC] = Tag.materializeCFuncPtr4[GLenum, GLenum, Ptr[GLint], Ptr[GLfloat], Unit]
    inline def fromPtr(ptr: Ptr[Byte] | Ptr[?]): PFNGLGETNONLINMATERIALFVSGIXPROC = CFuncPtr.fromPtr(ptr.asInstanceOf[Ptr[Byte]])
    inline def apply(inline o: CFuncPtr4[GLenum, GLenum, Ptr[GLint], Ptr[GLfloat], Unit]): PFNGLGETNONLINMATERIALFVSGIXPROC = o
    extension (v: PFNGLGETNONLINMATERIALFVSGIXPROC)
      inline def value: CFuncPtr4[GLenum, GLenum, Ptr[GLint], Ptr[GLfloat], Unit] = v
      inline def toPtr: Ptr[?] = CFuncPtr.toPtr(v)

  opaque type PFNGLGETNPIXELMAPFVARBPROC = CFuncPtr3[GLenum, GLsizei, Ptr[GLfloat], Unit]
  object PFNGLGETNPIXELMAPFVARBPROC:
    given _tag: Tag[PFNGLGETNPIXELMAPFVARBPROC] = Tag.materializeCFuncPtr3[GLenum, GLsizei, Ptr[GLfloat], Unit]
    inline def fromPtr(ptr: Ptr[Byte] | Ptr[?]): PFNGLGETNPIXELMAPFVARBPROC = CFuncPtr.fromPtr(ptr.asInstanceOf[Ptr[Byte]])
    inline def apply(inline o: CFuncPtr3[GLenum, GLsizei, Ptr[GLfloat], Unit]): PFNGLGETNPIXELMAPFVARBPROC = o
    extension (v: PFNGLGETNPIXELMAPFVARBPROC)
      inline def value: CFuncPtr3[GLenum, GLsizei, Ptr[GLfloat], Unit] = v
      inline def toPtr: Ptr[?] = CFuncPtr.toPtr(v)

  opaque type PFNGLGETNPIXELMAPUIVARBPROC = CFuncPtr3[GLenum, GLsizei, Ptr[GLuint], Unit]
  object PFNGLGETNPIXELMAPUIVARBPROC:
    given _tag: Tag[PFNGLGETNPIXELMAPUIVARBPROC] = Tag.materializeCFuncPtr3[GLenum, GLsizei, Ptr[GLuint], Unit]
    inline def fromPtr(ptr: Ptr[Byte] | Ptr[?]): PFNGLGETNPIXELMAPUIVARBPROC = CFuncPtr.fromPtr(ptr.asInstanceOf[Ptr[Byte]])
    inline def apply(inline o: CFuncPtr3[GLenum, GLsizei, Ptr[GLuint], Unit]): PFNGLGETNPIXELMAPUIVARBPROC = o
    extension (v: PFNGLGETNPIXELMAPUIVARBPROC)
      inline def value: CFuncPtr3[GLenum, GLsizei, Ptr[GLuint], Unit] = v
      inline def toPtr: Ptr[?] = CFuncPtr.toPtr(v)

  opaque type PFNGLGETNPIXELMAPUSVARBPROC = CFuncPtr3[GLenum, GLsizei, Ptr[GLushort], Unit]
  object PFNGLGETNPIXELMAPUSVARBPROC:
    given _tag: Tag[PFNGLGETNPIXELMAPUSVARBPROC] = Tag.materializeCFuncPtr3[GLenum, GLsizei, Ptr[GLushort], Unit]
    inline def fromPtr(ptr: Ptr[Byte] | Ptr[?]): PFNGLGETNPIXELMAPUSVARBPROC = CFuncPtr.fromPtr(ptr.asInstanceOf[Ptr[Byte]])
    inline def apply(inline o: CFuncPtr3[GLenum, GLsizei, Ptr[GLushort], Unit]): PFNGLGETNPIXELMAPUSVARBPROC = o
    extension (v: PFNGLGETNPIXELMAPUSVARBPROC)
      inline def value: CFuncPtr3[GLenum, GLsizei, Ptr[GLushort], Unit] = v
      inline def toPtr: Ptr[?] = CFuncPtr.toPtr(v)

  opaque type PFNGLGETNPOLYGONSTIPPLEARBPROC = CFuncPtr2[GLsizei, Ptr[GLubyte], Unit]
  object PFNGLGETNPOLYGONSTIPPLEARBPROC:
    given _tag: Tag[PFNGLGETNPOLYGONSTIPPLEARBPROC] = Tag.materializeCFuncPtr2[GLsizei, Ptr[GLubyte], Unit]
    inline def fromPtr(ptr: Ptr[Byte] | Ptr[?]): PFNGLGETNPOLYGONSTIPPLEARBPROC = CFuncPtr.fromPtr(ptr.asInstanceOf[Ptr[Byte]])
    inline def apply(inline o: CFuncPtr2[GLsizei, Ptr[GLubyte], Unit]): PFNGLGETNPOLYGONSTIPPLEARBPROC = o
    extension (v: PFNGLGETNPOLYGONSTIPPLEARBPROC)
      inline def value: CFuncPtr2[GLsizei, Ptr[GLubyte], Unit] = v
      inline def toPtr: Ptr[?] = CFuncPtr.toPtr(v)

  opaque type PFNGLGETNSEPARABLEFILTERARBPROC = CFuncPtr8[GLenum, GLenum, GLenum, GLsizei, Ptr[Byte], GLsizei, Ptr[Byte], Ptr[Byte], Unit]
  object PFNGLGETNSEPARABLEFILTERARBPROC:
    given _tag: Tag[PFNGLGETNSEPARABLEFILTERARBPROC] = Tag.materializeCFuncPtr8[GLenum, GLenum, GLenum, GLsizei, Ptr[Byte], GLsizei, Ptr[Byte], Ptr[Byte], Unit]
    inline def fromPtr(ptr: Ptr[Byte] | Ptr[?]): PFNGLGETNSEPARABLEFILTERARBPROC = CFuncPtr.fromPtr(ptr.asInstanceOf[Ptr[Byte]])
    inline def apply(inline o: CFuncPtr8[GLenum, GLenum, GLenum, GLsizei, Ptr[Byte], GLsizei, Ptr[Byte], Ptr[Byte], Unit]): PFNGLGETNSEPARABLEFILTERARBPROC = o
    extension (v: PFNGLGETNSEPARABLEFILTERARBPROC)
      inline def value: CFuncPtr8[GLenum, GLenum, GLenum, GLsizei, Ptr[Byte], GLsizei, Ptr[Byte], Ptr[Byte], Unit] = v
      inline def toPtr: Ptr[?] = CFuncPtr.toPtr(v)

  opaque type PFNGLGETNTEXIMAGEARBPROC = CFuncPtr6[GLenum, GLint, GLenum, GLenum, GLsizei, Ptr[Byte], Unit]
  object PFNGLGETNTEXIMAGEARBPROC:
    given _tag: Tag[PFNGLGETNTEXIMAGEARBPROC] = Tag.materializeCFuncPtr6[GLenum, GLint, GLenum, GLenum, GLsizei, Ptr[Byte], Unit]
    inline def fromPtr(ptr: Ptr[Byte] | Ptr[?]): PFNGLGETNTEXIMAGEARBPROC = CFuncPtr.fromPtr(ptr.asInstanceOf[Ptr[Byte]])
    inline def apply(inline o: CFuncPtr6[GLenum, GLint, GLenum, GLenum, GLsizei, Ptr[Byte], Unit]): PFNGLGETNTEXIMAGEARBPROC = o
    extension (v: PFNGLGETNTEXIMAGEARBPROC)
      inline def value: CFuncPtr6[GLenum, GLint, GLenum, GLenum, GLsizei, Ptr[Byte], Unit] = v
      inline def toPtr: Ptr[?] = CFuncPtr.toPtr(v)

  opaque type PFNGLGETNTEXIMAGEPROC = CFuncPtr6[GLenum, GLint, GLenum, GLenum, GLsizei, Ptr[GLvoid], Unit]
  object PFNGLGETNTEXIMAGEPROC:
    given _tag: Tag[PFNGLGETNTEXIMAGEPROC] = Tag.materializeCFuncPtr6[GLenum, GLint, GLenum, GLenum, GLsizei, Ptr[GLvoid], Unit]
    inline def fromPtr(ptr: Ptr[Byte] | Ptr[?]): PFNGLGETNTEXIMAGEPROC = CFuncPtr.fromPtr(ptr.asInstanceOf[Ptr[Byte]])
    inline def apply(inline o: CFuncPtr6[GLenum, GLint, GLenum, GLenum, GLsizei, Ptr[GLvoid], Unit]): PFNGLGETNTEXIMAGEPROC = o
    extension (v: PFNGLGETNTEXIMAGEPROC)
      inline def value: CFuncPtr6[GLenum, GLint, GLenum, GLenum, GLsizei, Ptr[GLvoid], Unit] = v
      inline def toPtr: Ptr[?] = CFuncPtr.toPtr(v)

  opaque type PFNGLGETNUNIFORMDVARBPROC = CFuncPtr4[GLuint, GLint, GLsizei, Ptr[GLdouble], Unit]
  object PFNGLGETNUNIFORMDVARBPROC:
    given _tag: Tag[PFNGLGETNUNIFORMDVARBPROC] = Tag.materializeCFuncPtr4[GLuint, GLint, GLsizei, Ptr[GLdouble], Unit]
    inline def fromPtr(ptr: Ptr[Byte] | Ptr[?]): PFNGLGETNUNIFORMDVARBPROC = CFuncPtr.fromPtr(ptr.asInstanceOf[Ptr[Byte]])
    inline def apply(inline o: CFuncPtr4[GLuint, GLint, GLsizei, Ptr[GLdouble], Unit]): PFNGLGETNUNIFORMDVARBPROC = o
    extension (v: PFNGLGETNUNIFORMDVARBPROC)
      inline def value: CFuncPtr4[GLuint, GLint, GLsizei, Ptr[GLdouble], Unit] = v
      inline def toPtr: Ptr[?] = CFuncPtr.toPtr(v)

  opaque type PFNGLGETNUNIFORMDVPROC = CFuncPtr4[GLuint, GLint, GLsizei, Ptr[GLdouble], Unit]
  object PFNGLGETNUNIFORMDVPROC:
    given _tag: Tag[PFNGLGETNUNIFORMDVPROC] = Tag.materializeCFuncPtr4[GLuint, GLint, GLsizei, Ptr[GLdouble], Unit]
    inline def fromPtr(ptr: Ptr[Byte] | Ptr[?]): PFNGLGETNUNIFORMDVPROC = CFuncPtr.fromPtr(ptr.asInstanceOf[Ptr[Byte]])
    inline def apply(inline o: CFuncPtr4[GLuint, GLint, GLsizei, Ptr[GLdouble], Unit]): PFNGLGETNUNIFORMDVPROC = o
    extension (v: PFNGLGETNUNIFORMDVPROC)
      inline def value: CFuncPtr4[GLuint, GLint, GLsizei, Ptr[GLdouble], Unit] = v
      inline def toPtr: Ptr[?] = CFuncPtr.toPtr(v)

  opaque type PFNGLGETNUNIFORMFVARBPROC = CFuncPtr4[GLuint, GLint, GLsizei, Ptr[GLfloat], Unit]
  object PFNGLGETNUNIFORMFVARBPROC:
    given _tag: Tag[PFNGLGETNUNIFORMFVARBPROC] = Tag.materializeCFuncPtr4[GLuint, GLint, GLsizei, Ptr[GLfloat], Unit]
    inline def fromPtr(ptr: Ptr[Byte] | Ptr[?]): PFNGLGETNUNIFORMFVARBPROC = CFuncPtr.fromPtr(ptr.asInstanceOf[Ptr[Byte]])
    inline def apply(inline o: CFuncPtr4[GLuint, GLint, GLsizei, Ptr[GLfloat], Unit]): PFNGLGETNUNIFORMFVARBPROC = o
    extension (v: PFNGLGETNUNIFORMFVARBPROC)
      inline def value: CFuncPtr4[GLuint, GLint, GLsizei, Ptr[GLfloat], Unit] = v
      inline def toPtr: Ptr[?] = CFuncPtr.toPtr(v)

  opaque type PFNGLGETNUNIFORMFVEXTPROC = CFuncPtr4[GLuint, GLint, GLsizei, Ptr[GLfloat], Unit]
  object PFNGLGETNUNIFORMFVEXTPROC:
    given _tag: Tag[PFNGLGETNUNIFORMFVEXTPROC] = Tag.materializeCFuncPtr4[GLuint, GLint, GLsizei, Ptr[GLfloat], Unit]
    inline def fromPtr(ptr: Ptr[Byte] | Ptr[?]): PFNGLGETNUNIFORMFVEXTPROC = CFuncPtr.fromPtr(ptr.asInstanceOf[Ptr[Byte]])
    inline def apply(inline o: CFuncPtr4[GLuint, GLint, GLsizei, Ptr[GLfloat], Unit]): PFNGLGETNUNIFORMFVEXTPROC = o
    extension (v: PFNGLGETNUNIFORMFVEXTPROC)
      inline def value: CFuncPtr4[GLuint, GLint, GLsizei, Ptr[GLfloat], Unit] = v
      inline def toPtr: Ptr[?] = CFuncPtr.toPtr(v)

  opaque type PFNGLGETNUNIFORMFVPROC = CFuncPtr4[GLuint, GLint, GLsizei, Ptr[GLfloat], Unit]
  object PFNGLGETNUNIFORMFVPROC:
    given _tag: Tag[PFNGLGETNUNIFORMFVPROC] = Tag.materializeCFuncPtr4[GLuint, GLint, GLsizei, Ptr[GLfloat], Unit]
    inline def fromPtr(ptr: Ptr[Byte] | Ptr[?]): PFNGLGETNUNIFORMFVPROC = CFuncPtr.fromPtr(ptr.asInstanceOf[Ptr[Byte]])
    inline def apply(inline o: CFuncPtr4[GLuint, GLint, GLsizei, Ptr[GLfloat], Unit]): PFNGLGETNUNIFORMFVPROC = o
    extension (v: PFNGLGETNUNIFORMFVPROC)
      inline def value: CFuncPtr4[GLuint, GLint, GLsizei, Ptr[GLfloat], Unit] = v
      inline def toPtr: Ptr[?] = CFuncPtr.toPtr(v)

  opaque type PFNGLGETNUNIFORMI64VARBPROC = CFuncPtr4[GLuint, GLint, GLsizei, Ptr[GLint64], Unit]
  object PFNGLGETNUNIFORMI64VARBPROC:
    given _tag: Tag[PFNGLGETNUNIFORMI64VARBPROC] = Tag.materializeCFuncPtr4[GLuint, GLint, GLsizei, Ptr[GLint64], Unit]
    inline def fromPtr(ptr: Ptr[Byte] | Ptr[?]): PFNGLGETNUNIFORMI64VARBPROC = CFuncPtr.fromPtr(ptr.asInstanceOf[Ptr[Byte]])
    inline def apply(inline o: CFuncPtr4[GLuint, GLint, GLsizei, Ptr[GLint64], Unit]): PFNGLGETNUNIFORMI64VARBPROC = o
    extension (v: PFNGLGETNUNIFORMI64VARBPROC)
      inline def value: CFuncPtr4[GLuint, GLint, GLsizei, Ptr[GLint64], Unit] = v
      inline def toPtr: Ptr[?] = CFuncPtr.toPtr(v)

  opaque type PFNGLGETNUNIFORMIVARBPROC = CFuncPtr4[GLuint, GLint, GLsizei, Ptr[GLint], Unit]
  object PFNGLGETNUNIFORMIVARBPROC:
    given _tag: Tag[PFNGLGETNUNIFORMIVARBPROC] = Tag.materializeCFuncPtr4[GLuint, GLint, GLsizei, Ptr[GLint], Unit]
    inline def fromPtr(ptr: Ptr[Byte] | Ptr[?]): PFNGLGETNUNIFORMIVARBPROC = CFuncPtr.fromPtr(ptr.asInstanceOf[Ptr[Byte]])
    inline def apply(inline o: CFuncPtr4[GLuint, GLint, GLsizei, Ptr[GLint], Unit]): PFNGLGETNUNIFORMIVARBPROC = o
    extension (v: PFNGLGETNUNIFORMIVARBPROC)
      inline def value: CFuncPtr4[GLuint, GLint, GLsizei, Ptr[GLint], Unit] = v
      inline def toPtr: Ptr[?] = CFuncPtr.toPtr(v)

  opaque type PFNGLGETNUNIFORMIVEXTPROC = CFuncPtr4[GLuint, GLint, GLsizei, Ptr[GLint], Unit]
  object PFNGLGETNUNIFORMIVEXTPROC:
    given _tag: Tag[PFNGLGETNUNIFORMIVEXTPROC] = Tag.materializeCFuncPtr4[GLuint, GLint, GLsizei, Ptr[GLint], Unit]
    inline def fromPtr(ptr: Ptr[Byte] | Ptr[?]): PFNGLGETNUNIFORMIVEXTPROC = CFuncPtr.fromPtr(ptr.asInstanceOf[Ptr[Byte]])
    inline def apply(inline o: CFuncPtr4[GLuint, GLint, GLsizei, Ptr[GLint], Unit]): PFNGLGETNUNIFORMIVEXTPROC = o
    extension (v: PFNGLGETNUNIFORMIVEXTPROC)
      inline def value: CFuncPtr4[GLuint, GLint, GLsizei, Ptr[GLint], Unit] = v
      inline def toPtr: Ptr[?] = CFuncPtr.toPtr(v)

  opaque type PFNGLGETNUNIFORMIVPROC = CFuncPtr4[GLuint, GLint, GLsizei, Ptr[GLint], Unit]
  object PFNGLGETNUNIFORMIVPROC:
    given _tag: Tag[PFNGLGETNUNIFORMIVPROC] = Tag.materializeCFuncPtr4[GLuint, GLint, GLsizei, Ptr[GLint], Unit]
    inline def fromPtr(ptr: Ptr[Byte] | Ptr[?]): PFNGLGETNUNIFORMIVPROC = CFuncPtr.fromPtr(ptr.asInstanceOf[Ptr[Byte]])
    inline def apply(inline o: CFuncPtr4[GLuint, GLint, GLsizei, Ptr[GLint], Unit]): PFNGLGETNUNIFORMIVPROC = o
    extension (v: PFNGLGETNUNIFORMIVPROC)
      inline def value: CFuncPtr4[GLuint, GLint, GLsizei, Ptr[GLint], Unit] = v
      inline def toPtr: Ptr[?] = CFuncPtr.toPtr(v)

  opaque type PFNGLGETNUNIFORMUI64VARBPROC = CFuncPtr4[GLuint, GLint, GLsizei, Ptr[GLuint64], Unit]
  object PFNGLGETNUNIFORMUI64VARBPROC:
    given _tag: Tag[PFNGLGETNUNIFORMUI64VARBPROC] = Tag.materializeCFuncPtr4[GLuint, GLint, GLsizei, Ptr[GLuint64], Unit]
    inline def fromPtr(ptr: Ptr[Byte] | Ptr[?]): PFNGLGETNUNIFORMUI64VARBPROC = CFuncPtr.fromPtr(ptr.asInstanceOf[Ptr[Byte]])
    inline def apply(inline o: CFuncPtr4[GLuint, GLint, GLsizei, Ptr[GLuint64], Unit]): PFNGLGETNUNIFORMUI64VARBPROC = o
    extension (v: PFNGLGETNUNIFORMUI64VARBPROC)
      inline def value: CFuncPtr4[GLuint, GLint, GLsizei, Ptr[GLuint64], Unit] = v
      inline def toPtr: Ptr[?] = CFuncPtr.toPtr(v)

  opaque type PFNGLGETNUNIFORMUIVARBPROC = CFuncPtr4[GLuint, GLint, GLsizei, Ptr[GLuint], Unit]
  object PFNGLGETNUNIFORMUIVARBPROC:
    given _tag: Tag[PFNGLGETNUNIFORMUIVARBPROC] = Tag.materializeCFuncPtr4[GLuint, GLint, GLsizei, Ptr[GLuint], Unit]
    inline def fromPtr(ptr: Ptr[Byte] | Ptr[?]): PFNGLGETNUNIFORMUIVARBPROC = CFuncPtr.fromPtr(ptr.asInstanceOf[Ptr[Byte]])
    inline def apply(inline o: CFuncPtr4[GLuint, GLint, GLsizei, Ptr[GLuint], Unit]): PFNGLGETNUNIFORMUIVARBPROC = o
    extension (v: PFNGLGETNUNIFORMUIVARBPROC)
      inline def value: CFuncPtr4[GLuint, GLint, GLsizei, Ptr[GLuint], Unit] = v
      inline def toPtr: Ptr[?] = CFuncPtr.toPtr(v)

  opaque type PFNGLGETNUNIFORMUIVPROC = CFuncPtr4[GLuint, GLint, GLsizei, Ptr[GLuint], Unit]
  object PFNGLGETNUNIFORMUIVPROC:
    given _tag: Tag[PFNGLGETNUNIFORMUIVPROC] = Tag.materializeCFuncPtr4[GLuint, GLint, GLsizei, Ptr[GLuint], Unit]
    inline def fromPtr(ptr: Ptr[Byte] | Ptr[?]): PFNGLGETNUNIFORMUIVPROC = CFuncPtr.fromPtr(ptr.asInstanceOf[Ptr[Byte]])
    inline def apply(inline o: CFuncPtr4[GLuint, GLint, GLsizei, Ptr[GLuint], Unit]): PFNGLGETNUNIFORMUIVPROC = o
    extension (v: PFNGLGETNUNIFORMUIVPROC)
      inline def value: CFuncPtr4[GLuint, GLint, GLsizei, Ptr[GLuint], Unit] = v
      inline def toPtr: Ptr[?] = CFuncPtr.toPtr(v)

  opaque type PFNGLGETOBJECTBUFFERFVATIPROC = CFuncPtr3[GLuint, GLenum, Ptr[GLfloat], Unit]
  object PFNGLGETOBJECTBUFFERFVATIPROC:
    given _tag: Tag[PFNGLGETOBJECTBUFFERFVATIPROC] = Tag.materializeCFuncPtr3[GLuint, GLenum, Ptr[GLfloat], Unit]
    inline def fromPtr(ptr: Ptr[Byte] | Ptr[?]): PFNGLGETOBJECTBUFFERFVATIPROC = CFuncPtr.fromPtr(ptr.asInstanceOf[Ptr[Byte]])
    inline def apply(inline o: CFuncPtr3[GLuint, GLenum, Ptr[GLfloat], Unit]): PFNGLGETOBJECTBUFFERFVATIPROC = o
    extension (v: PFNGLGETOBJECTBUFFERFVATIPROC)
      inline def value: CFuncPtr3[GLuint, GLenum, Ptr[GLfloat], Unit] = v
      inline def toPtr: Ptr[?] = CFuncPtr.toPtr(v)

  opaque type PFNGLGETOBJECTBUFFERIVATIPROC = CFuncPtr3[GLuint, GLenum, Ptr[GLint], Unit]
  object PFNGLGETOBJECTBUFFERIVATIPROC:
    given _tag: Tag[PFNGLGETOBJECTBUFFERIVATIPROC] = Tag.materializeCFuncPtr3[GLuint, GLenum, Ptr[GLint], Unit]
    inline def fromPtr(ptr: Ptr[Byte] | Ptr[?]): PFNGLGETOBJECTBUFFERIVATIPROC = CFuncPtr.fromPtr(ptr.asInstanceOf[Ptr[Byte]])
    inline def apply(inline o: CFuncPtr3[GLuint, GLenum, Ptr[GLint], Unit]): PFNGLGETOBJECTBUFFERIVATIPROC = o
    extension (v: PFNGLGETOBJECTBUFFERIVATIPROC)
      inline def value: CFuncPtr3[GLuint, GLenum, Ptr[GLint], Unit] = v
      inline def toPtr: Ptr[?] = CFuncPtr.toPtr(v)

  opaque type PFNGLGETOBJECTLABELEXTPROC = CFuncPtr5[GLenum, GLuint, GLsizei, Ptr[GLsizei], Ptr[GLchar], Unit]
  object PFNGLGETOBJECTLABELEXTPROC:
    given _tag: Tag[PFNGLGETOBJECTLABELEXTPROC] = Tag.materializeCFuncPtr5[GLenum, GLuint, GLsizei, Ptr[GLsizei], Ptr[GLchar], Unit]
    inline def fromPtr(ptr: Ptr[Byte] | Ptr[?]): PFNGLGETOBJECTLABELEXTPROC = CFuncPtr.fromPtr(ptr.asInstanceOf[Ptr[Byte]])
    inline def apply(inline o: CFuncPtr5[GLenum, GLuint, GLsizei, Ptr[GLsizei], Ptr[GLchar], Unit]): PFNGLGETOBJECTLABELEXTPROC = o
    extension (v: PFNGLGETOBJECTLABELEXTPROC)
      inline def value: CFuncPtr5[GLenum, GLuint, GLsizei, Ptr[GLsizei], Ptr[GLchar], Unit] = v
      inline def toPtr: Ptr[?] = CFuncPtr.toPtr(v)

  opaque type PFNGLGETOBJECTLABELPROC = CFuncPtr5[GLenum, GLuint, GLsizei, Ptr[GLsizei], Ptr[GLchar], Unit]
  object PFNGLGETOBJECTLABELPROC:
    given _tag: Tag[PFNGLGETOBJECTLABELPROC] = Tag.materializeCFuncPtr5[GLenum, GLuint, GLsizei, Ptr[GLsizei], Ptr[GLchar], Unit]
    inline def fromPtr(ptr: Ptr[Byte] | Ptr[?]): PFNGLGETOBJECTLABELPROC = CFuncPtr.fromPtr(ptr.asInstanceOf[Ptr[Byte]])
    inline def apply(inline o: CFuncPtr5[GLenum, GLuint, GLsizei, Ptr[GLsizei], Ptr[GLchar], Unit]): PFNGLGETOBJECTLABELPROC = o
    extension (v: PFNGLGETOBJECTLABELPROC)
      inline def value: CFuncPtr5[GLenum, GLuint, GLsizei, Ptr[GLsizei], Ptr[GLchar], Unit] = v
      inline def toPtr: Ptr[?] = CFuncPtr.toPtr(v)

  opaque type PFNGLGETOBJECTPARAMETERFVARBPROC = CFuncPtr3[GLhandleARB, GLenum, Ptr[GLfloat], Unit]
  object PFNGLGETOBJECTPARAMETERFVARBPROC:
    given _tag: Tag[PFNGLGETOBJECTPARAMETERFVARBPROC] = Tag.materializeCFuncPtr3[GLhandleARB, GLenum, Ptr[GLfloat], Unit]
    inline def fromPtr(ptr: Ptr[Byte] | Ptr[?]): PFNGLGETOBJECTPARAMETERFVARBPROC = CFuncPtr.fromPtr(ptr.asInstanceOf[Ptr[Byte]])
    inline def apply(inline o: CFuncPtr3[GLhandleARB, GLenum, Ptr[GLfloat], Unit]): PFNGLGETOBJECTPARAMETERFVARBPROC = o
    extension (v: PFNGLGETOBJECTPARAMETERFVARBPROC)
      inline def value: CFuncPtr3[GLhandleARB, GLenum, Ptr[GLfloat], Unit] = v
      inline def toPtr: Ptr[?] = CFuncPtr.toPtr(v)

  opaque type PFNGLGETOBJECTPARAMETERIVAPPLEPROC = CFuncPtr4[GLenum, GLuint, GLenum, Ptr[GLint], Unit]
  object PFNGLGETOBJECTPARAMETERIVAPPLEPROC:
    given _tag: Tag[PFNGLGETOBJECTPARAMETERIVAPPLEPROC] = Tag.materializeCFuncPtr4[GLenum, GLuint, GLenum, Ptr[GLint], Unit]
    inline def fromPtr(ptr: Ptr[Byte] | Ptr[?]): PFNGLGETOBJECTPARAMETERIVAPPLEPROC = CFuncPtr.fromPtr(ptr.asInstanceOf[Ptr[Byte]])
    inline def apply(inline o: CFuncPtr4[GLenum, GLuint, GLenum, Ptr[GLint], Unit]): PFNGLGETOBJECTPARAMETERIVAPPLEPROC = o
    extension (v: PFNGLGETOBJECTPARAMETERIVAPPLEPROC)
      inline def value: CFuncPtr4[GLenum, GLuint, GLenum, Ptr[GLint], Unit] = v
      inline def toPtr: Ptr[?] = CFuncPtr.toPtr(v)

  opaque type PFNGLGETOBJECTPARAMETERIVARBPROC = CFuncPtr3[GLhandleARB, GLenum, Ptr[GLint], Unit]
  object PFNGLGETOBJECTPARAMETERIVARBPROC:
    given _tag: Tag[PFNGLGETOBJECTPARAMETERIVARBPROC] = Tag.materializeCFuncPtr3[GLhandleARB, GLenum, Ptr[GLint], Unit]
    inline def fromPtr(ptr: Ptr[Byte] | Ptr[?]): PFNGLGETOBJECTPARAMETERIVARBPROC = CFuncPtr.fromPtr(ptr.asInstanceOf[Ptr[Byte]])
    inline def apply(inline o: CFuncPtr3[GLhandleARB, GLenum, Ptr[GLint], Unit]): PFNGLGETOBJECTPARAMETERIVARBPROC = o
    extension (v: PFNGLGETOBJECTPARAMETERIVARBPROC)
      inline def value: CFuncPtr3[GLhandleARB, GLenum, Ptr[GLint], Unit] = v
      inline def toPtr: Ptr[?] = CFuncPtr.toPtr(v)

  opaque type PFNGLGETOBJECTPTRLABELPROC = CFuncPtr4[Ptr[Byte], GLsizei, Ptr[GLsizei], Ptr[GLchar], Unit]
  object PFNGLGETOBJECTPTRLABELPROC:
    given _tag: Tag[PFNGLGETOBJECTPTRLABELPROC] = Tag.materializeCFuncPtr4[Ptr[Byte], GLsizei, Ptr[GLsizei], Ptr[GLchar], Unit]
    inline def fromPtr(ptr: Ptr[Byte] | Ptr[?]): PFNGLGETOBJECTPTRLABELPROC = CFuncPtr.fromPtr(ptr.asInstanceOf[Ptr[Byte]])
    inline def apply(inline o: CFuncPtr4[Ptr[Byte], GLsizei, Ptr[GLsizei], Ptr[GLchar], Unit]): PFNGLGETOBJECTPTRLABELPROC = o
    extension (v: PFNGLGETOBJECTPTRLABELPROC)
      inline def value: CFuncPtr4[Ptr[Byte], GLsizei, Ptr[GLsizei], Ptr[GLchar], Unit] = v
      inline def toPtr: Ptr[?] = CFuncPtr.toPtr(v)

  opaque type PFNGLGETOCCLUSIONQUERYIVNVPROC = CFuncPtr3[GLuint, GLenum, Ptr[GLint], Unit]
  object PFNGLGETOCCLUSIONQUERYIVNVPROC:
    given _tag: Tag[PFNGLGETOCCLUSIONQUERYIVNVPROC] = Tag.materializeCFuncPtr3[GLuint, GLenum, Ptr[GLint], Unit]
    inline def fromPtr(ptr: Ptr[Byte] | Ptr[?]): PFNGLGETOCCLUSIONQUERYIVNVPROC = CFuncPtr.fromPtr(ptr.asInstanceOf[Ptr[Byte]])
    inline def apply(inline o: CFuncPtr3[GLuint, GLenum, Ptr[GLint], Unit]): PFNGLGETOCCLUSIONQUERYIVNVPROC = o
    extension (v: PFNGLGETOCCLUSIONQUERYIVNVPROC)
      inline def value: CFuncPtr3[GLuint, GLenum, Ptr[GLint], Unit] = v
      inline def toPtr: Ptr[?] = CFuncPtr.toPtr(v)

  opaque type PFNGLGETOCCLUSIONQUERYUIVNVPROC = CFuncPtr3[GLuint, GLenum, Ptr[GLuint], Unit]
  object PFNGLGETOCCLUSIONQUERYUIVNVPROC:
    given _tag: Tag[PFNGLGETOCCLUSIONQUERYUIVNVPROC] = Tag.materializeCFuncPtr3[GLuint, GLenum, Ptr[GLuint], Unit]
    inline def fromPtr(ptr: Ptr[Byte] | Ptr[?]): PFNGLGETOCCLUSIONQUERYUIVNVPROC = CFuncPtr.fromPtr(ptr.asInstanceOf[Ptr[Byte]])
    inline def apply(inline o: CFuncPtr3[GLuint, GLenum, Ptr[GLuint], Unit]): PFNGLGETOCCLUSIONQUERYUIVNVPROC = o
    extension (v: PFNGLGETOCCLUSIONQUERYUIVNVPROC)
      inline def value: CFuncPtr3[GLuint, GLenum, Ptr[GLuint], Unit] = v
      inline def toPtr: Ptr[?] = CFuncPtr.toPtr(v)

  opaque type PFNGLGETPATHCOLORGENFVNVPROC = CFuncPtr3[GLenum, GLenum, Ptr[GLfloat], Unit]
  object PFNGLGETPATHCOLORGENFVNVPROC:
    given _tag: Tag[PFNGLGETPATHCOLORGENFVNVPROC] = Tag.materializeCFuncPtr3[GLenum, GLenum, Ptr[GLfloat], Unit]
    inline def fromPtr(ptr: Ptr[Byte] | Ptr[?]): PFNGLGETPATHCOLORGENFVNVPROC = CFuncPtr.fromPtr(ptr.asInstanceOf[Ptr[Byte]])
    inline def apply(inline o: CFuncPtr3[GLenum, GLenum, Ptr[GLfloat], Unit]): PFNGLGETPATHCOLORGENFVNVPROC = o
    extension (v: PFNGLGETPATHCOLORGENFVNVPROC)
      inline def value: CFuncPtr3[GLenum, GLenum, Ptr[GLfloat], Unit] = v
      inline def toPtr: Ptr[?] = CFuncPtr.toPtr(v)

  opaque type PFNGLGETPATHCOLORGENIVNVPROC = CFuncPtr3[GLenum, GLenum, Ptr[GLint], Unit]
  object PFNGLGETPATHCOLORGENIVNVPROC:
    given _tag: Tag[PFNGLGETPATHCOLORGENIVNVPROC] = Tag.materializeCFuncPtr3[GLenum, GLenum, Ptr[GLint], Unit]
    inline def fromPtr(ptr: Ptr[Byte] | Ptr[?]): PFNGLGETPATHCOLORGENIVNVPROC = CFuncPtr.fromPtr(ptr.asInstanceOf[Ptr[Byte]])
    inline def apply(inline o: CFuncPtr3[GLenum, GLenum, Ptr[GLint], Unit]): PFNGLGETPATHCOLORGENIVNVPROC = o
    extension (v: PFNGLGETPATHCOLORGENIVNVPROC)
      inline def value: CFuncPtr3[GLenum, GLenum, Ptr[GLint], Unit] = v
      inline def toPtr: Ptr[?] = CFuncPtr.toPtr(v)

  opaque type PFNGLGETPATHCOMMANDSNVPROC = CFuncPtr2[GLuint, Ptr[GLubyte], Unit]
  object PFNGLGETPATHCOMMANDSNVPROC:
    given _tag: Tag[PFNGLGETPATHCOMMANDSNVPROC] = Tag.materializeCFuncPtr2[GLuint, Ptr[GLubyte], Unit]
    inline def fromPtr(ptr: Ptr[Byte] | Ptr[?]): PFNGLGETPATHCOMMANDSNVPROC = CFuncPtr.fromPtr(ptr.asInstanceOf[Ptr[Byte]])
    inline def apply(inline o: CFuncPtr2[GLuint, Ptr[GLubyte], Unit]): PFNGLGETPATHCOMMANDSNVPROC = o
    extension (v: PFNGLGETPATHCOMMANDSNVPROC)
      inline def value: CFuncPtr2[GLuint, Ptr[GLubyte], Unit] = v
      inline def toPtr: Ptr[?] = CFuncPtr.toPtr(v)

  opaque type PFNGLGETPATHCOORDSNVPROC = CFuncPtr2[GLuint, Ptr[GLfloat], Unit]
  object PFNGLGETPATHCOORDSNVPROC:
    given _tag: Tag[PFNGLGETPATHCOORDSNVPROC] = Tag.materializeCFuncPtr2[GLuint, Ptr[GLfloat], Unit]
    inline def fromPtr(ptr: Ptr[Byte] | Ptr[?]): PFNGLGETPATHCOORDSNVPROC = CFuncPtr.fromPtr(ptr.asInstanceOf[Ptr[Byte]])
    inline def apply(inline o: CFuncPtr2[GLuint, Ptr[GLfloat], Unit]): PFNGLGETPATHCOORDSNVPROC = o
    extension (v: PFNGLGETPATHCOORDSNVPROC)
      inline def value: CFuncPtr2[GLuint, Ptr[GLfloat], Unit] = v
      inline def toPtr: Ptr[?] = CFuncPtr.toPtr(v)

  opaque type PFNGLGETPATHDASHARRAYNVPROC = CFuncPtr2[GLuint, Ptr[GLfloat], Unit]
  object PFNGLGETPATHDASHARRAYNVPROC:
    given _tag: Tag[PFNGLGETPATHDASHARRAYNVPROC] = Tag.materializeCFuncPtr2[GLuint, Ptr[GLfloat], Unit]
    inline def fromPtr(ptr: Ptr[Byte] | Ptr[?]): PFNGLGETPATHDASHARRAYNVPROC = CFuncPtr.fromPtr(ptr.asInstanceOf[Ptr[Byte]])
    inline def apply(inline o: CFuncPtr2[GLuint, Ptr[GLfloat], Unit]): PFNGLGETPATHDASHARRAYNVPROC = o
    extension (v: PFNGLGETPATHDASHARRAYNVPROC)
      inline def value: CFuncPtr2[GLuint, Ptr[GLfloat], Unit] = v
      inline def toPtr: Ptr[?] = CFuncPtr.toPtr(v)

  opaque type PFNGLGETPATHLENGTHNVPROC = CFuncPtr3[GLuint, GLsizei, GLsizei, GLfloat]
  object PFNGLGETPATHLENGTHNVPROC:
    given _tag: Tag[PFNGLGETPATHLENGTHNVPROC] = Tag.materializeCFuncPtr3[GLuint, GLsizei, GLsizei, GLfloat]
    inline def fromPtr(ptr: Ptr[Byte] | Ptr[?]): PFNGLGETPATHLENGTHNVPROC = CFuncPtr.fromPtr(ptr.asInstanceOf[Ptr[Byte]])
    inline def apply(inline o: CFuncPtr3[GLuint, GLsizei, GLsizei, GLfloat]): PFNGLGETPATHLENGTHNVPROC = o
    extension (v: PFNGLGETPATHLENGTHNVPROC)
      inline def value: CFuncPtr3[GLuint, GLsizei, GLsizei, GLfloat] = v
      inline def toPtr: Ptr[?] = CFuncPtr.toPtr(v)

  opaque type PFNGLGETPATHMETRICRANGENVPROC = CFuncPtr5[GLbitfield, GLuint, GLsizei, GLsizei, Ptr[GLfloat], Unit]
  object PFNGLGETPATHMETRICRANGENVPROC:
    given _tag: Tag[PFNGLGETPATHMETRICRANGENVPROC] = Tag.materializeCFuncPtr5[GLbitfield, GLuint, GLsizei, GLsizei, Ptr[GLfloat], Unit]
    inline def fromPtr(ptr: Ptr[Byte] | Ptr[?]): PFNGLGETPATHMETRICRANGENVPROC = CFuncPtr.fromPtr(ptr.asInstanceOf[Ptr[Byte]])
    inline def apply(inline o: CFuncPtr5[GLbitfield, GLuint, GLsizei, GLsizei, Ptr[GLfloat], Unit]): PFNGLGETPATHMETRICRANGENVPROC = o
    extension (v: PFNGLGETPATHMETRICRANGENVPROC)
      inline def value: CFuncPtr5[GLbitfield, GLuint, GLsizei, GLsizei, Ptr[GLfloat], Unit] = v
      inline def toPtr: Ptr[?] = CFuncPtr.toPtr(v)

  opaque type PFNGLGETPATHMETRICSNVPROC = CFuncPtr7[GLbitfield, GLsizei, GLenum, Ptr[Byte], GLuint, GLsizei, Ptr[GLfloat], Unit]
  object PFNGLGETPATHMETRICSNVPROC:
    given _tag: Tag[PFNGLGETPATHMETRICSNVPROC] = Tag.materializeCFuncPtr7[GLbitfield, GLsizei, GLenum, Ptr[Byte], GLuint, GLsizei, Ptr[GLfloat], Unit]
    inline def fromPtr(ptr: Ptr[Byte] | Ptr[?]): PFNGLGETPATHMETRICSNVPROC = CFuncPtr.fromPtr(ptr.asInstanceOf[Ptr[Byte]])
    inline def apply(inline o: CFuncPtr7[GLbitfield, GLsizei, GLenum, Ptr[Byte], GLuint, GLsizei, Ptr[GLfloat], Unit]): PFNGLGETPATHMETRICSNVPROC = o
    extension (v: PFNGLGETPATHMETRICSNVPROC)
      inline def value: CFuncPtr7[GLbitfield, GLsizei, GLenum, Ptr[Byte], GLuint, GLsizei, Ptr[GLfloat], Unit] = v
      inline def toPtr: Ptr[?] = CFuncPtr.toPtr(v)

  opaque type PFNGLGETPATHPARAMETERFVNVPROC = CFuncPtr3[GLuint, GLenum, Ptr[GLfloat], Unit]
  object PFNGLGETPATHPARAMETERFVNVPROC:
    given _tag: Tag[PFNGLGETPATHPARAMETERFVNVPROC] = Tag.materializeCFuncPtr3[GLuint, GLenum, Ptr[GLfloat], Unit]
    inline def fromPtr(ptr: Ptr[Byte] | Ptr[?]): PFNGLGETPATHPARAMETERFVNVPROC = CFuncPtr.fromPtr(ptr.asInstanceOf[Ptr[Byte]])
    inline def apply(inline o: CFuncPtr3[GLuint, GLenum, Ptr[GLfloat], Unit]): PFNGLGETPATHPARAMETERFVNVPROC = o
    extension (v: PFNGLGETPATHPARAMETERFVNVPROC)
      inline def value: CFuncPtr3[GLuint, GLenum, Ptr[GLfloat], Unit] = v
      inline def toPtr: Ptr[?] = CFuncPtr.toPtr(v)

  opaque type PFNGLGETPATHPARAMETERIVNVPROC = CFuncPtr3[GLuint, GLenum, Ptr[GLint], Unit]
  object PFNGLGETPATHPARAMETERIVNVPROC:
    given _tag: Tag[PFNGLGETPATHPARAMETERIVNVPROC] = Tag.materializeCFuncPtr3[GLuint, GLenum, Ptr[GLint], Unit]
    inline def fromPtr(ptr: Ptr[Byte] | Ptr[?]): PFNGLGETPATHPARAMETERIVNVPROC = CFuncPtr.fromPtr(ptr.asInstanceOf[Ptr[Byte]])
    inline def apply(inline o: CFuncPtr3[GLuint, GLenum, Ptr[GLint], Unit]): PFNGLGETPATHPARAMETERIVNVPROC = o
    extension (v: PFNGLGETPATHPARAMETERIVNVPROC)
      inline def value: CFuncPtr3[GLuint, GLenum, Ptr[GLint], Unit] = v
      inline def toPtr: Ptr[?] = CFuncPtr.toPtr(v)

  opaque type PFNGLGETPATHSPACINGNVPROC = CFuncPtr9[GLenum, GLsizei, GLenum, Ptr[Byte], GLuint, GLfloat, GLfloat, GLenum, Ptr[GLfloat], Unit]
  object PFNGLGETPATHSPACINGNVPROC:
    given _tag: Tag[PFNGLGETPATHSPACINGNVPROC] = Tag.materializeCFuncPtr9[GLenum, GLsizei, GLenum, Ptr[Byte], GLuint, GLfloat, GLfloat, GLenum, Ptr[GLfloat], Unit]
    inline def fromPtr(ptr: Ptr[Byte] | Ptr[?]): PFNGLGETPATHSPACINGNVPROC = CFuncPtr.fromPtr(ptr.asInstanceOf[Ptr[Byte]])
    inline def apply(inline o: CFuncPtr9[GLenum, GLsizei, GLenum, Ptr[Byte], GLuint, GLfloat, GLfloat, GLenum, Ptr[GLfloat], Unit]): PFNGLGETPATHSPACINGNVPROC = o
    extension (v: PFNGLGETPATHSPACINGNVPROC)
      inline def value: CFuncPtr9[GLenum, GLsizei, GLenum, Ptr[Byte], GLuint, GLfloat, GLfloat, GLenum, Ptr[GLfloat], Unit] = v
      inline def toPtr: Ptr[?] = CFuncPtr.toPtr(v)

  opaque type PFNGLGETPATHTEXGENFVNVPROC = CFuncPtr3[GLenum, GLenum, Ptr[GLfloat], Unit]
  object PFNGLGETPATHTEXGENFVNVPROC:
    given _tag: Tag[PFNGLGETPATHTEXGENFVNVPROC] = Tag.materializeCFuncPtr3[GLenum, GLenum, Ptr[GLfloat], Unit]
    inline def fromPtr(ptr: Ptr[Byte] | Ptr[?]): PFNGLGETPATHTEXGENFVNVPROC = CFuncPtr.fromPtr(ptr.asInstanceOf[Ptr[Byte]])
    inline def apply(inline o: CFuncPtr3[GLenum, GLenum, Ptr[GLfloat], Unit]): PFNGLGETPATHTEXGENFVNVPROC = o
    extension (v: PFNGLGETPATHTEXGENFVNVPROC)
      inline def value: CFuncPtr3[GLenum, GLenum, Ptr[GLfloat], Unit] = v
      inline def toPtr: Ptr[?] = CFuncPtr.toPtr(v)

  opaque type PFNGLGETPATHTEXGENIVNVPROC = CFuncPtr3[GLenum, GLenum, Ptr[GLint], Unit]
  object PFNGLGETPATHTEXGENIVNVPROC:
    given _tag: Tag[PFNGLGETPATHTEXGENIVNVPROC] = Tag.materializeCFuncPtr3[GLenum, GLenum, Ptr[GLint], Unit]
    inline def fromPtr(ptr: Ptr[Byte] | Ptr[?]): PFNGLGETPATHTEXGENIVNVPROC = CFuncPtr.fromPtr(ptr.asInstanceOf[Ptr[Byte]])
    inline def apply(inline o: CFuncPtr3[GLenum, GLenum, Ptr[GLint], Unit]): PFNGLGETPATHTEXGENIVNVPROC = o
    extension (v: PFNGLGETPATHTEXGENIVNVPROC)
      inline def value: CFuncPtr3[GLenum, GLenum, Ptr[GLint], Unit] = v
      inline def toPtr: Ptr[?] = CFuncPtr.toPtr(v)

  opaque type PFNGLGETPERFCOUNTERINFOINTELPROC = CFuncPtr11[GLuint, GLuint, GLuint, Ptr[GLchar], GLuint, Ptr[GLchar], Ptr[GLuint], Ptr[GLuint], Ptr[GLuint], Ptr[GLuint], Ptr[GLuint64], Unit]
  object PFNGLGETPERFCOUNTERINFOINTELPROC:
    given _tag: Tag[PFNGLGETPERFCOUNTERINFOINTELPROC] = Tag.materializeCFuncPtr11[GLuint, GLuint, GLuint, Ptr[GLchar], GLuint, Ptr[GLchar], Ptr[GLuint], Ptr[GLuint], Ptr[GLuint], Ptr[GLuint], Ptr[GLuint64], Unit]
    inline def fromPtr(ptr: Ptr[Byte] | Ptr[?]): PFNGLGETPERFCOUNTERINFOINTELPROC = CFuncPtr.fromPtr(ptr.asInstanceOf[Ptr[Byte]])
    inline def apply(inline o: CFuncPtr11[GLuint, GLuint, GLuint, Ptr[GLchar], GLuint, Ptr[GLchar], Ptr[GLuint], Ptr[GLuint], Ptr[GLuint], Ptr[GLuint], Ptr[GLuint64], Unit]): PFNGLGETPERFCOUNTERINFOINTELPROC = o
    extension (v: PFNGLGETPERFCOUNTERINFOINTELPROC)
      inline def value: CFuncPtr11[GLuint, GLuint, GLuint, Ptr[GLchar], GLuint, Ptr[GLchar], Ptr[GLuint], Ptr[GLuint], Ptr[GLuint], Ptr[GLuint], Ptr[GLuint64], Unit] = v
      inline def toPtr: Ptr[?] = CFuncPtr.toPtr(v)

  opaque type PFNGLGETPERFMONITORCOUNTERDATAAMDPROC = CFuncPtr5[GLuint, GLenum, GLsizei, Ptr[GLuint], Ptr[GLint], Unit]
  object PFNGLGETPERFMONITORCOUNTERDATAAMDPROC:
    given _tag: Tag[PFNGLGETPERFMONITORCOUNTERDATAAMDPROC] = Tag.materializeCFuncPtr5[GLuint, GLenum, GLsizei, Ptr[GLuint], Ptr[GLint], Unit]
    inline def fromPtr(ptr: Ptr[Byte] | Ptr[?]): PFNGLGETPERFMONITORCOUNTERDATAAMDPROC = CFuncPtr.fromPtr(ptr.asInstanceOf[Ptr[Byte]])
    inline def apply(inline o: CFuncPtr5[GLuint, GLenum, GLsizei, Ptr[GLuint], Ptr[GLint], Unit]): PFNGLGETPERFMONITORCOUNTERDATAAMDPROC = o
    extension (v: PFNGLGETPERFMONITORCOUNTERDATAAMDPROC)
      inline def value: CFuncPtr5[GLuint, GLenum, GLsizei, Ptr[GLuint], Ptr[GLint], Unit] = v
      inline def toPtr: Ptr[?] = CFuncPtr.toPtr(v)

  opaque type PFNGLGETPERFMONITORCOUNTERINFOAMDPROC = CFuncPtr4[GLuint, GLuint, GLenum, Ptr[Byte], Unit]
  object PFNGLGETPERFMONITORCOUNTERINFOAMDPROC:
    given _tag: Tag[PFNGLGETPERFMONITORCOUNTERINFOAMDPROC] = Tag.materializeCFuncPtr4[GLuint, GLuint, GLenum, Ptr[Byte], Unit]
    inline def fromPtr(ptr: Ptr[Byte] | Ptr[?]): PFNGLGETPERFMONITORCOUNTERINFOAMDPROC = CFuncPtr.fromPtr(ptr.asInstanceOf[Ptr[Byte]])
    inline def apply(inline o: CFuncPtr4[GLuint, GLuint, GLenum, Ptr[Byte], Unit]): PFNGLGETPERFMONITORCOUNTERINFOAMDPROC = o
    extension (v: PFNGLGETPERFMONITORCOUNTERINFOAMDPROC)
      inline def value: CFuncPtr4[GLuint, GLuint, GLenum, Ptr[Byte], Unit] = v
      inline def toPtr: Ptr[?] = CFuncPtr.toPtr(v)

  opaque type PFNGLGETPERFMONITORCOUNTERSAMDPROC = CFuncPtr5[GLuint, Ptr[GLint], Ptr[GLint], GLsizei, Ptr[GLuint], Unit]
  object PFNGLGETPERFMONITORCOUNTERSAMDPROC:
    given _tag: Tag[PFNGLGETPERFMONITORCOUNTERSAMDPROC] = Tag.materializeCFuncPtr5[GLuint, Ptr[GLint], Ptr[GLint], GLsizei, Ptr[GLuint], Unit]
    inline def fromPtr(ptr: Ptr[Byte] | Ptr[?]): PFNGLGETPERFMONITORCOUNTERSAMDPROC = CFuncPtr.fromPtr(ptr.asInstanceOf[Ptr[Byte]])
    inline def apply(inline o: CFuncPtr5[GLuint, Ptr[GLint], Ptr[GLint], GLsizei, Ptr[GLuint], Unit]): PFNGLGETPERFMONITORCOUNTERSAMDPROC = o
    extension (v: PFNGLGETPERFMONITORCOUNTERSAMDPROC)
      inline def value: CFuncPtr5[GLuint, Ptr[GLint], Ptr[GLint], GLsizei, Ptr[GLuint], Unit] = v
      inline def toPtr: Ptr[?] = CFuncPtr.toPtr(v)

  opaque type PFNGLGETPERFMONITORCOUNTERSTRINGAMDPROC = CFuncPtr5[GLuint, GLuint, GLsizei, Ptr[GLsizei], Ptr[GLchar], Unit]
  object PFNGLGETPERFMONITORCOUNTERSTRINGAMDPROC:
    given _tag: Tag[PFNGLGETPERFMONITORCOUNTERSTRINGAMDPROC] = Tag.materializeCFuncPtr5[GLuint, GLuint, GLsizei, Ptr[GLsizei], Ptr[GLchar], Unit]
    inline def fromPtr(ptr: Ptr[Byte] | Ptr[?]): PFNGLGETPERFMONITORCOUNTERSTRINGAMDPROC = CFuncPtr.fromPtr(ptr.asInstanceOf[Ptr[Byte]])
    inline def apply(inline o: CFuncPtr5[GLuint, GLuint, GLsizei, Ptr[GLsizei], Ptr[GLchar], Unit]): PFNGLGETPERFMONITORCOUNTERSTRINGAMDPROC = o
    extension (v: PFNGLGETPERFMONITORCOUNTERSTRINGAMDPROC)
      inline def value: CFuncPtr5[GLuint, GLuint, GLsizei, Ptr[GLsizei], Ptr[GLchar], Unit] = v
      inline def toPtr: Ptr[?] = CFuncPtr.toPtr(v)

  opaque type PFNGLGETPERFMONITORGROUPSAMDPROC = CFuncPtr3[Ptr[GLint], GLsizei, Ptr[GLuint], Unit]
  object PFNGLGETPERFMONITORGROUPSAMDPROC:
    given _tag: Tag[PFNGLGETPERFMONITORGROUPSAMDPROC] = Tag.materializeCFuncPtr3[Ptr[GLint], GLsizei, Ptr[GLuint], Unit]
    inline def fromPtr(ptr: Ptr[Byte] | Ptr[?]): PFNGLGETPERFMONITORGROUPSAMDPROC = CFuncPtr.fromPtr(ptr.asInstanceOf[Ptr[Byte]])
    inline def apply(inline o: CFuncPtr3[Ptr[GLint], GLsizei, Ptr[GLuint], Unit]): PFNGLGETPERFMONITORGROUPSAMDPROC = o
    extension (v: PFNGLGETPERFMONITORGROUPSAMDPROC)
      inline def value: CFuncPtr3[Ptr[GLint], GLsizei, Ptr[GLuint], Unit] = v
      inline def toPtr: Ptr[?] = CFuncPtr.toPtr(v)

  opaque type PFNGLGETPERFMONITORGROUPSTRINGAMDPROC = CFuncPtr4[GLuint, GLsizei, Ptr[GLsizei], Ptr[GLchar], Unit]
  object PFNGLGETPERFMONITORGROUPSTRINGAMDPROC:
    given _tag: Tag[PFNGLGETPERFMONITORGROUPSTRINGAMDPROC] = Tag.materializeCFuncPtr4[GLuint, GLsizei, Ptr[GLsizei], Ptr[GLchar], Unit]
    inline def fromPtr(ptr: Ptr[Byte] | Ptr[?]): PFNGLGETPERFMONITORGROUPSTRINGAMDPROC = CFuncPtr.fromPtr(ptr.asInstanceOf[Ptr[Byte]])
    inline def apply(inline o: CFuncPtr4[GLuint, GLsizei, Ptr[GLsizei], Ptr[GLchar], Unit]): PFNGLGETPERFMONITORGROUPSTRINGAMDPROC = o
    extension (v: PFNGLGETPERFMONITORGROUPSTRINGAMDPROC)
      inline def value: CFuncPtr4[GLuint, GLsizei, Ptr[GLsizei], Ptr[GLchar], Unit] = v
      inline def toPtr: Ptr[?] = CFuncPtr.toPtr(v)

  opaque type PFNGLGETPERFQUERYDATAINTELPROC = CFuncPtr5[GLuint, GLuint, GLsizei, Ptr[Byte], Ptr[GLuint], Unit]
  object PFNGLGETPERFQUERYDATAINTELPROC:
    given _tag: Tag[PFNGLGETPERFQUERYDATAINTELPROC] = Tag.materializeCFuncPtr5[GLuint, GLuint, GLsizei, Ptr[Byte], Ptr[GLuint], Unit]
    inline def fromPtr(ptr: Ptr[Byte] | Ptr[?]): PFNGLGETPERFQUERYDATAINTELPROC = CFuncPtr.fromPtr(ptr.asInstanceOf[Ptr[Byte]])
    inline def apply(inline o: CFuncPtr5[GLuint, GLuint, GLsizei, Ptr[Byte], Ptr[GLuint], Unit]): PFNGLGETPERFQUERYDATAINTELPROC = o
    extension (v: PFNGLGETPERFQUERYDATAINTELPROC)
      inline def value: CFuncPtr5[GLuint, GLuint, GLsizei, Ptr[Byte], Ptr[GLuint], Unit] = v
      inline def toPtr: Ptr[?] = CFuncPtr.toPtr(v)

  opaque type PFNGLGETPERFQUERYIDBYNAMEINTELPROC = CFuncPtr2[Ptr[GLchar], Ptr[GLuint], Unit]
  object PFNGLGETPERFQUERYIDBYNAMEINTELPROC:
    given _tag: Tag[PFNGLGETPERFQUERYIDBYNAMEINTELPROC] = Tag.materializeCFuncPtr2[Ptr[GLchar], Ptr[GLuint], Unit]
    inline def fromPtr(ptr: Ptr[Byte] | Ptr[?]): PFNGLGETPERFQUERYIDBYNAMEINTELPROC = CFuncPtr.fromPtr(ptr.asInstanceOf[Ptr[Byte]])
    inline def apply(inline o: CFuncPtr2[Ptr[GLchar], Ptr[GLuint], Unit]): PFNGLGETPERFQUERYIDBYNAMEINTELPROC = o
    extension (v: PFNGLGETPERFQUERYIDBYNAMEINTELPROC)
      inline def value: CFuncPtr2[Ptr[GLchar], Ptr[GLuint], Unit] = v
      inline def toPtr: Ptr[?] = CFuncPtr.toPtr(v)

  opaque type PFNGLGETPERFQUERYINFOINTELPROC = CFuncPtr7[GLuint, GLuint, Ptr[GLchar], Ptr[GLuint], Ptr[GLuint], Ptr[GLuint], Ptr[GLuint], Unit]
  object PFNGLGETPERFQUERYINFOINTELPROC:
    given _tag: Tag[PFNGLGETPERFQUERYINFOINTELPROC] = Tag.materializeCFuncPtr7[GLuint, GLuint, Ptr[GLchar], Ptr[GLuint], Ptr[GLuint], Ptr[GLuint], Ptr[GLuint], Unit]
    inline def fromPtr(ptr: Ptr[Byte] | Ptr[?]): PFNGLGETPERFQUERYINFOINTELPROC = CFuncPtr.fromPtr(ptr.asInstanceOf[Ptr[Byte]])
    inline def apply(inline o: CFuncPtr7[GLuint, GLuint, Ptr[GLchar], Ptr[GLuint], Ptr[GLuint], Ptr[GLuint], Ptr[GLuint], Unit]): PFNGLGETPERFQUERYINFOINTELPROC = o
    extension (v: PFNGLGETPERFQUERYINFOINTELPROC)
      inline def value: CFuncPtr7[GLuint, GLuint, Ptr[GLchar], Ptr[GLuint], Ptr[GLuint], Ptr[GLuint], Ptr[GLuint], Unit] = v
      inline def toPtr: Ptr[?] = CFuncPtr.toPtr(v)

  opaque type PFNGLGETPIXELTRANSFORMPARAMETERFVEXTPROC = CFuncPtr3[GLenum, GLenum, Ptr[GLfloat], Unit]
  object PFNGLGETPIXELTRANSFORMPARAMETERFVEXTPROC:
    given _tag: Tag[PFNGLGETPIXELTRANSFORMPARAMETERFVEXTPROC] = Tag.materializeCFuncPtr3[GLenum, GLenum, Ptr[GLfloat], Unit]
    inline def fromPtr(ptr: Ptr[Byte] | Ptr[?]): PFNGLGETPIXELTRANSFORMPARAMETERFVEXTPROC = CFuncPtr.fromPtr(ptr.asInstanceOf[Ptr[Byte]])
    inline def apply(inline o: CFuncPtr3[GLenum, GLenum, Ptr[GLfloat], Unit]): PFNGLGETPIXELTRANSFORMPARAMETERFVEXTPROC = o
    extension (v: PFNGLGETPIXELTRANSFORMPARAMETERFVEXTPROC)
      inline def value: CFuncPtr3[GLenum, GLenum, Ptr[GLfloat], Unit] = v
      inline def toPtr: Ptr[?] = CFuncPtr.toPtr(v)

  opaque type PFNGLGETPIXELTRANSFORMPARAMETERFVSGIPROC = CFuncPtr3[GLenum, GLenum, Ptr[GLfloat], Unit]
  object PFNGLGETPIXELTRANSFORMPARAMETERFVSGIPROC:
    given _tag: Tag[PFNGLGETPIXELTRANSFORMPARAMETERFVSGIPROC] = Tag.materializeCFuncPtr3[GLenum, GLenum, Ptr[GLfloat], Unit]
    inline def fromPtr(ptr: Ptr[Byte] | Ptr[?]): PFNGLGETPIXELTRANSFORMPARAMETERFVSGIPROC = CFuncPtr.fromPtr(ptr.asInstanceOf[Ptr[Byte]])
    inline def apply(inline o: CFuncPtr3[GLenum, GLenum, Ptr[GLfloat], Unit]): PFNGLGETPIXELTRANSFORMPARAMETERFVSGIPROC = o
    extension (v: PFNGLGETPIXELTRANSFORMPARAMETERFVSGIPROC)
      inline def value: CFuncPtr3[GLenum, GLenum, Ptr[GLfloat], Unit] = v
      inline def toPtr: Ptr[?] = CFuncPtr.toPtr(v)

  opaque type PFNGLGETPIXELTRANSFORMPARAMETERIVEXTPROC = CFuncPtr3[GLenum, GLenum, Ptr[GLint], Unit]
  object PFNGLGETPIXELTRANSFORMPARAMETERIVEXTPROC:
    given _tag: Tag[PFNGLGETPIXELTRANSFORMPARAMETERIVEXTPROC] = Tag.materializeCFuncPtr3[GLenum, GLenum, Ptr[GLint], Unit]
    inline def fromPtr(ptr: Ptr[Byte] | Ptr[?]): PFNGLGETPIXELTRANSFORMPARAMETERIVEXTPROC = CFuncPtr.fromPtr(ptr.asInstanceOf[Ptr[Byte]])
    inline def apply(inline o: CFuncPtr3[GLenum, GLenum, Ptr[GLint], Unit]): PFNGLGETPIXELTRANSFORMPARAMETERIVEXTPROC = o
    extension (v: PFNGLGETPIXELTRANSFORMPARAMETERIVEXTPROC)
      inline def value: CFuncPtr3[GLenum, GLenum, Ptr[GLint], Unit] = v
      inline def toPtr: Ptr[?] = CFuncPtr.toPtr(v)

  opaque type PFNGLGETPIXELTRANSFORMPARAMETERIVSGIPROC = CFuncPtr3[GLenum, GLenum, Ptr[GLint], Unit]
  object PFNGLGETPIXELTRANSFORMPARAMETERIVSGIPROC:
    given _tag: Tag[PFNGLGETPIXELTRANSFORMPARAMETERIVSGIPROC] = Tag.materializeCFuncPtr3[GLenum, GLenum, Ptr[GLint], Unit]
    inline def fromPtr(ptr: Ptr[Byte] | Ptr[?]): PFNGLGETPIXELTRANSFORMPARAMETERIVSGIPROC = CFuncPtr.fromPtr(ptr.asInstanceOf[Ptr[Byte]])
    inline def apply(inline o: CFuncPtr3[GLenum, GLenum, Ptr[GLint], Unit]): PFNGLGETPIXELTRANSFORMPARAMETERIVSGIPROC = o
    extension (v: PFNGLGETPIXELTRANSFORMPARAMETERIVSGIPROC)
      inline def value: CFuncPtr3[GLenum, GLenum, Ptr[GLint], Unit] = v
      inline def toPtr: Ptr[?] = CFuncPtr.toPtr(v)

  opaque type PFNGLGETPOINTERINDEXEDVEXTPROC = CFuncPtr3[GLenum, GLuint, Ptr[Ptr[Byte]], Unit]
  object PFNGLGETPOINTERINDEXEDVEXTPROC:
    given _tag: Tag[PFNGLGETPOINTERINDEXEDVEXTPROC] = Tag.materializeCFuncPtr3[GLenum, GLuint, Ptr[Ptr[Byte]], Unit]
    inline def fromPtr(ptr: Ptr[Byte] | Ptr[?]): PFNGLGETPOINTERINDEXEDVEXTPROC = CFuncPtr.fromPtr(ptr.asInstanceOf[Ptr[Byte]])
    inline def apply(inline o: CFuncPtr3[GLenum, GLuint, Ptr[Ptr[Byte]], Unit]): PFNGLGETPOINTERINDEXEDVEXTPROC = o
    extension (v: PFNGLGETPOINTERINDEXEDVEXTPROC)
      inline def value: CFuncPtr3[GLenum, GLuint, Ptr[Ptr[Byte]], Unit] = v
      inline def toPtr: Ptr[?] = CFuncPtr.toPtr(v)

  opaque type PFNGLGETPOINTERI_VEXTPROC = CFuncPtr3[GLenum, GLuint, Ptr[Ptr[Byte]], Unit]
  object PFNGLGETPOINTERI_VEXTPROC:
    given _tag: Tag[PFNGLGETPOINTERI_VEXTPROC] = Tag.materializeCFuncPtr3[GLenum, GLuint, Ptr[Ptr[Byte]], Unit]
    inline def fromPtr(ptr: Ptr[Byte] | Ptr[?]): PFNGLGETPOINTERI_VEXTPROC = CFuncPtr.fromPtr(ptr.asInstanceOf[Ptr[Byte]])
    inline def apply(inline o: CFuncPtr3[GLenum, GLuint, Ptr[Ptr[Byte]], Unit]): PFNGLGETPOINTERI_VEXTPROC = o
    extension (v: PFNGLGETPOINTERI_VEXTPROC)
      inline def value: CFuncPtr3[GLenum, GLuint, Ptr[Ptr[Byte]], Unit] = v
      inline def toPtr: Ptr[?] = CFuncPtr.toPtr(v)

  opaque type PFNGLGETPROCADDRESSREGALPROC = CFuncPtr1[Ptr[GLchar], Ptr[Byte]]
  object PFNGLGETPROCADDRESSREGALPROC:
    given _tag: Tag[PFNGLGETPROCADDRESSREGALPROC] = Tag.materializeCFuncPtr1[Ptr[GLchar], Ptr[Byte]]
    inline def fromPtr(ptr: Ptr[Byte] | Ptr[?]): PFNGLGETPROCADDRESSREGALPROC = CFuncPtr.fromPtr(ptr.asInstanceOf[Ptr[Byte]])
    inline def apply(inline o: CFuncPtr1[Ptr[GLchar], Ptr[Byte]]): PFNGLGETPROCADDRESSREGALPROC = o
    extension (v: PFNGLGETPROCADDRESSREGALPROC)
      inline def value: CFuncPtr1[Ptr[GLchar], Ptr[Byte]] = v
      inline def toPtr: Ptr[?] = CFuncPtr.toPtr(v)

  opaque type PFNGLGETPROGRAMBINARYOESPROC = CFuncPtr5[GLuint, GLsizei, Ptr[GLsizei], Ptr[GLenum], Ptr[Byte], Unit]
  object PFNGLGETPROGRAMBINARYOESPROC:
    given _tag: Tag[PFNGLGETPROGRAMBINARYOESPROC] = Tag.materializeCFuncPtr5[GLuint, GLsizei, Ptr[GLsizei], Ptr[GLenum], Ptr[Byte], Unit]
    inline def fromPtr(ptr: Ptr[Byte] | Ptr[?]): PFNGLGETPROGRAMBINARYOESPROC = CFuncPtr.fromPtr(ptr.asInstanceOf[Ptr[Byte]])
    inline def apply(inline o: CFuncPtr5[GLuint, GLsizei, Ptr[GLsizei], Ptr[GLenum], Ptr[Byte], Unit]): PFNGLGETPROGRAMBINARYOESPROC = o
    extension (v: PFNGLGETPROGRAMBINARYOESPROC)
      inline def value: CFuncPtr5[GLuint, GLsizei, Ptr[GLsizei], Ptr[GLenum], Ptr[Byte], Unit] = v
      inline def toPtr: Ptr[?] = CFuncPtr.toPtr(v)

  opaque type PFNGLGETPROGRAMBINARYPROC = CFuncPtr5[GLuint, GLsizei, Ptr[GLsizei], Ptr[GLenum], Ptr[Byte], Unit]
  object PFNGLGETPROGRAMBINARYPROC:
    given _tag: Tag[PFNGLGETPROGRAMBINARYPROC] = Tag.materializeCFuncPtr5[GLuint, GLsizei, Ptr[GLsizei], Ptr[GLenum], Ptr[Byte], Unit]
    inline def fromPtr(ptr: Ptr[Byte] | Ptr[?]): PFNGLGETPROGRAMBINARYPROC = CFuncPtr.fromPtr(ptr.asInstanceOf[Ptr[Byte]])
    inline def apply(inline o: CFuncPtr5[GLuint, GLsizei, Ptr[GLsizei], Ptr[GLenum], Ptr[Byte], Unit]): PFNGLGETPROGRAMBINARYPROC = o
    extension (v: PFNGLGETPROGRAMBINARYPROC)
      inline def value: CFuncPtr5[GLuint, GLsizei, Ptr[GLsizei], Ptr[GLenum], Ptr[Byte], Unit] = v
      inline def toPtr: Ptr[?] = CFuncPtr.toPtr(v)

  opaque type PFNGLGETPROGRAMENVPARAMETERDVARBPROC = CFuncPtr3[GLenum, GLuint, Ptr[GLdouble], Unit]
  object PFNGLGETPROGRAMENVPARAMETERDVARBPROC:
    given _tag: Tag[PFNGLGETPROGRAMENVPARAMETERDVARBPROC] = Tag.materializeCFuncPtr3[GLenum, GLuint, Ptr[GLdouble], Unit]
    inline def fromPtr(ptr: Ptr[Byte] | Ptr[?]): PFNGLGETPROGRAMENVPARAMETERDVARBPROC = CFuncPtr.fromPtr(ptr.asInstanceOf[Ptr[Byte]])
    inline def apply(inline o: CFuncPtr3[GLenum, GLuint, Ptr[GLdouble], Unit]): PFNGLGETPROGRAMENVPARAMETERDVARBPROC = o
    extension (v: PFNGLGETPROGRAMENVPARAMETERDVARBPROC)
      inline def value: CFuncPtr3[GLenum, GLuint, Ptr[GLdouble], Unit] = v
      inline def toPtr: Ptr[?] = CFuncPtr.toPtr(v)

  opaque type PFNGLGETPROGRAMENVPARAMETERFVARBPROC = CFuncPtr3[GLenum, GLuint, Ptr[GLfloat], Unit]
  object PFNGLGETPROGRAMENVPARAMETERFVARBPROC:
    given _tag: Tag[PFNGLGETPROGRAMENVPARAMETERFVARBPROC] = Tag.materializeCFuncPtr3[GLenum, GLuint, Ptr[GLfloat], Unit]
    inline def fromPtr(ptr: Ptr[Byte] | Ptr[?]): PFNGLGETPROGRAMENVPARAMETERFVARBPROC = CFuncPtr.fromPtr(ptr.asInstanceOf[Ptr[Byte]])
    inline def apply(inline o: CFuncPtr3[GLenum, GLuint, Ptr[GLfloat], Unit]): PFNGLGETPROGRAMENVPARAMETERFVARBPROC = o
    extension (v: PFNGLGETPROGRAMENVPARAMETERFVARBPROC)
      inline def value: CFuncPtr3[GLenum, GLuint, Ptr[GLfloat], Unit] = v
      inline def toPtr: Ptr[?] = CFuncPtr.toPtr(v)

  opaque type PFNGLGETPROGRAMINFOLOGPROC = CFuncPtr4[GLuint, GLsizei, Ptr[GLsizei], Ptr[GLchar], Unit]
  object PFNGLGETPROGRAMINFOLOGPROC:
    given _tag: Tag[PFNGLGETPROGRAMINFOLOGPROC] = Tag.materializeCFuncPtr4[GLuint, GLsizei, Ptr[GLsizei], Ptr[GLchar], Unit]
    inline def fromPtr(ptr: Ptr[Byte] | Ptr[?]): PFNGLGETPROGRAMINFOLOGPROC = CFuncPtr.fromPtr(ptr.asInstanceOf[Ptr[Byte]])
    inline def apply(inline o: CFuncPtr4[GLuint, GLsizei, Ptr[GLsizei], Ptr[GLchar], Unit]): PFNGLGETPROGRAMINFOLOGPROC = o
    extension (v: PFNGLGETPROGRAMINFOLOGPROC)
      inline def value: CFuncPtr4[GLuint, GLsizei, Ptr[GLsizei], Ptr[GLchar], Unit] = v
      inline def toPtr: Ptr[?] = CFuncPtr.toPtr(v)

  opaque type PFNGLGETPROGRAMINTERFACEIVPROC = CFuncPtr4[GLuint, GLenum, GLenum, Ptr[GLint], Unit]
  object PFNGLGETPROGRAMINTERFACEIVPROC:
    given _tag: Tag[PFNGLGETPROGRAMINTERFACEIVPROC] = Tag.materializeCFuncPtr4[GLuint, GLenum, GLenum, Ptr[GLint], Unit]
    inline def fromPtr(ptr: Ptr[Byte] | Ptr[?]): PFNGLGETPROGRAMINTERFACEIVPROC = CFuncPtr.fromPtr(ptr.asInstanceOf[Ptr[Byte]])
    inline def apply(inline o: CFuncPtr4[GLuint, GLenum, GLenum, Ptr[GLint], Unit]): PFNGLGETPROGRAMINTERFACEIVPROC = o
    extension (v: PFNGLGETPROGRAMINTERFACEIVPROC)
      inline def value: CFuncPtr4[GLuint, GLenum, GLenum, Ptr[GLint], Unit] = v
      inline def toPtr: Ptr[?] = CFuncPtr.toPtr(v)

  opaque type PFNGLGETPROGRAMIVARBPROC = CFuncPtr3[GLenum, GLenum, Ptr[GLint], Unit]
  object PFNGLGETPROGRAMIVARBPROC:
    given _tag: Tag[PFNGLGETPROGRAMIVARBPROC] = Tag.materializeCFuncPtr3[GLenum, GLenum, Ptr[GLint], Unit]
    inline def fromPtr(ptr: Ptr[Byte] | Ptr[?]): PFNGLGETPROGRAMIVARBPROC = CFuncPtr.fromPtr(ptr.asInstanceOf[Ptr[Byte]])
    inline def apply(inline o: CFuncPtr3[GLenum, GLenum, Ptr[GLint], Unit]): PFNGLGETPROGRAMIVARBPROC = o
    extension (v: PFNGLGETPROGRAMIVARBPROC)
      inline def value: CFuncPtr3[GLenum, GLenum, Ptr[GLint], Unit] = v
      inline def toPtr: Ptr[?] = CFuncPtr.toPtr(v)

  opaque type PFNGLGETPROGRAMIVNVPROC = CFuncPtr3[GLuint, GLenum, Ptr[GLint], Unit]
  object PFNGLGETPROGRAMIVNVPROC:
    given _tag: Tag[PFNGLGETPROGRAMIVNVPROC] = Tag.materializeCFuncPtr3[GLuint, GLenum, Ptr[GLint], Unit]
    inline def fromPtr(ptr: Ptr[Byte] | Ptr[?]): PFNGLGETPROGRAMIVNVPROC = CFuncPtr.fromPtr(ptr.asInstanceOf[Ptr[Byte]])
    inline def apply(inline o: CFuncPtr3[GLuint, GLenum, Ptr[GLint], Unit]): PFNGLGETPROGRAMIVNVPROC = o
    extension (v: PFNGLGETPROGRAMIVNVPROC)
      inline def value: CFuncPtr3[GLuint, GLenum, Ptr[GLint], Unit] = v
      inline def toPtr: Ptr[?] = CFuncPtr.toPtr(v)

  opaque type PFNGLGETPROGRAMIVPROC = CFuncPtr3[GLuint, GLenum, Ptr[GLint], Unit]
  object PFNGLGETPROGRAMIVPROC:
    given _tag: Tag[PFNGLGETPROGRAMIVPROC] = Tag.materializeCFuncPtr3[GLuint, GLenum, Ptr[GLint], Unit]
    inline def fromPtr(ptr: Ptr[Byte] | Ptr[?]): PFNGLGETPROGRAMIVPROC = CFuncPtr.fromPtr(ptr.asInstanceOf[Ptr[Byte]])
    inline def apply(inline o: CFuncPtr3[GLuint, GLenum, Ptr[GLint], Unit]): PFNGLGETPROGRAMIVPROC = o
    extension (v: PFNGLGETPROGRAMIVPROC)
      inline def value: CFuncPtr3[GLuint, GLenum, Ptr[GLint], Unit] = v
      inline def toPtr: Ptr[?] = CFuncPtr.toPtr(v)

  opaque type PFNGLGETPROGRAMLOCALPARAMETERDVARBPROC = CFuncPtr3[GLenum, GLuint, Ptr[GLdouble], Unit]
  object PFNGLGETPROGRAMLOCALPARAMETERDVARBPROC:
    given _tag: Tag[PFNGLGETPROGRAMLOCALPARAMETERDVARBPROC] = Tag.materializeCFuncPtr3[GLenum, GLuint, Ptr[GLdouble], Unit]
    inline def fromPtr(ptr: Ptr[Byte] | Ptr[?]): PFNGLGETPROGRAMLOCALPARAMETERDVARBPROC = CFuncPtr.fromPtr(ptr.asInstanceOf[Ptr[Byte]])
    inline def apply(inline o: CFuncPtr3[GLenum, GLuint, Ptr[GLdouble], Unit]): PFNGLGETPROGRAMLOCALPARAMETERDVARBPROC = o
    extension (v: PFNGLGETPROGRAMLOCALPARAMETERDVARBPROC)
      inline def value: CFuncPtr3[GLenum, GLuint, Ptr[GLdouble], Unit] = v
      inline def toPtr: Ptr[?] = CFuncPtr.toPtr(v)

  opaque type PFNGLGETPROGRAMLOCALPARAMETERFVARBPROC = CFuncPtr3[GLenum, GLuint, Ptr[GLfloat], Unit]
  object PFNGLGETPROGRAMLOCALPARAMETERFVARBPROC:
    given _tag: Tag[PFNGLGETPROGRAMLOCALPARAMETERFVARBPROC] = Tag.materializeCFuncPtr3[GLenum, GLuint, Ptr[GLfloat], Unit]
    inline def fromPtr(ptr: Ptr[Byte] | Ptr[?]): PFNGLGETPROGRAMLOCALPARAMETERFVARBPROC = CFuncPtr.fromPtr(ptr.asInstanceOf[Ptr[Byte]])
    inline def apply(inline o: CFuncPtr3[GLenum, GLuint, Ptr[GLfloat], Unit]): PFNGLGETPROGRAMLOCALPARAMETERFVARBPROC = o
    extension (v: PFNGLGETPROGRAMLOCALPARAMETERFVARBPROC)
      inline def value: CFuncPtr3[GLenum, GLuint, Ptr[GLfloat], Unit] = v
      inline def toPtr: Ptr[?] = CFuncPtr.toPtr(v)

  opaque type PFNGLGETPROGRAMNAMEDPARAMETERDVNVPROC = CFuncPtr4[GLuint, GLsizei, Ptr[GLubyte], Ptr[GLdouble], Unit]
  object PFNGLGETPROGRAMNAMEDPARAMETERDVNVPROC:
    given _tag: Tag[PFNGLGETPROGRAMNAMEDPARAMETERDVNVPROC] = Tag.materializeCFuncPtr4[GLuint, GLsizei, Ptr[GLubyte], Ptr[GLdouble], Unit]
    inline def fromPtr(ptr: Ptr[Byte] | Ptr[?]): PFNGLGETPROGRAMNAMEDPARAMETERDVNVPROC = CFuncPtr.fromPtr(ptr.asInstanceOf[Ptr[Byte]])
    inline def apply(inline o: CFuncPtr4[GLuint, GLsizei, Ptr[GLubyte], Ptr[GLdouble], Unit]): PFNGLGETPROGRAMNAMEDPARAMETERDVNVPROC = o
    extension (v: PFNGLGETPROGRAMNAMEDPARAMETERDVNVPROC)
      inline def value: CFuncPtr4[GLuint, GLsizei, Ptr[GLubyte], Ptr[GLdouble], Unit] = v
      inline def toPtr: Ptr[?] = CFuncPtr.toPtr(v)

  opaque type PFNGLGETPROGRAMNAMEDPARAMETERFVNVPROC = CFuncPtr4[GLuint, GLsizei, Ptr[GLubyte], Ptr[GLfloat], Unit]
  object PFNGLGETPROGRAMNAMEDPARAMETERFVNVPROC:
    given _tag: Tag[PFNGLGETPROGRAMNAMEDPARAMETERFVNVPROC] = Tag.materializeCFuncPtr4[GLuint, GLsizei, Ptr[GLubyte], Ptr[GLfloat], Unit]
    inline def fromPtr(ptr: Ptr[Byte] | Ptr[?]): PFNGLGETPROGRAMNAMEDPARAMETERFVNVPROC = CFuncPtr.fromPtr(ptr.asInstanceOf[Ptr[Byte]])
    inline def apply(inline o: CFuncPtr4[GLuint, GLsizei, Ptr[GLubyte], Ptr[GLfloat], Unit]): PFNGLGETPROGRAMNAMEDPARAMETERFVNVPROC = o
    extension (v: PFNGLGETPROGRAMNAMEDPARAMETERFVNVPROC)
      inline def value: CFuncPtr4[GLuint, GLsizei, Ptr[GLubyte], Ptr[GLfloat], Unit] = v
      inline def toPtr: Ptr[?] = CFuncPtr.toPtr(v)

  opaque type PFNGLGETPROGRAMPARAMETERDVNVPROC = CFuncPtr4[GLenum, GLuint, GLenum, Ptr[GLdouble], Unit]
  object PFNGLGETPROGRAMPARAMETERDVNVPROC:
    given _tag: Tag[PFNGLGETPROGRAMPARAMETERDVNVPROC] = Tag.materializeCFuncPtr4[GLenum, GLuint, GLenum, Ptr[GLdouble], Unit]
    inline def fromPtr(ptr: Ptr[Byte] | Ptr[?]): PFNGLGETPROGRAMPARAMETERDVNVPROC = CFuncPtr.fromPtr(ptr.asInstanceOf[Ptr[Byte]])
    inline def apply(inline o: CFuncPtr4[GLenum, GLuint, GLenum, Ptr[GLdouble], Unit]): PFNGLGETPROGRAMPARAMETERDVNVPROC = o
    extension (v: PFNGLGETPROGRAMPARAMETERDVNVPROC)
      inline def value: CFuncPtr4[GLenum, GLuint, GLenum, Ptr[GLdouble], Unit] = v
      inline def toPtr: Ptr[?] = CFuncPtr.toPtr(v)

  opaque type PFNGLGETPROGRAMPARAMETERFVNVPROC = CFuncPtr4[GLenum, GLuint, GLenum, Ptr[GLfloat], Unit]
  object PFNGLGETPROGRAMPARAMETERFVNVPROC:
    given _tag: Tag[PFNGLGETPROGRAMPARAMETERFVNVPROC] = Tag.materializeCFuncPtr4[GLenum, GLuint, GLenum, Ptr[GLfloat], Unit]
    inline def fromPtr(ptr: Ptr[Byte] | Ptr[?]): PFNGLGETPROGRAMPARAMETERFVNVPROC = CFuncPtr.fromPtr(ptr.asInstanceOf[Ptr[Byte]])
    inline def apply(inline o: CFuncPtr4[GLenum, GLuint, GLenum, Ptr[GLfloat], Unit]): PFNGLGETPROGRAMPARAMETERFVNVPROC = o
    extension (v: PFNGLGETPROGRAMPARAMETERFVNVPROC)
      inline def value: CFuncPtr4[GLenum, GLuint, GLenum, Ptr[GLfloat], Unit] = v
      inline def toPtr: Ptr[?] = CFuncPtr.toPtr(v)

  opaque type PFNGLGETPROGRAMPIPELINEINFOLOGPROC = CFuncPtr4[GLuint, GLsizei, Ptr[GLsizei], Ptr[GLchar], Unit]
  object PFNGLGETPROGRAMPIPELINEINFOLOGPROC:
    given _tag: Tag[PFNGLGETPROGRAMPIPELINEINFOLOGPROC] = Tag.materializeCFuncPtr4[GLuint, GLsizei, Ptr[GLsizei], Ptr[GLchar], Unit]
    inline def fromPtr(ptr: Ptr[Byte] | Ptr[?]): PFNGLGETPROGRAMPIPELINEINFOLOGPROC = CFuncPtr.fromPtr(ptr.asInstanceOf[Ptr[Byte]])
    inline def apply(inline o: CFuncPtr4[GLuint, GLsizei, Ptr[GLsizei], Ptr[GLchar], Unit]): PFNGLGETPROGRAMPIPELINEINFOLOGPROC = o
    extension (v: PFNGLGETPROGRAMPIPELINEINFOLOGPROC)
      inline def value: CFuncPtr4[GLuint, GLsizei, Ptr[GLsizei], Ptr[GLchar], Unit] = v
      inline def toPtr: Ptr[?] = CFuncPtr.toPtr(v)

  opaque type PFNGLGETPROGRAMPIPELINEIVPROC = CFuncPtr3[GLuint, GLenum, Ptr[GLint], Unit]
  object PFNGLGETPROGRAMPIPELINEIVPROC:
    given _tag: Tag[PFNGLGETPROGRAMPIPELINEIVPROC] = Tag.materializeCFuncPtr3[GLuint, GLenum, Ptr[GLint], Unit]
    inline def fromPtr(ptr: Ptr[Byte] | Ptr[?]): PFNGLGETPROGRAMPIPELINEIVPROC = CFuncPtr.fromPtr(ptr.asInstanceOf[Ptr[Byte]])
    inline def apply(inline o: CFuncPtr3[GLuint, GLenum, Ptr[GLint], Unit]): PFNGLGETPROGRAMPIPELINEIVPROC = o
    extension (v: PFNGLGETPROGRAMPIPELINEIVPROC)
      inline def value: CFuncPtr3[GLuint, GLenum, Ptr[GLint], Unit] = v
      inline def toPtr: Ptr[?] = CFuncPtr.toPtr(v)

  opaque type PFNGLGETPROGRAMRESOURCEFVNVPROC = CFuncPtr8[GLuint, GLenum, GLuint, GLsizei, Ptr[GLenum], GLsizei, Ptr[GLsizei], Ptr[GLfloat], Unit]
  object PFNGLGETPROGRAMRESOURCEFVNVPROC:
    given _tag: Tag[PFNGLGETPROGRAMRESOURCEFVNVPROC] = Tag.materializeCFuncPtr8[GLuint, GLenum, GLuint, GLsizei, Ptr[GLenum], GLsizei, Ptr[GLsizei], Ptr[GLfloat], Unit]
    inline def fromPtr(ptr: Ptr[Byte] | Ptr[?]): PFNGLGETPROGRAMRESOURCEFVNVPROC = CFuncPtr.fromPtr(ptr.asInstanceOf[Ptr[Byte]])
    inline def apply(inline o: CFuncPtr8[GLuint, GLenum, GLuint, GLsizei, Ptr[GLenum], GLsizei, Ptr[GLsizei], Ptr[GLfloat], Unit]): PFNGLGETPROGRAMRESOURCEFVNVPROC = o
    extension (v: PFNGLGETPROGRAMRESOURCEFVNVPROC)
      inline def value: CFuncPtr8[GLuint, GLenum, GLuint, GLsizei, Ptr[GLenum], GLsizei, Ptr[GLsizei], Ptr[GLfloat], Unit] = v
      inline def toPtr: Ptr[?] = CFuncPtr.toPtr(v)

  opaque type PFNGLGETPROGRAMRESOURCEINDEXPROC = CFuncPtr3[GLuint, GLenum, Ptr[GLchar], GLuint]
  object PFNGLGETPROGRAMRESOURCEINDEXPROC:
    given _tag: Tag[PFNGLGETPROGRAMRESOURCEINDEXPROC] = Tag.materializeCFuncPtr3[GLuint, GLenum, Ptr[GLchar], GLuint]
    inline def fromPtr(ptr: Ptr[Byte] | Ptr[?]): PFNGLGETPROGRAMRESOURCEINDEXPROC = CFuncPtr.fromPtr(ptr.asInstanceOf[Ptr[Byte]])
    inline def apply(inline o: CFuncPtr3[GLuint, GLenum, Ptr[GLchar], GLuint]): PFNGLGETPROGRAMRESOURCEINDEXPROC = o
    extension (v: PFNGLGETPROGRAMRESOURCEINDEXPROC)
      inline def value: CFuncPtr3[GLuint, GLenum, Ptr[GLchar], GLuint] = v
      inline def toPtr: Ptr[?] = CFuncPtr.toPtr(v)

  opaque type PFNGLGETPROGRAMRESOURCEIVPROC = CFuncPtr8[GLuint, GLenum, GLuint, GLsizei, Ptr[GLenum], GLsizei, Ptr[GLsizei], Ptr[GLint], Unit]
  object PFNGLGETPROGRAMRESOURCEIVPROC:
    given _tag: Tag[PFNGLGETPROGRAMRESOURCEIVPROC] = Tag.materializeCFuncPtr8[GLuint, GLenum, GLuint, GLsizei, Ptr[GLenum], GLsizei, Ptr[GLsizei], Ptr[GLint], Unit]
    inline def fromPtr(ptr: Ptr[Byte] | Ptr[?]): PFNGLGETPROGRAMRESOURCEIVPROC = CFuncPtr.fromPtr(ptr.asInstanceOf[Ptr[Byte]])
    inline def apply(inline o: CFuncPtr8[GLuint, GLenum, GLuint, GLsizei, Ptr[GLenum], GLsizei, Ptr[GLsizei], Ptr[GLint], Unit]): PFNGLGETPROGRAMRESOURCEIVPROC = o
    extension (v: PFNGLGETPROGRAMRESOURCEIVPROC)
      inline def value: CFuncPtr8[GLuint, GLenum, GLuint, GLsizei, Ptr[GLenum], GLsizei, Ptr[GLsizei], Ptr[GLint], Unit] = v
      inline def toPtr: Ptr[?] = CFuncPtr.toPtr(v)

  opaque type PFNGLGETPROGRAMRESOURCELOCATIONINDEXEXTPROC = CFuncPtr3[GLuint, GLenum, Ptr[GLchar], GLint]
  object PFNGLGETPROGRAMRESOURCELOCATIONINDEXEXTPROC:
    given _tag: Tag[PFNGLGETPROGRAMRESOURCELOCATIONINDEXEXTPROC] = Tag.materializeCFuncPtr3[GLuint, GLenum, Ptr[GLchar], GLint]
    inline def fromPtr(ptr: Ptr[Byte] | Ptr[?]): PFNGLGETPROGRAMRESOURCELOCATIONINDEXEXTPROC = CFuncPtr.fromPtr(ptr.asInstanceOf[Ptr[Byte]])
    inline def apply(inline o: CFuncPtr3[GLuint, GLenum, Ptr[GLchar], GLint]): PFNGLGETPROGRAMRESOURCELOCATIONINDEXEXTPROC = o
    extension (v: PFNGLGETPROGRAMRESOURCELOCATIONINDEXEXTPROC)
      inline def value: CFuncPtr3[GLuint, GLenum, Ptr[GLchar], GLint] = v
      inline def toPtr: Ptr[?] = CFuncPtr.toPtr(v)

  opaque type PFNGLGETPROGRAMRESOURCELOCATIONINDEXPROC = CFuncPtr3[GLuint, GLenum, Ptr[GLchar], GLint]
  object PFNGLGETPROGRAMRESOURCELOCATIONINDEXPROC:
    given _tag: Tag[PFNGLGETPROGRAMRESOURCELOCATIONINDEXPROC] = Tag.materializeCFuncPtr3[GLuint, GLenum, Ptr[GLchar], GLint]
    inline def fromPtr(ptr: Ptr[Byte] | Ptr[?]): PFNGLGETPROGRAMRESOURCELOCATIONINDEXPROC = CFuncPtr.fromPtr(ptr.asInstanceOf[Ptr[Byte]])
    inline def apply(inline o: CFuncPtr3[GLuint, GLenum, Ptr[GLchar], GLint]): PFNGLGETPROGRAMRESOURCELOCATIONINDEXPROC = o
    extension (v: PFNGLGETPROGRAMRESOURCELOCATIONINDEXPROC)
      inline def value: CFuncPtr3[GLuint, GLenum, Ptr[GLchar], GLint] = v
      inline def toPtr: Ptr[?] = CFuncPtr.toPtr(v)

  opaque type PFNGLGETPROGRAMRESOURCELOCATIONPROC = CFuncPtr3[GLuint, GLenum, Ptr[GLchar], GLint]
  object PFNGLGETPROGRAMRESOURCELOCATIONPROC:
    given _tag: Tag[PFNGLGETPROGRAMRESOURCELOCATIONPROC] = Tag.materializeCFuncPtr3[GLuint, GLenum, Ptr[GLchar], GLint]
    inline def fromPtr(ptr: Ptr[Byte] | Ptr[?]): PFNGLGETPROGRAMRESOURCELOCATIONPROC = CFuncPtr.fromPtr(ptr.asInstanceOf[Ptr[Byte]])
    inline def apply(inline o: CFuncPtr3[GLuint, GLenum, Ptr[GLchar], GLint]): PFNGLGETPROGRAMRESOURCELOCATIONPROC = o
    extension (v: PFNGLGETPROGRAMRESOURCELOCATIONPROC)
      inline def value: CFuncPtr3[GLuint, GLenum, Ptr[GLchar], GLint] = v
      inline def toPtr: Ptr[?] = CFuncPtr.toPtr(v)

  opaque type PFNGLGETPROGRAMRESOURCENAMEPROC = CFuncPtr6[GLuint, GLenum, GLuint, GLsizei, Ptr[GLsizei], Ptr[GLchar], Unit]
  object PFNGLGETPROGRAMRESOURCENAMEPROC:
    given _tag: Tag[PFNGLGETPROGRAMRESOURCENAMEPROC] = Tag.materializeCFuncPtr6[GLuint, GLenum, GLuint, GLsizei, Ptr[GLsizei], Ptr[GLchar], Unit]
    inline def fromPtr(ptr: Ptr[Byte] | Ptr[?]): PFNGLGETPROGRAMRESOURCENAMEPROC = CFuncPtr.fromPtr(ptr.asInstanceOf[Ptr[Byte]])
    inline def apply(inline o: CFuncPtr6[GLuint, GLenum, GLuint, GLsizei, Ptr[GLsizei], Ptr[GLchar], Unit]): PFNGLGETPROGRAMRESOURCENAMEPROC = o
    extension (v: PFNGLGETPROGRAMRESOURCENAMEPROC)
      inline def value: CFuncPtr6[GLuint, GLenum, GLuint, GLsizei, Ptr[GLsizei], Ptr[GLchar], Unit] = v
      inline def toPtr: Ptr[?] = CFuncPtr.toPtr(v)

  opaque type PFNGLGETPROGRAMSTAGEIVPROC = CFuncPtr4[GLuint, GLenum, GLenum, Ptr[GLint], Unit]
  object PFNGLGETPROGRAMSTAGEIVPROC:
    given _tag: Tag[PFNGLGETPROGRAMSTAGEIVPROC] = Tag.materializeCFuncPtr4[GLuint, GLenum, GLenum, Ptr[GLint], Unit]
    inline def fromPtr(ptr: Ptr[Byte] | Ptr[?]): PFNGLGETPROGRAMSTAGEIVPROC = CFuncPtr.fromPtr(ptr.asInstanceOf[Ptr[Byte]])
    inline def apply(inline o: CFuncPtr4[GLuint, GLenum, GLenum, Ptr[GLint], Unit]): PFNGLGETPROGRAMSTAGEIVPROC = o
    extension (v: PFNGLGETPROGRAMSTAGEIVPROC)
      inline def value: CFuncPtr4[GLuint, GLenum, GLenum, Ptr[GLint], Unit] = v
      inline def toPtr: Ptr[?] = CFuncPtr.toPtr(v)

  opaque type PFNGLGETPROGRAMSTRINGARBPROC = CFuncPtr3[GLenum, GLenum, Ptr[Byte], Unit]
  object PFNGLGETPROGRAMSTRINGARBPROC:
    given _tag: Tag[PFNGLGETPROGRAMSTRINGARBPROC] = Tag.materializeCFuncPtr3[GLenum, GLenum, Ptr[Byte], Unit]
    inline def fromPtr(ptr: Ptr[Byte] | Ptr[?]): PFNGLGETPROGRAMSTRINGARBPROC = CFuncPtr.fromPtr(ptr.asInstanceOf[Ptr[Byte]])
    inline def apply(inline o: CFuncPtr3[GLenum, GLenum, Ptr[Byte], Unit]): PFNGLGETPROGRAMSTRINGARBPROC = o
    extension (v: PFNGLGETPROGRAMSTRINGARBPROC)
      inline def value: CFuncPtr3[GLenum, GLenum, Ptr[Byte], Unit] = v
      inline def toPtr: Ptr[?] = CFuncPtr.toPtr(v)

  opaque type PFNGLGETPROGRAMSTRINGNVPROC = CFuncPtr3[GLuint, GLenum, Ptr[GLubyte], Unit]
  object PFNGLGETPROGRAMSTRINGNVPROC:
    given _tag: Tag[PFNGLGETPROGRAMSTRINGNVPROC] = Tag.materializeCFuncPtr3[GLuint, GLenum, Ptr[GLubyte], Unit]
    inline def fromPtr(ptr: Ptr[Byte] | Ptr[?]): PFNGLGETPROGRAMSTRINGNVPROC = CFuncPtr.fromPtr(ptr.asInstanceOf[Ptr[Byte]])
    inline def apply(inline o: CFuncPtr3[GLuint, GLenum, Ptr[GLubyte], Unit]): PFNGLGETPROGRAMSTRINGNVPROC = o
    extension (v: PFNGLGETPROGRAMSTRINGNVPROC)
      inline def value: CFuncPtr3[GLuint, GLenum, Ptr[GLubyte], Unit] = v
      inline def toPtr: Ptr[?] = CFuncPtr.toPtr(v)

  opaque type PFNGLGETQUERYBUFFEROBJECTI64VPROC = CFuncPtr4[GLuint, GLuint, GLenum, GLintptr, Unit]
  object PFNGLGETQUERYBUFFEROBJECTI64VPROC:
    given _tag: Tag[PFNGLGETQUERYBUFFEROBJECTI64VPROC] = Tag.materializeCFuncPtr4[GLuint, GLuint, GLenum, GLintptr, Unit]
    inline def fromPtr(ptr: Ptr[Byte] | Ptr[?]): PFNGLGETQUERYBUFFEROBJECTI64VPROC = CFuncPtr.fromPtr(ptr.asInstanceOf[Ptr[Byte]])
    inline def apply(inline o: CFuncPtr4[GLuint, GLuint, GLenum, GLintptr, Unit]): PFNGLGETQUERYBUFFEROBJECTI64VPROC = o
    extension (v: PFNGLGETQUERYBUFFEROBJECTI64VPROC)
      inline def value: CFuncPtr4[GLuint, GLuint, GLenum, GLintptr, Unit] = v
      inline def toPtr: Ptr[?] = CFuncPtr.toPtr(v)

  opaque type PFNGLGETQUERYBUFFEROBJECTIVPROC = CFuncPtr4[GLuint, GLuint, GLenum, GLintptr, Unit]
  object PFNGLGETQUERYBUFFEROBJECTIVPROC:
    given _tag: Tag[PFNGLGETQUERYBUFFEROBJECTIVPROC] = Tag.materializeCFuncPtr4[GLuint, GLuint, GLenum, GLintptr, Unit]
    inline def fromPtr(ptr: Ptr[Byte] | Ptr[?]): PFNGLGETQUERYBUFFEROBJECTIVPROC = CFuncPtr.fromPtr(ptr.asInstanceOf[Ptr[Byte]])
    inline def apply(inline o: CFuncPtr4[GLuint, GLuint, GLenum, GLintptr, Unit]): PFNGLGETQUERYBUFFEROBJECTIVPROC = o
    extension (v: PFNGLGETQUERYBUFFEROBJECTIVPROC)
      inline def value: CFuncPtr4[GLuint, GLuint, GLenum, GLintptr, Unit] = v
      inline def toPtr: Ptr[?] = CFuncPtr.toPtr(v)

  opaque type PFNGLGETQUERYBUFFEROBJECTUI64VPROC = CFuncPtr4[GLuint, GLuint, GLenum, GLintptr, Unit]
  object PFNGLGETQUERYBUFFEROBJECTUI64VPROC:
    given _tag: Tag[PFNGLGETQUERYBUFFEROBJECTUI64VPROC] = Tag.materializeCFuncPtr4[GLuint, GLuint, GLenum, GLintptr, Unit]
    inline def fromPtr(ptr: Ptr[Byte] | Ptr[?]): PFNGLGETQUERYBUFFEROBJECTUI64VPROC = CFuncPtr.fromPtr(ptr.asInstanceOf[Ptr[Byte]])
    inline def apply(inline o: CFuncPtr4[GLuint, GLuint, GLenum, GLintptr, Unit]): PFNGLGETQUERYBUFFEROBJECTUI64VPROC = o
    extension (v: PFNGLGETQUERYBUFFEROBJECTUI64VPROC)
      inline def value: CFuncPtr4[GLuint, GLuint, GLenum, GLintptr, Unit] = v
      inline def toPtr: Ptr[?] = CFuncPtr.toPtr(v)

  opaque type PFNGLGETQUERYBUFFEROBJECTUIVPROC = CFuncPtr4[GLuint, GLuint, GLenum, GLintptr, Unit]
  object PFNGLGETQUERYBUFFEROBJECTUIVPROC:
    given _tag: Tag[PFNGLGETQUERYBUFFEROBJECTUIVPROC] = Tag.materializeCFuncPtr4[GLuint, GLuint, GLenum, GLintptr, Unit]
    inline def fromPtr(ptr: Ptr[Byte] | Ptr[?]): PFNGLGETQUERYBUFFEROBJECTUIVPROC = CFuncPtr.fromPtr(ptr.asInstanceOf[Ptr[Byte]])
    inline def apply(inline o: CFuncPtr4[GLuint, GLuint, GLenum, GLintptr, Unit]): PFNGLGETQUERYBUFFEROBJECTUIVPROC = o
    extension (v: PFNGLGETQUERYBUFFEROBJECTUIVPROC)
      inline def value: CFuncPtr4[GLuint, GLuint, GLenum, GLintptr, Unit] = v
      inline def toPtr: Ptr[?] = CFuncPtr.toPtr(v)

  opaque type PFNGLGETQUERYINDEXEDIVPROC = CFuncPtr4[GLenum, GLuint, GLenum, Ptr[GLint], Unit]
  object PFNGLGETQUERYINDEXEDIVPROC:
    given _tag: Tag[PFNGLGETQUERYINDEXEDIVPROC] = Tag.materializeCFuncPtr4[GLenum, GLuint, GLenum, Ptr[GLint], Unit]
    inline def fromPtr(ptr: Ptr[Byte] | Ptr[?]): PFNGLGETQUERYINDEXEDIVPROC = CFuncPtr.fromPtr(ptr.asInstanceOf[Ptr[Byte]])
    inline def apply(inline o: CFuncPtr4[GLenum, GLuint, GLenum, Ptr[GLint], Unit]): PFNGLGETQUERYINDEXEDIVPROC = o
    extension (v: PFNGLGETQUERYINDEXEDIVPROC)
      inline def value: CFuncPtr4[GLenum, GLuint, GLenum, Ptr[GLint], Unit] = v
      inline def toPtr: Ptr[?] = CFuncPtr.toPtr(v)

  opaque type PFNGLGETQUERYIVANGLEPROC = CFuncPtr3[GLenum, GLenum, Ptr[GLint], Unit]
  object PFNGLGETQUERYIVANGLEPROC:
    given _tag: Tag[PFNGLGETQUERYIVANGLEPROC] = Tag.materializeCFuncPtr3[GLenum, GLenum, Ptr[GLint], Unit]
    inline def fromPtr(ptr: Ptr[Byte] | Ptr[?]): PFNGLGETQUERYIVANGLEPROC = CFuncPtr.fromPtr(ptr.asInstanceOf[Ptr[Byte]])
    inline def apply(inline o: CFuncPtr3[GLenum, GLenum, Ptr[GLint], Unit]): PFNGLGETQUERYIVANGLEPROC = o
    extension (v: PFNGLGETQUERYIVANGLEPROC)
      inline def value: CFuncPtr3[GLenum, GLenum, Ptr[GLint], Unit] = v
      inline def toPtr: Ptr[?] = CFuncPtr.toPtr(v)

  opaque type PFNGLGETQUERYIVARBPROC = CFuncPtr3[GLenum, GLenum, Ptr[GLint], Unit]
  object PFNGLGETQUERYIVARBPROC:
    given _tag: Tag[PFNGLGETQUERYIVARBPROC] = Tag.materializeCFuncPtr3[GLenum, GLenum, Ptr[GLint], Unit]
    inline def fromPtr(ptr: Ptr[Byte] | Ptr[?]): PFNGLGETQUERYIVARBPROC = CFuncPtr.fromPtr(ptr.asInstanceOf[Ptr[Byte]])
    inline def apply(inline o: CFuncPtr3[GLenum, GLenum, Ptr[GLint], Unit]): PFNGLGETQUERYIVARBPROC = o
    extension (v: PFNGLGETQUERYIVARBPROC)
      inline def value: CFuncPtr3[GLenum, GLenum, Ptr[GLint], Unit] = v
      inline def toPtr: Ptr[?] = CFuncPtr.toPtr(v)

  opaque type PFNGLGETQUERYIVEXTPROC = CFuncPtr3[GLenum, GLenum, Ptr[GLint], Unit]
  object PFNGLGETQUERYIVEXTPROC:
    given _tag: Tag[PFNGLGETQUERYIVEXTPROC] = Tag.materializeCFuncPtr3[GLenum, GLenum, Ptr[GLint], Unit]
    inline def fromPtr(ptr: Ptr[Byte] | Ptr[?]): PFNGLGETQUERYIVEXTPROC = CFuncPtr.fromPtr(ptr.asInstanceOf[Ptr[Byte]])
    inline def apply(inline o: CFuncPtr3[GLenum, GLenum, Ptr[GLint], Unit]): PFNGLGETQUERYIVEXTPROC = o
    extension (v: PFNGLGETQUERYIVEXTPROC)
      inline def value: CFuncPtr3[GLenum, GLenum, Ptr[GLint], Unit] = v
      inline def toPtr: Ptr[?] = CFuncPtr.toPtr(v)

  opaque type PFNGLGETQUERYIVPROC = CFuncPtr3[GLenum, GLenum, Ptr[GLint], Unit]
  object PFNGLGETQUERYIVPROC:
    given _tag: Tag[PFNGLGETQUERYIVPROC] = Tag.materializeCFuncPtr3[GLenum, GLenum, Ptr[GLint], Unit]
    inline def fromPtr(ptr: Ptr[Byte] | Ptr[?]): PFNGLGETQUERYIVPROC = CFuncPtr.fromPtr(ptr.asInstanceOf[Ptr[Byte]])
    inline def apply(inline o: CFuncPtr3[GLenum, GLenum, Ptr[GLint], Unit]): PFNGLGETQUERYIVPROC = o
    extension (v: PFNGLGETQUERYIVPROC)
      inline def value: CFuncPtr3[GLenum, GLenum, Ptr[GLint], Unit] = v
      inline def toPtr: Ptr[?] = CFuncPtr.toPtr(v)

  opaque type PFNGLGETQUERYOBJECTI64VANGLEPROC = CFuncPtr3[GLuint, GLenum, Ptr[GLint64], Unit]
  object PFNGLGETQUERYOBJECTI64VANGLEPROC:
    given _tag: Tag[PFNGLGETQUERYOBJECTI64VANGLEPROC] = Tag.materializeCFuncPtr3[GLuint, GLenum, Ptr[GLint64], Unit]
    inline def fromPtr(ptr: Ptr[Byte] | Ptr[?]): PFNGLGETQUERYOBJECTI64VANGLEPROC = CFuncPtr.fromPtr(ptr.asInstanceOf[Ptr[Byte]])
    inline def apply(inline o: CFuncPtr3[GLuint, GLenum, Ptr[GLint64], Unit]): PFNGLGETQUERYOBJECTI64VANGLEPROC = o
    extension (v: PFNGLGETQUERYOBJECTI64VANGLEPROC)
      inline def value: CFuncPtr3[GLuint, GLenum, Ptr[GLint64], Unit] = v
      inline def toPtr: Ptr[?] = CFuncPtr.toPtr(v)

  opaque type PFNGLGETQUERYOBJECTI64VEXTPROC = CFuncPtr3[GLuint, GLenum, Ptr[GLint64EXT], Unit]
  object PFNGLGETQUERYOBJECTI64VEXTPROC:
    given _tag: Tag[PFNGLGETQUERYOBJECTI64VEXTPROC] = Tag.materializeCFuncPtr3[GLuint, GLenum, Ptr[GLint64EXT], Unit]
    inline def fromPtr(ptr: Ptr[Byte] | Ptr[?]): PFNGLGETQUERYOBJECTI64VEXTPROC = CFuncPtr.fromPtr(ptr.asInstanceOf[Ptr[Byte]])
    inline def apply(inline o: CFuncPtr3[GLuint, GLenum, Ptr[GLint64EXT], Unit]): PFNGLGETQUERYOBJECTI64VEXTPROC = o
    extension (v: PFNGLGETQUERYOBJECTI64VEXTPROC)
      inline def value: CFuncPtr3[GLuint, GLenum, Ptr[GLint64EXT], Unit] = v
      inline def toPtr: Ptr[?] = CFuncPtr.toPtr(v)

  opaque type PFNGLGETQUERYOBJECTI64VPROC = CFuncPtr3[GLuint, GLenum, Ptr[GLint64], Unit]
  object PFNGLGETQUERYOBJECTI64VPROC:
    given _tag: Tag[PFNGLGETQUERYOBJECTI64VPROC] = Tag.materializeCFuncPtr3[GLuint, GLenum, Ptr[GLint64], Unit]
    inline def fromPtr(ptr: Ptr[Byte] | Ptr[?]): PFNGLGETQUERYOBJECTI64VPROC = CFuncPtr.fromPtr(ptr.asInstanceOf[Ptr[Byte]])
    inline def apply(inline o: CFuncPtr3[GLuint, GLenum, Ptr[GLint64], Unit]): PFNGLGETQUERYOBJECTI64VPROC = o
    extension (v: PFNGLGETQUERYOBJECTI64VPROC)
      inline def value: CFuncPtr3[GLuint, GLenum, Ptr[GLint64], Unit] = v
      inline def toPtr: Ptr[?] = CFuncPtr.toPtr(v)

  opaque type PFNGLGETQUERYOBJECTIVANGLEPROC = CFuncPtr3[GLuint, GLenum, Ptr[GLint], Unit]
  object PFNGLGETQUERYOBJECTIVANGLEPROC:
    given _tag: Tag[PFNGLGETQUERYOBJECTIVANGLEPROC] = Tag.materializeCFuncPtr3[GLuint, GLenum, Ptr[GLint], Unit]
    inline def fromPtr(ptr: Ptr[Byte] | Ptr[?]): PFNGLGETQUERYOBJECTIVANGLEPROC = CFuncPtr.fromPtr(ptr.asInstanceOf[Ptr[Byte]])
    inline def apply(inline o: CFuncPtr3[GLuint, GLenum, Ptr[GLint], Unit]): PFNGLGETQUERYOBJECTIVANGLEPROC = o
    extension (v: PFNGLGETQUERYOBJECTIVANGLEPROC)
      inline def value: CFuncPtr3[GLuint, GLenum, Ptr[GLint], Unit] = v
      inline def toPtr: Ptr[?] = CFuncPtr.toPtr(v)

  opaque type PFNGLGETQUERYOBJECTIVARBPROC = CFuncPtr3[GLuint, GLenum, Ptr[GLint], Unit]
  object PFNGLGETQUERYOBJECTIVARBPROC:
    given _tag: Tag[PFNGLGETQUERYOBJECTIVARBPROC] = Tag.materializeCFuncPtr3[GLuint, GLenum, Ptr[GLint], Unit]
    inline def fromPtr(ptr: Ptr[Byte] | Ptr[?]): PFNGLGETQUERYOBJECTIVARBPROC = CFuncPtr.fromPtr(ptr.asInstanceOf[Ptr[Byte]])
    inline def apply(inline o: CFuncPtr3[GLuint, GLenum, Ptr[GLint], Unit]): PFNGLGETQUERYOBJECTIVARBPROC = o
    extension (v: PFNGLGETQUERYOBJECTIVARBPROC)
      inline def value: CFuncPtr3[GLuint, GLenum, Ptr[GLint], Unit] = v
      inline def toPtr: Ptr[?] = CFuncPtr.toPtr(v)

  opaque type PFNGLGETQUERYOBJECTIVEXTPROC = CFuncPtr3[GLuint, GLenum, Ptr[GLint], Unit]
  object PFNGLGETQUERYOBJECTIVEXTPROC:
    given _tag: Tag[PFNGLGETQUERYOBJECTIVEXTPROC] = Tag.materializeCFuncPtr3[GLuint, GLenum, Ptr[GLint], Unit]
    inline def fromPtr(ptr: Ptr[Byte] | Ptr[?]): PFNGLGETQUERYOBJECTIVEXTPROC = CFuncPtr.fromPtr(ptr.asInstanceOf[Ptr[Byte]])
    inline def apply(inline o: CFuncPtr3[GLuint, GLenum, Ptr[GLint], Unit]): PFNGLGETQUERYOBJECTIVEXTPROC = o
    extension (v: PFNGLGETQUERYOBJECTIVEXTPROC)
      inline def value: CFuncPtr3[GLuint, GLenum, Ptr[GLint], Unit] = v
      inline def toPtr: Ptr[?] = CFuncPtr.toPtr(v)

  opaque type PFNGLGETQUERYOBJECTIVPROC = CFuncPtr3[GLuint, GLenum, Ptr[GLint], Unit]
  object PFNGLGETQUERYOBJECTIVPROC:
    given _tag: Tag[PFNGLGETQUERYOBJECTIVPROC] = Tag.materializeCFuncPtr3[GLuint, GLenum, Ptr[GLint], Unit]
    inline def fromPtr(ptr: Ptr[Byte] | Ptr[?]): PFNGLGETQUERYOBJECTIVPROC = CFuncPtr.fromPtr(ptr.asInstanceOf[Ptr[Byte]])
    inline def apply(inline o: CFuncPtr3[GLuint, GLenum, Ptr[GLint], Unit]): PFNGLGETQUERYOBJECTIVPROC = o
    extension (v: PFNGLGETQUERYOBJECTIVPROC)
      inline def value: CFuncPtr3[GLuint, GLenum, Ptr[GLint], Unit] = v
      inline def toPtr: Ptr[?] = CFuncPtr.toPtr(v)

  opaque type PFNGLGETQUERYOBJECTUI64VANGLEPROC = CFuncPtr3[GLuint, GLenum, Ptr[GLuint64], Unit]
  object PFNGLGETQUERYOBJECTUI64VANGLEPROC:
    given _tag: Tag[PFNGLGETQUERYOBJECTUI64VANGLEPROC] = Tag.materializeCFuncPtr3[GLuint, GLenum, Ptr[GLuint64], Unit]
    inline def fromPtr(ptr: Ptr[Byte] | Ptr[?]): PFNGLGETQUERYOBJECTUI64VANGLEPROC = CFuncPtr.fromPtr(ptr.asInstanceOf[Ptr[Byte]])
    inline def apply(inline o: CFuncPtr3[GLuint, GLenum, Ptr[GLuint64], Unit]): PFNGLGETQUERYOBJECTUI64VANGLEPROC = o
    extension (v: PFNGLGETQUERYOBJECTUI64VANGLEPROC)
      inline def value: CFuncPtr3[GLuint, GLenum, Ptr[GLuint64], Unit] = v
      inline def toPtr: Ptr[?] = CFuncPtr.toPtr(v)

  opaque type PFNGLGETQUERYOBJECTUI64VEXTPROC = CFuncPtr3[GLuint, GLenum, Ptr[GLuint64EXT], Unit]
  object PFNGLGETQUERYOBJECTUI64VEXTPROC:
    given _tag: Tag[PFNGLGETQUERYOBJECTUI64VEXTPROC] = Tag.materializeCFuncPtr3[GLuint, GLenum, Ptr[GLuint64EXT], Unit]
    inline def fromPtr(ptr: Ptr[Byte] | Ptr[?]): PFNGLGETQUERYOBJECTUI64VEXTPROC = CFuncPtr.fromPtr(ptr.asInstanceOf[Ptr[Byte]])
    inline def apply(inline o: CFuncPtr3[GLuint, GLenum, Ptr[GLuint64EXT], Unit]): PFNGLGETQUERYOBJECTUI64VEXTPROC = o
    extension (v: PFNGLGETQUERYOBJECTUI64VEXTPROC)
      inline def value: CFuncPtr3[GLuint, GLenum, Ptr[GLuint64EXT], Unit] = v
      inline def toPtr: Ptr[?] = CFuncPtr.toPtr(v)

  opaque type PFNGLGETQUERYOBJECTUI64VPROC = CFuncPtr3[GLuint, GLenum, Ptr[GLuint64], Unit]
  object PFNGLGETQUERYOBJECTUI64VPROC:
    given _tag: Tag[PFNGLGETQUERYOBJECTUI64VPROC] = Tag.materializeCFuncPtr3[GLuint, GLenum, Ptr[GLuint64], Unit]
    inline def fromPtr(ptr: Ptr[Byte] | Ptr[?]): PFNGLGETQUERYOBJECTUI64VPROC = CFuncPtr.fromPtr(ptr.asInstanceOf[Ptr[Byte]])
    inline def apply(inline o: CFuncPtr3[GLuint, GLenum, Ptr[GLuint64], Unit]): PFNGLGETQUERYOBJECTUI64VPROC = o
    extension (v: PFNGLGETQUERYOBJECTUI64VPROC)
      inline def value: CFuncPtr3[GLuint, GLenum, Ptr[GLuint64], Unit] = v
      inline def toPtr: Ptr[?] = CFuncPtr.toPtr(v)

  opaque type PFNGLGETQUERYOBJECTUIVANGLEPROC = CFuncPtr3[GLuint, GLenum, Ptr[GLuint], Unit]
  object PFNGLGETQUERYOBJECTUIVANGLEPROC:
    given _tag: Tag[PFNGLGETQUERYOBJECTUIVANGLEPROC] = Tag.materializeCFuncPtr3[GLuint, GLenum, Ptr[GLuint], Unit]
    inline def fromPtr(ptr: Ptr[Byte] | Ptr[?]): PFNGLGETQUERYOBJECTUIVANGLEPROC = CFuncPtr.fromPtr(ptr.asInstanceOf[Ptr[Byte]])
    inline def apply(inline o: CFuncPtr3[GLuint, GLenum, Ptr[GLuint], Unit]): PFNGLGETQUERYOBJECTUIVANGLEPROC = o
    extension (v: PFNGLGETQUERYOBJECTUIVANGLEPROC)
      inline def value: CFuncPtr3[GLuint, GLenum, Ptr[GLuint], Unit] = v
      inline def toPtr: Ptr[?] = CFuncPtr.toPtr(v)

  opaque type PFNGLGETQUERYOBJECTUIVARBPROC = CFuncPtr3[GLuint, GLenum, Ptr[GLuint], Unit]
  object PFNGLGETQUERYOBJECTUIVARBPROC:
    given _tag: Tag[PFNGLGETQUERYOBJECTUIVARBPROC] = Tag.materializeCFuncPtr3[GLuint, GLenum, Ptr[GLuint], Unit]
    inline def fromPtr(ptr: Ptr[Byte] | Ptr[?]): PFNGLGETQUERYOBJECTUIVARBPROC = CFuncPtr.fromPtr(ptr.asInstanceOf[Ptr[Byte]])
    inline def apply(inline o: CFuncPtr3[GLuint, GLenum, Ptr[GLuint], Unit]): PFNGLGETQUERYOBJECTUIVARBPROC = o
    extension (v: PFNGLGETQUERYOBJECTUIVARBPROC)
      inline def value: CFuncPtr3[GLuint, GLenum, Ptr[GLuint], Unit] = v
      inline def toPtr: Ptr[?] = CFuncPtr.toPtr(v)

  opaque type PFNGLGETQUERYOBJECTUIVEXTPROC = CFuncPtr3[GLuint, GLenum, Ptr[GLuint], Unit]
  object PFNGLGETQUERYOBJECTUIVEXTPROC:
    given _tag: Tag[PFNGLGETQUERYOBJECTUIVEXTPROC] = Tag.materializeCFuncPtr3[GLuint, GLenum, Ptr[GLuint], Unit]
    inline def fromPtr(ptr: Ptr[Byte] | Ptr[?]): PFNGLGETQUERYOBJECTUIVEXTPROC = CFuncPtr.fromPtr(ptr.asInstanceOf[Ptr[Byte]])
    inline def apply(inline o: CFuncPtr3[GLuint, GLenum, Ptr[GLuint], Unit]): PFNGLGETQUERYOBJECTUIVEXTPROC = o
    extension (v: PFNGLGETQUERYOBJECTUIVEXTPROC)
      inline def value: CFuncPtr3[GLuint, GLenum, Ptr[GLuint], Unit] = v
      inline def toPtr: Ptr[?] = CFuncPtr.toPtr(v)

  opaque type PFNGLGETQUERYOBJECTUIVPROC = CFuncPtr3[GLuint, GLenum, Ptr[GLuint], Unit]
  object PFNGLGETQUERYOBJECTUIVPROC:
    given _tag: Tag[PFNGLGETQUERYOBJECTUIVPROC] = Tag.materializeCFuncPtr3[GLuint, GLenum, Ptr[GLuint], Unit]
    inline def fromPtr(ptr: Ptr[Byte] | Ptr[?]): PFNGLGETQUERYOBJECTUIVPROC = CFuncPtr.fromPtr(ptr.asInstanceOf[Ptr[Byte]])
    inline def apply(inline o: CFuncPtr3[GLuint, GLenum, Ptr[GLuint], Unit]): PFNGLGETQUERYOBJECTUIVPROC = o
    extension (v: PFNGLGETQUERYOBJECTUIVPROC)
      inline def value: CFuncPtr3[GLuint, GLenum, Ptr[GLuint], Unit] = v
      inline def toPtr: Ptr[?] = CFuncPtr.toPtr(v)

  opaque type PFNGLGETRENDERBUFFERPARAMETERIVEXTPROC = CFuncPtr3[GLenum, GLenum, Ptr[GLint], Unit]
  object PFNGLGETRENDERBUFFERPARAMETERIVEXTPROC:
    given _tag: Tag[PFNGLGETRENDERBUFFERPARAMETERIVEXTPROC] = Tag.materializeCFuncPtr3[GLenum, GLenum, Ptr[GLint], Unit]
    inline def fromPtr(ptr: Ptr[Byte] | Ptr[?]): PFNGLGETRENDERBUFFERPARAMETERIVEXTPROC = CFuncPtr.fromPtr(ptr.asInstanceOf[Ptr[Byte]])
    inline def apply(inline o: CFuncPtr3[GLenum, GLenum, Ptr[GLint], Unit]): PFNGLGETRENDERBUFFERPARAMETERIVEXTPROC = o
    extension (v: PFNGLGETRENDERBUFFERPARAMETERIVEXTPROC)
      inline def value: CFuncPtr3[GLenum, GLenum, Ptr[GLint], Unit] = v
      inline def toPtr: Ptr[?] = CFuncPtr.toPtr(v)

  opaque type PFNGLGETRENDERBUFFERPARAMETERIVOESPROC = CFuncPtr3[GLenum, GLenum, Ptr[GLint], Unit]
  object PFNGLGETRENDERBUFFERPARAMETERIVOESPROC:
    given _tag: Tag[PFNGLGETRENDERBUFFERPARAMETERIVOESPROC] = Tag.materializeCFuncPtr3[GLenum, GLenum, Ptr[GLint], Unit]
    inline def fromPtr(ptr: Ptr[Byte] | Ptr[?]): PFNGLGETRENDERBUFFERPARAMETERIVOESPROC = CFuncPtr.fromPtr(ptr.asInstanceOf[Ptr[Byte]])
    inline def apply(inline o: CFuncPtr3[GLenum, GLenum, Ptr[GLint], Unit]): PFNGLGETRENDERBUFFERPARAMETERIVOESPROC = o
    extension (v: PFNGLGETRENDERBUFFERPARAMETERIVOESPROC)
      inline def value: CFuncPtr3[GLenum, GLenum, Ptr[GLint], Unit] = v
      inline def toPtr: Ptr[?] = CFuncPtr.toPtr(v)

  opaque type PFNGLGETRENDERBUFFERPARAMETERIVPROC = CFuncPtr3[GLenum, GLenum, Ptr[GLint], Unit]
  object PFNGLGETRENDERBUFFERPARAMETERIVPROC:
    given _tag: Tag[PFNGLGETRENDERBUFFERPARAMETERIVPROC] = Tag.materializeCFuncPtr3[GLenum, GLenum, Ptr[GLint], Unit]
    inline def fromPtr(ptr: Ptr[Byte] | Ptr[?]): PFNGLGETRENDERBUFFERPARAMETERIVPROC = CFuncPtr.fromPtr(ptr.asInstanceOf[Ptr[Byte]])
    inline def apply(inline o: CFuncPtr3[GLenum, GLenum, Ptr[GLint], Unit]): PFNGLGETRENDERBUFFERPARAMETERIVPROC = o
    extension (v: PFNGLGETRENDERBUFFERPARAMETERIVPROC)
      inline def value: CFuncPtr3[GLenum, GLenum, Ptr[GLint], Unit] = v
      inline def toPtr: Ptr[?] = CFuncPtr.toPtr(v)

  opaque type PFNGLGETSAMPLERPARAMETERFVPROC = CFuncPtr3[GLuint, GLenum, Ptr[GLfloat], Unit]
  object PFNGLGETSAMPLERPARAMETERFVPROC:
    given _tag: Tag[PFNGLGETSAMPLERPARAMETERFVPROC] = Tag.materializeCFuncPtr3[GLuint, GLenum, Ptr[GLfloat], Unit]
    inline def fromPtr(ptr: Ptr[Byte] | Ptr[?]): PFNGLGETSAMPLERPARAMETERFVPROC = CFuncPtr.fromPtr(ptr.asInstanceOf[Ptr[Byte]])
    inline def apply(inline o: CFuncPtr3[GLuint, GLenum, Ptr[GLfloat], Unit]): PFNGLGETSAMPLERPARAMETERFVPROC = o
    extension (v: PFNGLGETSAMPLERPARAMETERFVPROC)
      inline def value: CFuncPtr3[GLuint, GLenum, Ptr[GLfloat], Unit] = v
      inline def toPtr: Ptr[?] = CFuncPtr.toPtr(v)

  opaque type PFNGLGETSAMPLERPARAMETERIIVEXTPROC = CFuncPtr3[GLuint, GLenum, Ptr[GLint], Unit]
  object PFNGLGETSAMPLERPARAMETERIIVEXTPROC:
    given _tag: Tag[PFNGLGETSAMPLERPARAMETERIIVEXTPROC] = Tag.materializeCFuncPtr3[GLuint, GLenum, Ptr[GLint], Unit]
    inline def fromPtr(ptr: Ptr[Byte] | Ptr[?]): PFNGLGETSAMPLERPARAMETERIIVEXTPROC = CFuncPtr.fromPtr(ptr.asInstanceOf[Ptr[Byte]])
    inline def apply(inline o: CFuncPtr3[GLuint, GLenum, Ptr[GLint], Unit]): PFNGLGETSAMPLERPARAMETERIIVEXTPROC = o
    extension (v: PFNGLGETSAMPLERPARAMETERIIVEXTPROC)
      inline def value: CFuncPtr3[GLuint, GLenum, Ptr[GLint], Unit] = v
      inline def toPtr: Ptr[?] = CFuncPtr.toPtr(v)

  opaque type PFNGLGETSAMPLERPARAMETERIIVOESPROC = CFuncPtr3[GLuint, GLenum, Ptr[GLint], Unit]
  object PFNGLGETSAMPLERPARAMETERIIVOESPROC:
    given _tag: Tag[PFNGLGETSAMPLERPARAMETERIIVOESPROC] = Tag.materializeCFuncPtr3[GLuint, GLenum, Ptr[GLint], Unit]
    inline def fromPtr(ptr: Ptr[Byte] | Ptr[?]): PFNGLGETSAMPLERPARAMETERIIVOESPROC = CFuncPtr.fromPtr(ptr.asInstanceOf[Ptr[Byte]])
    inline def apply(inline o: CFuncPtr3[GLuint, GLenum, Ptr[GLint], Unit]): PFNGLGETSAMPLERPARAMETERIIVOESPROC = o
    extension (v: PFNGLGETSAMPLERPARAMETERIIVOESPROC)
      inline def value: CFuncPtr3[GLuint, GLenum, Ptr[GLint], Unit] = v
      inline def toPtr: Ptr[?] = CFuncPtr.toPtr(v)

  opaque type PFNGLGETSAMPLERPARAMETERIIVPROC = CFuncPtr3[GLuint, GLenum, Ptr[GLint], Unit]
  object PFNGLGETSAMPLERPARAMETERIIVPROC:
    given _tag: Tag[PFNGLGETSAMPLERPARAMETERIIVPROC] = Tag.materializeCFuncPtr3[GLuint, GLenum, Ptr[GLint], Unit]
    inline def fromPtr(ptr: Ptr[Byte] | Ptr[?]): PFNGLGETSAMPLERPARAMETERIIVPROC = CFuncPtr.fromPtr(ptr.asInstanceOf[Ptr[Byte]])
    inline def apply(inline o: CFuncPtr3[GLuint, GLenum, Ptr[GLint], Unit]): PFNGLGETSAMPLERPARAMETERIIVPROC = o
    extension (v: PFNGLGETSAMPLERPARAMETERIIVPROC)
      inline def value: CFuncPtr3[GLuint, GLenum, Ptr[GLint], Unit] = v
      inline def toPtr: Ptr[?] = CFuncPtr.toPtr(v)

  opaque type PFNGLGETSAMPLERPARAMETERIUIVEXTPROC = CFuncPtr3[GLuint, GLenum, Ptr[GLuint], Unit]
  object PFNGLGETSAMPLERPARAMETERIUIVEXTPROC:
    given _tag: Tag[PFNGLGETSAMPLERPARAMETERIUIVEXTPROC] = Tag.materializeCFuncPtr3[GLuint, GLenum, Ptr[GLuint], Unit]
    inline def fromPtr(ptr: Ptr[Byte] | Ptr[?]): PFNGLGETSAMPLERPARAMETERIUIVEXTPROC = CFuncPtr.fromPtr(ptr.asInstanceOf[Ptr[Byte]])
    inline def apply(inline o: CFuncPtr3[GLuint, GLenum, Ptr[GLuint], Unit]): PFNGLGETSAMPLERPARAMETERIUIVEXTPROC = o
    extension (v: PFNGLGETSAMPLERPARAMETERIUIVEXTPROC)
      inline def value: CFuncPtr3[GLuint, GLenum, Ptr[GLuint], Unit] = v
      inline def toPtr: Ptr[?] = CFuncPtr.toPtr(v)

  opaque type PFNGLGETSAMPLERPARAMETERIUIVOESPROC = CFuncPtr3[GLuint, GLenum, Ptr[GLuint], Unit]
  object PFNGLGETSAMPLERPARAMETERIUIVOESPROC:
    given _tag: Tag[PFNGLGETSAMPLERPARAMETERIUIVOESPROC] = Tag.materializeCFuncPtr3[GLuint, GLenum, Ptr[GLuint], Unit]
    inline def fromPtr(ptr: Ptr[Byte] | Ptr[?]): PFNGLGETSAMPLERPARAMETERIUIVOESPROC = CFuncPtr.fromPtr(ptr.asInstanceOf[Ptr[Byte]])
    inline def apply(inline o: CFuncPtr3[GLuint, GLenum, Ptr[GLuint], Unit]): PFNGLGETSAMPLERPARAMETERIUIVOESPROC = o
    extension (v: PFNGLGETSAMPLERPARAMETERIUIVOESPROC)
      inline def value: CFuncPtr3[GLuint, GLenum, Ptr[GLuint], Unit] = v
      inline def toPtr: Ptr[?] = CFuncPtr.toPtr(v)

  opaque type PFNGLGETSAMPLERPARAMETERIUIVPROC = CFuncPtr3[GLuint, GLenum, Ptr[GLuint], Unit]
  object PFNGLGETSAMPLERPARAMETERIUIVPROC:
    given _tag: Tag[PFNGLGETSAMPLERPARAMETERIUIVPROC] = Tag.materializeCFuncPtr3[GLuint, GLenum, Ptr[GLuint], Unit]
    inline def fromPtr(ptr: Ptr[Byte] | Ptr[?]): PFNGLGETSAMPLERPARAMETERIUIVPROC = CFuncPtr.fromPtr(ptr.asInstanceOf[Ptr[Byte]])
    inline def apply(inline o: CFuncPtr3[GLuint, GLenum, Ptr[GLuint], Unit]): PFNGLGETSAMPLERPARAMETERIUIVPROC = o
    extension (v: PFNGLGETSAMPLERPARAMETERIUIVPROC)
      inline def value: CFuncPtr3[GLuint, GLenum, Ptr[GLuint], Unit] = v
      inline def toPtr: Ptr[?] = CFuncPtr.toPtr(v)

  opaque type PFNGLGETSAMPLERPARAMETERIVPROC = CFuncPtr3[GLuint, GLenum, Ptr[GLint], Unit]
  object PFNGLGETSAMPLERPARAMETERIVPROC:
    given _tag: Tag[PFNGLGETSAMPLERPARAMETERIVPROC] = Tag.materializeCFuncPtr3[GLuint, GLenum, Ptr[GLint], Unit]
    inline def fromPtr(ptr: Ptr[Byte] | Ptr[?]): PFNGLGETSAMPLERPARAMETERIVPROC = CFuncPtr.fromPtr(ptr.asInstanceOf[Ptr[Byte]])
    inline def apply(inline o: CFuncPtr3[GLuint, GLenum, Ptr[GLint], Unit]): PFNGLGETSAMPLERPARAMETERIVPROC = o
    extension (v: PFNGLGETSAMPLERPARAMETERIVPROC)
      inline def value: CFuncPtr3[GLuint, GLenum, Ptr[GLint], Unit] = v
      inline def toPtr: Ptr[?] = CFuncPtr.toPtr(v)

  opaque type PFNGLGETSEMAPHOREPARAMETERUI64VEXTPROC = CFuncPtr3[GLuint, GLenum, Ptr[GLuint64], Unit]
  object PFNGLGETSEMAPHOREPARAMETERUI64VEXTPROC:
    given _tag: Tag[PFNGLGETSEMAPHOREPARAMETERUI64VEXTPROC] = Tag.materializeCFuncPtr3[GLuint, GLenum, Ptr[GLuint64], Unit]
    inline def fromPtr(ptr: Ptr[Byte] | Ptr[?]): PFNGLGETSEMAPHOREPARAMETERUI64VEXTPROC = CFuncPtr.fromPtr(ptr.asInstanceOf[Ptr[Byte]])
    inline def apply(inline o: CFuncPtr3[GLuint, GLenum, Ptr[GLuint64], Unit]): PFNGLGETSEMAPHOREPARAMETERUI64VEXTPROC = o
    extension (v: PFNGLGETSEMAPHOREPARAMETERUI64VEXTPROC)
      inline def value: CFuncPtr3[GLuint, GLenum, Ptr[GLuint64], Unit] = v
      inline def toPtr: Ptr[?] = CFuncPtr.toPtr(v)

  opaque type PFNGLGETSEPARABLEFILTEREXTPROC = CFuncPtr6[GLenum, GLenum, GLenum, Ptr[Byte], Ptr[Byte], Ptr[Byte], Unit]
  object PFNGLGETSEPARABLEFILTEREXTPROC:
    given _tag: Tag[PFNGLGETSEPARABLEFILTEREXTPROC] = Tag.materializeCFuncPtr6[GLenum, GLenum, GLenum, Ptr[Byte], Ptr[Byte], Ptr[Byte], Unit]
    inline def fromPtr(ptr: Ptr[Byte] | Ptr[?]): PFNGLGETSEPARABLEFILTEREXTPROC = CFuncPtr.fromPtr(ptr.asInstanceOf[Ptr[Byte]])
    inline def apply(inline o: CFuncPtr6[GLenum, GLenum, GLenum, Ptr[Byte], Ptr[Byte], Ptr[Byte], Unit]): PFNGLGETSEPARABLEFILTEREXTPROC = o
    extension (v: PFNGLGETSEPARABLEFILTEREXTPROC)
      inline def value: CFuncPtr6[GLenum, GLenum, GLenum, Ptr[Byte], Ptr[Byte], Ptr[Byte], Unit] = v
      inline def toPtr: Ptr[?] = CFuncPtr.toPtr(v)

  opaque type PFNGLGETSEPARABLEFILTERPROC = CFuncPtr6[GLenum, GLenum, GLenum, Ptr[Byte], Ptr[Byte], Ptr[Byte], Unit]
  object PFNGLGETSEPARABLEFILTERPROC:
    given _tag: Tag[PFNGLGETSEPARABLEFILTERPROC] = Tag.materializeCFuncPtr6[GLenum, GLenum, GLenum, Ptr[Byte], Ptr[Byte], Ptr[Byte], Unit]
    inline def fromPtr(ptr: Ptr[Byte] | Ptr[?]): PFNGLGETSEPARABLEFILTERPROC = CFuncPtr.fromPtr(ptr.asInstanceOf[Ptr[Byte]])
    inline def apply(inline o: CFuncPtr6[GLenum, GLenum, GLenum, Ptr[Byte], Ptr[Byte], Ptr[Byte], Unit]): PFNGLGETSEPARABLEFILTERPROC = o
    extension (v: PFNGLGETSEPARABLEFILTERPROC)
      inline def value: CFuncPtr6[GLenum, GLenum, GLenum, Ptr[Byte], Ptr[Byte], Ptr[Byte], Unit] = v
      inline def toPtr: Ptr[?] = CFuncPtr.toPtr(v)

  opaque type PFNGLGETSHADERINFOLOGPROC = CFuncPtr4[GLuint, GLsizei, Ptr[GLsizei], Ptr[GLchar], Unit]
  object PFNGLGETSHADERINFOLOGPROC:
    given _tag: Tag[PFNGLGETSHADERINFOLOGPROC] = Tag.materializeCFuncPtr4[GLuint, GLsizei, Ptr[GLsizei], Ptr[GLchar], Unit]
    inline def fromPtr(ptr: Ptr[Byte] | Ptr[?]): PFNGLGETSHADERINFOLOGPROC = CFuncPtr.fromPtr(ptr.asInstanceOf[Ptr[Byte]])
    inline def apply(inline o: CFuncPtr4[GLuint, GLsizei, Ptr[GLsizei], Ptr[GLchar], Unit]): PFNGLGETSHADERINFOLOGPROC = o
    extension (v: PFNGLGETSHADERINFOLOGPROC)
      inline def value: CFuncPtr4[GLuint, GLsizei, Ptr[GLsizei], Ptr[GLchar], Unit] = v
      inline def toPtr: Ptr[?] = CFuncPtr.toPtr(v)

  opaque type PFNGLGETSHADERIVPROC = CFuncPtr3[GLuint, GLenum, Ptr[GLint], Unit]
  object PFNGLGETSHADERIVPROC:
    given _tag: Tag[PFNGLGETSHADERIVPROC] = Tag.materializeCFuncPtr3[GLuint, GLenum, Ptr[GLint], Unit]
    inline def fromPtr(ptr: Ptr[Byte] | Ptr[?]): PFNGLGETSHADERIVPROC = CFuncPtr.fromPtr(ptr.asInstanceOf[Ptr[Byte]])
    inline def apply(inline o: CFuncPtr3[GLuint, GLenum, Ptr[GLint], Unit]): PFNGLGETSHADERIVPROC = o
    extension (v: PFNGLGETSHADERIVPROC)
      inline def value: CFuncPtr3[GLuint, GLenum, Ptr[GLint], Unit] = v
      inline def toPtr: Ptr[?] = CFuncPtr.toPtr(v)

  opaque type PFNGLGETSHADERPRECISIONFORMATPROC = CFuncPtr4[GLenum, GLenum, Ptr[GLint], Ptr[GLint], Unit]
  object PFNGLGETSHADERPRECISIONFORMATPROC:
    given _tag: Tag[PFNGLGETSHADERPRECISIONFORMATPROC] = Tag.materializeCFuncPtr4[GLenum, GLenum, Ptr[GLint], Ptr[GLint], Unit]
    inline def fromPtr(ptr: Ptr[Byte] | Ptr[?]): PFNGLGETSHADERPRECISIONFORMATPROC = CFuncPtr.fromPtr(ptr.asInstanceOf[Ptr[Byte]])
    inline def apply(inline o: CFuncPtr4[GLenum, GLenum, Ptr[GLint], Ptr[GLint], Unit]): PFNGLGETSHADERPRECISIONFORMATPROC = o
    extension (v: PFNGLGETSHADERPRECISIONFORMATPROC)
      inline def value: CFuncPtr4[GLenum, GLenum, Ptr[GLint], Ptr[GLint], Unit] = v
      inline def toPtr: Ptr[?] = CFuncPtr.toPtr(v)

  opaque type PFNGLGETSHADERSOURCEARBPROC = CFuncPtr4[GLhandleARB, GLsizei, Ptr[GLsizei], Ptr[GLcharARB], Unit]
  object PFNGLGETSHADERSOURCEARBPROC:
    given _tag: Tag[PFNGLGETSHADERSOURCEARBPROC] = Tag.materializeCFuncPtr4[GLhandleARB, GLsizei, Ptr[GLsizei], Ptr[GLcharARB], Unit]
    inline def fromPtr(ptr: Ptr[Byte] | Ptr[?]): PFNGLGETSHADERSOURCEARBPROC = CFuncPtr.fromPtr(ptr.asInstanceOf[Ptr[Byte]])
    inline def apply(inline o: CFuncPtr4[GLhandleARB, GLsizei, Ptr[GLsizei], Ptr[GLcharARB], Unit]): PFNGLGETSHADERSOURCEARBPROC = o
    extension (v: PFNGLGETSHADERSOURCEARBPROC)
      inline def value: CFuncPtr4[GLhandleARB, GLsizei, Ptr[GLsizei], Ptr[GLcharARB], Unit] = v
      inline def toPtr: Ptr[?] = CFuncPtr.toPtr(v)

  opaque type PFNGLGETSHADERSOURCEPROC = CFuncPtr4[GLuint, GLsizei, Ptr[GLsizei], Ptr[GLchar], Unit]
  object PFNGLGETSHADERSOURCEPROC:
    given _tag: Tag[PFNGLGETSHADERSOURCEPROC] = Tag.materializeCFuncPtr4[GLuint, GLsizei, Ptr[GLsizei], Ptr[GLchar], Unit]
    inline def fromPtr(ptr: Ptr[Byte] | Ptr[?]): PFNGLGETSHADERSOURCEPROC = CFuncPtr.fromPtr(ptr.asInstanceOf[Ptr[Byte]])
    inline def apply(inline o: CFuncPtr4[GLuint, GLsizei, Ptr[GLsizei], Ptr[GLchar], Unit]): PFNGLGETSHADERSOURCEPROC = o
    extension (v: PFNGLGETSHADERSOURCEPROC)
      inline def value: CFuncPtr4[GLuint, GLsizei, Ptr[GLsizei], Ptr[GLchar], Unit] = v
      inline def toPtr: Ptr[?] = CFuncPtr.toPtr(v)

  opaque type PFNGLGETSHADINGRATEIMAGEPALETTENVPROC = CFuncPtr3[GLuint, GLuint, Ptr[GLenum], Unit]
  object PFNGLGETSHADINGRATEIMAGEPALETTENVPROC:
    given _tag: Tag[PFNGLGETSHADINGRATEIMAGEPALETTENVPROC] = Tag.materializeCFuncPtr3[GLuint, GLuint, Ptr[GLenum], Unit]
    inline def fromPtr(ptr: Ptr[Byte] | Ptr[?]): PFNGLGETSHADINGRATEIMAGEPALETTENVPROC = CFuncPtr.fromPtr(ptr.asInstanceOf[Ptr[Byte]])
    inline def apply(inline o: CFuncPtr3[GLuint, GLuint, Ptr[GLenum], Unit]): PFNGLGETSHADINGRATEIMAGEPALETTENVPROC = o
    extension (v: PFNGLGETSHADINGRATEIMAGEPALETTENVPROC)
      inline def value: CFuncPtr3[GLuint, GLuint, Ptr[GLenum], Unit] = v
      inline def toPtr: Ptr[?] = CFuncPtr.toPtr(v)

  opaque type PFNGLGETSHADINGRATESAMPLELOCATIONIVNVPROC = CFuncPtr4[GLenum, GLuint, GLuint, Ptr[GLint], Unit]
  object PFNGLGETSHADINGRATESAMPLELOCATIONIVNVPROC:
    given _tag: Tag[PFNGLGETSHADINGRATESAMPLELOCATIONIVNVPROC] = Tag.materializeCFuncPtr4[GLenum, GLuint, GLuint, Ptr[GLint], Unit]
    inline def fromPtr(ptr: Ptr[Byte] | Ptr[?]): PFNGLGETSHADINGRATESAMPLELOCATIONIVNVPROC = CFuncPtr.fromPtr(ptr.asInstanceOf[Ptr[Byte]])
    inline def apply(inline o: CFuncPtr4[GLenum, GLuint, GLuint, Ptr[GLint], Unit]): PFNGLGETSHADINGRATESAMPLELOCATIONIVNVPROC = o
    extension (v: PFNGLGETSHADINGRATESAMPLELOCATIONIVNVPROC)
      inline def value: CFuncPtr4[GLenum, GLuint, GLuint, Ptr[GLint], Unit] = v
      inline def toPtr: Ptr[?] = CFuncPtr.toPtr(v)

  opaque type PFNGLGETSHARPENTEXFUNCSGISPROC = CFuncPtr2[GLenum, Ptr[GLfloat], Unit]
  object PFNGLGETSHARPENTEXFUNCSGISPROC:
    given _tag: Tag[PFNGLGETSHARPENTEXFUNCSGISPROC] = Tag.materializeCFuncPtr2[GLenum, Ptr[GLfloat], Unit]
    inline def fromPtr(ptr: Ptr[Byte] | Ptr[?]): PFNGLGETSHARPENTEXFUNCSGISPROC = CFuncPtr.fromPtr(ptr.asInstanceOf[Ptr[Byte]])
    inline def apply(inline o: CFuncPtr2[GLenum, Ptr[GLfloat], Unit]): PFNGLGETSHARPENTEXFUNCSGISPROC = o
    extension (v: PFNGLGETSHARPENTEXFUNCSGISPROC)
      inline def value: CFuncPtr2[GLenum, Ptr[GLfloat], Unit] = v
      inline def toPtr: Ptr[?] = CFuncPtr.toPtr(v)

  opaque type PFNGLGETSTAGEINDEXNVPROC = CFuncPtr1[GLenum, GLushort]
  object PFNGLGETSTAGEINDEXNVPROC:
    given _tag: Tag[PFNGLGETSTAGEINDEXNVPROC] = Tag.materializeCFuncPtr1[GLenum, GLushort]
    inline def fromPtr(ptr: Ptr[Byte] | Ptr[?]): PFNGLGETSTAGEINDEXNVPROC = CFuncPtr.fromPtr(ptr.asInstanceOf[Ptr[Byte]])
    inline def apply(inline o: CFuncPtr1[GLenum, GLushort]): PFNGLGETSTAGEINDEXNVPROC = o
    extension (v: PFNGLGETSTAGEINDEXNVPROC)
      inline def value: CFuncPtr1[GLenum, GLushort] = v
      inline def toPtr: Ptr[?] = CFuncPtr.toPtr(v)

  opaque type PFNGLGETSTRINGIPROC = CFuncPtr2[GLenum, GLuint, Ptr[GLubyte]]
  object PFNGLGETSTRINGIPROC:
    given _tag: Tag[PFNGLGETSTRINGIPROC] = Tag.materializeCFuncPtr2[GLenum, GLuint, Ptr[GLubyte]]
    inline def fromPtr(ptr: Ptr[Byte] | Ptr[?]): PFNGLGETSTRINGIPROC = CFuncPtr.fromPtr(ptr.asInstanceOf[Ptr[Byte]])
    inline def apply(inline o: CFuncPtr2[GLenum, GLuint, Ptr[GLubyte]]): PFNGLGETSTRINGIPROC = o
    extension (v: PFNGLGETSTRINGIPROC)
      inline def value: CFuncPtr2[GLenum, GLuint, Ptr[GLubyte]] = v
      inline def toPtr: Ptr[?] = CFuncPtr.toPtr(v)

  opaque type PFNGLGETSUBROUTINEINDEXPROC = CFuncPtr3[GLuint, GLenum, Ptr[GLchar], GLuint]
  object PFNGLGETSUBROUTINEINDEXPROC:
    given _tag: Tag[PFNGLGETSUBROUTINEINDEXPROC] = Tag.materializeCFuncPtr3[GLuint, GLenum, Ptr[GLchar], GLuint]
    inline def fromPtr(ptr: Ptr[Byte] | Ptr[?]): PFNGLGETSUBROUTINEINDEXPROC = CFuncPtr.fromPtr(ptr.asInstanceOf[Ptr[Byte]])
    inline def apply(inline o: CFuncPtr3[GLuint, GLenum, Ptr[GLchar], GLuint]): PFNGLGETSUBROUTINEINDEXPROC = o
    extension (v: PFNGLGETSUBROUTINEINDEXPROC)
      inline def value: CFuncPtr3[GLuint, GLenum, Ptr[GLchar], GLuint] = v
      inline def toPtr: Ptr[?] = CFuncPtr.toPtr(v)

  opaque type PFNGLGETSUBROUTINEUNIFORMLOCATIONPROC = CFuncPtr3[GLuint, GLenum, Ptr[GLchar], GLint]
  object PFNGLGETSUBROUTINEUNIFORMLOCATIONPROC:
    given _tag: Tag[PFNGLGETSUBROUTINEUNIFORMLOCATIONPROC] = Tag.materializeCFuncPtr3[GLuint, GLenum, Ptr[GLchar], GLint]
    inline def fromPtr(ptr: Ptr[Byte] | Ptr[?]): PFNGLGETSUBROUTINEUNIFORMLOCATIONPROC = CFuncPtr.fromPtr(ptr.asInstanceOf[Ptr[Byte]])
    inline def apply(inline o: CFuncPtr3[GLuint, GLenum, Ptr[GLchar], GLint]): PFNGLGETSUBROUTINEUNIFORMLOCATIONPROC = o
    extension (v: PFNGLGETSUBROUTINEUNIFORMLOCATIONPROC)
      inline def value: CFuncPtr3[GLuint, GLenum, Ptr[GLchar], GLint] = v
      inline def toPtr: Ptr[?] = CFuncPtr.toPtr(v)

  opaque type PFNGLGETSYNCIVAPPLEPROC = CFuncPtr5[GLsync, GLenum, GLsizei, Ptr[GLsizei], Ptr[GLint], Unit]
  object PFNGLGETSYNCIVAPPLEPROC:
    given _tag: Tag[PFNGLGETSYNCIVAPPLEPROC] = Tag.materializeCFuncPtr5[GLsync, GLenum, GLsizei, Ptr[GLsizei], Ptr[GLint], Unit]
    inline def fromPtr(ptr: Ptr[Byte] | Ptr[?]): PFNGLGETSYNCIVAPPLEPROC = CFuncPtr.fromPtr(ptr.asInstanceOf[Ptr[Byte]])
    inline def apply(inline o: CFuncPtr5[GLsync, GLenum, GLsizei, Ptr[GLsizei], Ptr[GLint], Unit]): PFNGLGETSYNCIVAPPLEPROC = o
    extension (v: PFNGLGETSYNCIVAPPLEPROC)
      inline def value: CFuncPtr5[GLsync, GLenum, GLsizei, Ptr[GLsizei], Ptr[GLint], Unit] = v
      inline def toPtr: Ptr[?] = CFuncPtr.toPtr(v)

  opaque type PFNGLGETSYNCIVPROC = CFuncPtr5[GLsync, GLenum, GLsizei, Ptr[GLsizei], Ptr[GLint], Unit]
  object PFNGLGETSYNCIVPROC:
    given _tag: Tag[PFNGLGETSYNCIVPROC] = Tag.materializeCFuncPtr5[GLsync, GLenum, GLsizei, Ptr[GLsizei], Ptr[GLint], Unit]
    inline def fromPtr(ptr: Ptr[Byte] | Ptr[?]): PFNGLGETSYNCIVPROC = CFuncPtr.fromPtr(ptr.asInstanceOf[Ptr[Byte]])
    inline def apply(inline o: CFuncPtr5[GLsync, GLenum, GLsizei, Ptr[GLsizei], Ptr[GLint], Unit]): PFNGLGETSYNCIVPROC = o
    extension (v: PFNGLGETSYNCIVPROC)
      inline def value: CFuncPtr5[GLsync, GLenum, GLsizei, Ptr[GLsizei], Ptr[GLint], Unit] = v
      inline def toPtr: Ptr[?] = CFuncPtr.toPtr(v)

  opaque type PFNGLGETTEXBUMPPARAMETERFVATIPROC = CFuncPtr2[GLenum, Ptr[GLfloat], Unit]
  object PFNGLGETTEXBUMPPARAMETERFVATIPROC:
    given _tag: Tag[PFNGLGETTEXBUMPPARAMETERFVATIPROC] = Tag.materializeCFuncPtr2[GLenum, Ptr[GLfloat], Unit]
    inline def fromPtr(ptr: Ptr[Byte] | Ptr[?]): PFNGLGETTEXBUMPPARAMETERFVATIPROC = CFuncPtr.fromPtr(ptr.asInstanceOf[Ptr[Byte]])
    inline def apply(inline o: CFuncPtr2[GLenum, Ptr[GLfloat], Unit]): PFNGLGETTEXBUMPPARAMETERFVATIPROC = o
    extension (v: PFNGLGETTEXBUMPPARAMETERFVATIPROC)
      inline def value: CFuncPtr2[GLenum, Ptr[GLfloat], Unit] = v
      inline def toPtr: Ptr[?] = CFuncPtr.toPtr(v)

  opaque type PFNGLGETTEXBUMPPARAMETERIVATIPROC = CFuncPtr2[GLenum, Ptr[GLint], Unit]
  object PFNGLGETTEXBUMPPARAMETERIVATIPROC:
    given _tag: Tag[PFNGLGETTEXBUMPPARAMETERIVATIPROC] = Tag.materializeCFuncPtr2[GLenum, Ptr[GLint], Unit]
    inline def fromPtr(ptr: Ptr[Byte] | Ptr[?]): PFNGLGETTEXBUMPPARAMETERIVATIPROC = CFuncPtr.fromPtr(ptr.asInstanceOf[Ptr[Byte]])
    inline def apply(inline o: CFuncPtr2[GLenum, Ptr[GLint], Unit]): PFNGLGETTEXBUMPPARAMETERIVATIPROC = o
    extension (v: PFNGLGETTEXBUMPPARAMETERIVATIPROC)
      inline def value: CFuncPtr2[GLenum, Ptr[GLint], Unit] = v
      inline def toPtr: Ptr[?] = CFuncPtr.toPtr(v)

  opaque type PFNGLGETTEXENVXVPROC = CFuncPtr3[GLenum, GLenum, Ptr[GLfixed], Unit]
  object PFNGLGETTEXENVXVPROC:
    given _tag: Tag[PFNGLGETTEXENVXVPROC] = Tag.materializeCFuncPtr3[GLenum, GLenum, Ptr[GLfixed], Unit]
    inline def fromPtr(ptr: Ptr[Byte] | Ptr[?]): PFNGLGETTEXENVXVPROC = CFuncPtr.fromPtr(ptr.asInstanceOf[Ptr[Byte]])
    inline def apply(inline o: CFuncPtr3[GLenum, GLenum, Ptr[GLfixed], Unit]): PFNGLGETTEXENVXVPROC = o
    extension (v: PFNGLGETTEXENVXVPROC)
      inline def value: CFuncPtr3[GLenum, GLenum, Ptr[GLfixed], Unit] = v
      inline def toPtr: Ptr[?] = CFuncPtr.toPtr(v)

  opaque type PFNGLGETTEXFILTERFUNCSGISPROC = CFuncPtr3[GLenum, GLenum, Ptr[GLfloat], Unit]
  object PFNGLGETTEXFILTERFUNCSGISPROC:
    given _tag: Tag[PFNGLGETTEXFILTERFUNCSGISPROC] = Tag.materializeCFuncPtr3[GLenum, GLenum, Ptr[GLfloat], Unit]
    inline def fromPtr(ptr: Ptr[Byte] | Ptr[?]): PFNGLGETTEXFILTERFUNCSGISPROC = CFuncPtr.fromPtr(ptr.asInstanceOf[Ptr[Byte]])
    inline def apply(inline o: CFuncPtr3[GLenum, GLenum, Ptr[GLfloat], Unit]): PFNGLGETTEXFILTERFUNCSGISPROC = o
    extension (v: PFNGLGETTEXFILTERFUNCSGISPROC)
      inline def value: CFuncPtr3[GLenum, GLenum, Ptr[GLfloat], Unit] = v
      inline def toPtr: Ptr[?] = CFuncPtr.toPtr(v)

  opaque type PFNGLGETTEXGENFVOESPROC = CFuncPtr3[GLenum, GLenum, Ptr[GLfloat], Unit]
  object PFNGLGETTEXGENFVOESPROC:
    given _tag: Tag[PFNGLGETTEXGENFVOESPROC] = Tag.materializeCFuncPtr3[GLenum, GLenum, Ptr[GLfloat], Unit]
    inline def fromPtr(ptr: Ptr[Byte] | Ptr[?]): PFNGLGETTEXGENFVOESPROC = CFuncPtr.fromPtr(ptr.asInstanceOf[Ptr[Byte]])
    inline def apply(inline o: CFuncPtr3[GLenum, GLenum, Ptr[GLfloat], Unit]): PFNGLGETTEXGENFVOESPROC = o
    extension (v: PFNGLGETTEXGENFVOESPROC)
      inline def value: CFuncPtr3[GLenum, GLenum, Ptr[GLfloat], Unit] = v
      inline def toPtr: Ptr[?] = CFuncPtr.toPtr(v)

  opaque type PFNGLGETTEXGENIVOESPROC = CFuncPtr3[GLenum, GLenum, Ptr[GLint], Unit]
  object PFNGLGETTEXGENIVOESPROC:
    given _tag: Tag[PFNGLGETTEXGENIVOESPROC] = Tag.materializeCFuncPtr3[GLenum, GLenum, Ptr[GLint], Unit]
    inline def fromPtr(ptr: Ptr[Byte] | Ptr[?]): PFNGLGETTEXGENIVOESPROC = CFuncPtr.fromPtr(ptr.asInstanceOf[Ptr[Byte]])
    inline def apply(inline o: CFuncPtr3[GLenum, GLenum, Ptr[GLint], Unit]): PFNGLGETTEXGENIVOESPROC = o
    extension (v: PFNGLGETTEXGENIVOESPROC)
      inline def value: CFuncPtr3[GLenum, GLenum, Ptr[GLint], Unit] = v
      inline def toPtr: Ptr[?] = CFuncPtr.toPtr(v)

  opaque type PFNGLGETTEXGENXVOESPROC = CFuncPtr3[GLenum, GLenum, Ptr[GLfixed], Unit]
  object PFNGLGETTEXGENXVOESPROC:
    given _tag: Tag[PFNGLGETTEXGENXVOESPROC] = Tag.materializeCFuncPtr3[GLenum, GLenum, Ptr[GLfixed], Unit]
    inline def fromPtr(ptr: Ptr[Byte] | Ptr[?]): PFNGLGETTEXGENXVOESPROC = CFuncPtr.fromPtr(ptr.asInstanceOf[Ptr[Byte]])
    inline def apply(inline o: CFuncPtr3[GLenum, GLenum, Ptr[GLfixed], Unit]): PFNGLGETTEXGENXVOESPROC = o
    extension (v: PFNGLGETTEXGENXVOESPROC)
      inline def value: CFuncPtr3[GLenum, GLenum, Ptr[GLfixed], Unit] = v
      inline def toPtr: Ptr[?] = CFuncPtr.toPtr(v)

  opaque type PFNGLGETTEXPARAMETERIIVEXTPROC = CFuncPtr3[GLenum, GLenum, Ptr[GLint], Unit]
  object PFNGLGETTEXPARAMETERIIVEXTPROC:
    given _tag: Tag[PFNGLGETTEXPARAMETERIIVEXTPROC] = Tag.materializeCFuncPtr3[GLenum, GLenum, Ptr[GLint], Unit]
    inline def fromPtr(ptr: Ptr[Byte] | Ptr[?]): PFNGLGETTEXPARAMETERIIVEXTPROC = CFuncPtr.fromPtr(ptr.asInstanceOf[Ptr[Byte]])
    inline def apply(inline o: CFuncPtr3[GLenum, GLenum, Ptr[GLint], Unit]): PFNGLGETTEXPARAMETERIIVEXTPROC = o
    extension (v: PFNGLGETTEXPARAMETERIIVEXTPROC)
      inline def value: CFuncPtr3[GLenum, GLenum, Ptr[GLint], Unit] = v
      inline def toPtr: Ptr[?] = CFuncPtr.toPtr(v)

  opaque type PFNGLGETTEXPARAMETERIIVOESPROC = CFuncPtr3[GLenum, GLenum, Ptr[GLint], Unit]
  object PFNGLGETTEXPARAMETERIIVOESPROC:
    given _tag: Tag[PFNGLGETTEXPARAMETERIIVOESPROC] = Tag.materializeCFuncPtr3[GLenum, GLenum, Ptr[GLint], Unit]
    inline def fromPtr(ptr: Ptr[Byte] | Ptr[?]): PFNGLGETTEXPARAMETERIIVOESPROC = CFuncPtr.fromPtr(ptr.asInstanceOf[Ptr[Byte]])
    inline def apply(inline o: CFuncPtr3[GLenum, GLenum, Ptr[GLint], Unit]): PFNGLGETTEXPARAMETERIIVOESPROC = o
    extension (v: PFNGLGETTEXPARAMETERIIVOESPROC)
      inline def value: CFuncPtr3[GLenum, GLenum, Ptr[GLint], Unit] = v
      inline def toPtr: Ptr[?] = CFuncPtr.toPtr(v)

  opaque type PFNGLGETTEXPARAMETERIIVPROC = CFuncPtr3[GLenum, GLenum, Ptr[GLint], Unit]
  object PFNGLGETTEXPARAMETERIIVPROC:
    given _tag: Tag[PFNGLGETTEXPARAMETERIIVPROC] = Tag.materializeCFuncPtr3[GLenum, GLenum, Ptr[GLint], Unit]
    inline def fromPtr(ptr: Ptr[Byte] | Ptr[?]): PFNGLGETTEXPARAMETERIIVPROC = CFuncPtr.fromPtr(ptr.asInstanceOf[Ptr[Byte]])
    inline def apply(inline o: CFuncPtr3[GLenum, GLenum, Ptr[GLint], Unit]): PFNGLGETTEXPARAMETERIIVPROC = o
    extension (v: PFNGLGETTEXPARAMETERIIVPROC)
      inline def value: CFuncPtr3[GLenum, GLenum, Ptr[GLint], Unit] = v
      inline def toPtr: Ptr[?] = CFuncPtr.toPtr(v)

  opaque type PFNGLGETTEXPARAMETERIUIVEXTPROC = CFuncPtr3[GLenum, GLenum, Ptr[GLuint], Unit]
  object PFNGLGETTEXPARAMETERIUIVEXTPROC:
    given _tag: Tag[PFNGLGETTEXPARAMETERIUIVEXTPROC] = Tag.materializeCFuncPtr3[GLenum, GLenum, Ptr[GLuint], Unit]
    inline def fromPtr(ptr: Ptr[Byte] | Ptr[?]): PFNGLGETTEXPARAMETERIUIVEXTPROC = CFuncPtr.fromPtr(ptr.asInstanceOf[Ptr[Byte]])
    inline def apply(inline o: CFuncPtr3[GLenum, GLenum, Ptr[GLuint], Unit]): PFNGLGETTEXPARAMETERIUIVEXTPROC = o
    extension (v: PFNGLGETTEXPARAMETERIUIVEXTPROC)
      inline def value: CFuncPtr3[GLenum, GLenum, Ptr[GLuint], Unit] = v
      inline def toPtr: Ptr[?] = CFuncPtr.toPtr(v)

  opaque type PFNGLGETTEXPARAMETERIUIVOESPROC = CFuncPtr3[GLenum, GLenum, Ptr[GLuint], Unit]
  object PFNGLGETTEXPARAMETERIUIVOESPROC:
    given _tag: Tag[PFNGLGETTEXPARAMETERIUIVOESPROC] = Tag.materializeCFuncPtr3[GLenum, GLenum, Ptr[GLuint], Unit]
    inline def fromPtr(ptr: Ptr[Byte] | Ptr[?]): PFNGLGETTEXPARAMETERIUIVOESPROC = CFuncPtr.fromPtr(ptr.asInstanceOf[Ptr[Byte]])
    inline def apply(inline o: CFuncPtr3[GLenum, GLenum, Ptr[GLuint], Unit]): PFNGLGETTEXPARAMETERIUIVOESPROC = o
    extension (v: PFNGLGETTEXPARAMETERIUIVOESPROC)
      inline def value: CFuncPtr3[GLenum, GLenum, Ptr[GLuint], Unit] = v
      inline def toPtr: Ptr[?] = CFuncPtr.toPtr(v)

  opaque type PFNGLGETTEXPARAMETERIUIVPROC = CFuncPtr3[GLenum, GLenum, Ptr[GLuint], Unit]
  object PFNGLGETTEXPARAMETERIUIVPROC:
    given _tag: Tag[PFNGLGETTEXPARAMETERIUIVPROC] = Tag.materializeCFuncPtr3[GLenum, GLenum, Ptr[GLuint], Unit]
    inline def fromPtr(ptr: Ptr[Byte] | Ptr[?]): PFNGLGETTEXPARAMETERIUIVPROC = CFuncPtr.fromPtr(ptr.asInstanceOf[Ptr[Byte]])
    inline def apply(inline o: CFuncPtr3[GLenum, GLenum, Ptr[GLuint], Unit]): PFNGLGETTEXPARAMETERIUIVPROC = o
    extension (v: PFNGLGETTEXPARAMETERIUIVPROC)
      inline def value: CFuncPtr3[GLenum, GLenum, Ptr[GLuint], Unit] = v
      inline def toPtr: Ptr[?] = CFuncPtr.toPtr(v)

  opaque type PFNGLGETTEXPARAMETERPOINTERVAPPLEPROC = CFuncPtr3[GLenum, GLenum, Ptr[Ptr[Byte]], Unit]
  object PFNGLGETTEXPARAMETERPOINTERVAPPLEPROC:
    given _tag: Tag[PFNGLGETTEXPARAMETERPOINTERVAPPLEPROC] = Tag.materializeCFuncPtr3[GLenum, GLenum, Ptr[Ptr[Byte]], Unit]
    inline def fromPtr(ptr: Ptr[Byte] | Ptr[?]): PFNGLGETTEXPARAMETERPOINTERVAPPLEPROC = CFuncPtr.fromPtr(ptr.asInstanceOf[Ptr[Byte]])
    inline def apply(inline o: CFuncPtr3[GLenum, GLenum, Ptr[Ptr[Byte]], Unit]): PFNGLGETTEXPARAMETERPOINTERVAPPLEPROC = o
    extension (v: PFNGLGETTEXPARAMETERPOINTERVAPPLEPROC)
      inline def value: CFuncPtr3[GLenum, GLenum, Ptr[Ptr[Byte]], Unit] = v
      inline def toPtr: Ptr[?] = CFuncPtr.toPtr(v)

  opaque type PFNGLGETTEXPARAMETERXVPROC = CFuncPtr3[GLenum, GLenum, Ptr[GLfixed], Unit]
  object PFNGLGETTEXPARAMETERXVPROC:
    given _tag: Tag[PFNGLGETTEXPARAMETERXVPROC] = Tag.materializeCFuncPtr3[GLenum, GLenum, Ptr[GLfixed], Unit]
    inline def fromPtr(ptr: Ptr[Byte] | Ptr[?]): PFNGLGETTEXPARAMETERXVPROC = CFuncPtr.fromPtr(ptr.asInstanceOf[Ptr[Byte]])
    inline def apply(inline o: CFuncPtr3[GLenum, GLenum, Ptr[GLfixed], Unit]): PFNGLGETTEXPARAMETERXVPROC = o
    extension (v: PFNGLGETTEXPARAMETERXVPROC)
      inline def value: CFuncPtr3[GLenum, GLenum, Ptr[GLfixed], Unit] = v
      inline def toPtr: Ptr[?] = CFuncPtr.toPtr(v)

  opaque type PFNGLGETTEXTUREHANDLEARBPROC = CFuncPtr1[GLuint, GLuint64]
  object PFNGLGETTEXTUREHANDLEARBPROC:
    given _tag: Tag[PFNGLGETTEXTUREHANDLEARBPROC] = Tag.materializeCFuncPtr1[GLuint, GLuint64]
    inline def fromPtr(ptr: Ptr[Byte] | Ptr[?]): PFNGLGETTEXTUREHANDLEARBPROC = CFuncPtr.fromPtr(ptr.asInstanceOf[Ptr[Byte]])
    inline def apply(inline o: CFuncPtr1[GLuint, GLuint64]): PFNGLGETTEXTUREHANDLEARBPROC = o
    extension (v: PFNGLGETTEXTUREHANDLEARBPROC)
      inline def value: CFuncPtr1[GLuint, GLuint64] = v
      inline def toPtr: Ptr[?] = CFuncPtr.toPtr(v)

  opaque type PFNGLGETTEXTUREHANDLEIMGPROC = CFuncPtr1[GLuint, GLuint64]
  object PFNGLGETTEXTUREHANDLEIMGPROC:
    given _tag: Tag[PFNGLGETTEXTUREHANDLEIMGPROC] = Tag.materializeCFuncPtr1[GLuint, GLuint64]
    inline def fromPtr(ptr: Ptr[Byte] | Ptr[?]): PFNGLGETTEXTUREHANDLEIMGPROC = CFuncPtr.fromPtr(ptr.asInstanceOf[Ptr[Byte]])
    inline def apply(inline o: CFuncPtr1[GLuint, GLuint64]): PFNGLGETTEXTUREHANDLEIMGPROC = o
    extension (v: PFNGLGETTEXTUREHANDLEIMGPROC)
      inline def value: CFuncPtr1[GLuint, GLuint64] = v
      inline def toPtr: Ptr[?] = CFuncPtr.toPtr(v)

  opaque type PFNGLGETTEXTUREHANDLENVPROC = CFuncPtr1[GLuint, GLuint64]
  object PFNGLGETTEXTUREHANDLENVPROC:
    given _tag: Tag[PFNGLGETTEXTUREHANDLENVPROC] = Tag.materializeCFuncPtr1[GLuint, GLuint64]
    inline def fromPtr(ptr: Ptr[Byte] | Ptr[?]): PFNGLGETTEXTUREHANDLENVPROC = CFuncPtr.fromPtr(ptr.asInstanceOf[Ptr[Byte]])
    inline def apply(inline o: CFuncPtr1[GLuint, GLuint64]): PFNGLGETTEXTUREHANDLENVPROC = o
    extension (v: PFNGLGETTEXTUREHANDLENVPROC)
      inline def value: CFuncPtr1[GLuint, GLuint64] = v
      inline def toPtr: Ptr[?] = CFuncPtr.toPtr(v)

  opaque type PFNGLGETTEXTUREIMAGEEXTPROC = CFuncPtr6[GLuint, GLenum, GLint, GLenum, GLenum, Ptr[Byte], Unit]
  object PFNGLGETTEXTUREIMAGEEXTPROC:
    given _tag: Tag[PFNGLGETTEXTUREIMAGEEXTPROC] = Tag.materializeCFuncPtr6[GLuint, GLenum, GLint, GLenum, GLenum, Ptr[Byte], Unit]
    inline def fromPtr(ptr: Ptr[Byte] | Ptr[?]): PFNGLGETTEXTUREIMAGEEXTPROC = CFuncPtr.fromPtr(ptr.asInstanceOf[Ptr[Byte]])
    inline def apply(inline o: CFuncPtr6[GLuint, GLenum, GLint, GLenum, GLenum, Ptr[Byte], Unit]): PFNGLGETTEXTUREIMAGEEXTPROC = o
    extension (v: PFNGLGETTEXTUREIMAGEEXTPROC)
      inline def value: CFuncPtr6[GLuint, GLenum, GLint, GLenum, GLenum, Ptr[Byte], Unit] = v
      inline def toPtr: Ptr[?] = CFuncPtr.toPtr(v)

  opaque type PFNGLGETTEXTUREIMAGEPROC = CFuncPtr6[GLuint, GLint, GLenum, GLenum, GLsizei, Ptr[Byte], Unit]
  object PFNGLGETTEXTUREIMAGEPROC:
    given _tag: Tag[PFNGLGETTEXTUREIMAGEPROC] = Tag.materializeCFuncPtr6[GLuint, GLint, GLenum, GLenum, GLsizei, Ptr[Byte], Unit]
    inline def fromPtr(ptr: Ptr[Byte] | Ptr[?]): PFNGLGETTEXTUREIMAGEPROC = CFuncPtr.fromPtr(ptr.asInstanceOf[Ptr[Byte]])
    inline def apply(inline o: CFuncPtr6[GLuint, GLint, GLenum, GLenum, GLsizei, Ptr[Byte], Unit]): PFNGLGETTEXTUREIMAGEPROC = o
    extension (v: PFNGLGETTEXTUREIMAGEPROC)
      inline def value: CFuncPtr6[GLuint, GLint, GLenum, GLenum, GLsizei, Ptr[Byte], Unit] = v
      inline def toPtr: Ptr[?] = CFuncPtr.toPtr(v)

  opaque type PFNGLGETTEXTURELEVELPARAMETERFVEXTPROC = CFuncPtr5[GLuint, GLenum, GLint, GLenum, Ptr[GLfloat], Unit]
  object PFNGLGETTEXTURELEVELPARAMETERFVEXTPROC:
    given _tag: Tag[PFNGLGETTEXTURELEVELPARAMETERFVEXTPROC] = Tag.materializeCFuncPtr5[GLuint, GLenum, GLint, GLenum, Ptr[GLfloat], Unit]
    inline def fromPtr(ptr: Ptr[Byte] | Ptr[?]): PFNGLGETTEXTURELEVELPARAMETERFVEXTPROC = CFuncPtr.fromPtr(ptr.asInstanceOf[Ptr[Byte]])
    inline def apply(inline o: CFuncPtr5[GLuint, GLenum, GLint, GLenum, Ptr[GLfloat], Unit]): PFNGLGETTEXTURELEVELPARAMETERFVEXTPROC = o
    extension (v: PFNGLGETTEXTURELEVELPARAMETERFVEXTPROC)
      inline def value: CFuncPtr5[GLuint, GLenum, GLint, GLenum, Ptr[GLfloat], Unit] = v
      inline def toPtr: Ptr[?] = CFuncPtr.toPtr(v)

  opaque type PFNGLGETTEXTURELEVELPARAMETERFVPROC = CFuncPtr4[GLuint, GLint, GLenum, Ptr[GLfloat], Unit]
  object PFNGLGETTEXTURELEVELPARAMETERFVPROC:
    given _tag: Tag[PFNGLGETTEXTURELEVELPARAMETERFVPROC] = Tag.materializeCFuncPtr4[GLuint, GLint, GLenum, Ptr[GLfloat], Unit]
    inline def fromPtr(ptr: Ptr[Byte] | Ptr[?]): PFNGLGETTEXTURELEVELPARAMETERFVPROC = CFuncPtr.fromPtr(ptr.asInstanceOf[Ptr[Byte]])
    inline def apply(inline o: CFuncPtr4[GLuint, GLint, GLenum, Ptr[GLfloat], Unit]): PFNGLGETTEXTURELEVELPARAMETERFVPROC = o
    extension (v: PFNGLGETTEXTURELEVELPARAMETERFVPROC)
      inline def value: CFuncPtr4[GLuint, GLint, GLenum, Ptr[GLfloat], Unit] = v
      inline def toPtr: Ptr[?] = CFuncPtr.toPtr(v)

  opaque type PFNGLGETTEXTURELEVELPARAMETERIVEXTPROC = CFuncPtr5[GLuint, GLenum, GLint, GLenum, Ptr[GLint], Unit]
  object PFNGLGETTEXTURELEVELPARAMETERIVEXTPROC:
    given _tag: Tag[PFNGLGETTEXTURELEVELPARAMETERIVEXTPROC] = Tag.materializeCFuncPtr5[GLuint, GLenum, GLint, GLenum, Ptr[GLint], Unit]
    inline def fromPtr(ptr: Ptr[Byte] | Ptr[?]): PFNGLGETTEXTURELEVELPARAMETERIVEXTPROC = CFuncPtr.fromPtr(ptr.asInstanceOf[Ptr[Byte]])
    inline def apply(inline o: CFuncPtr5[GLuint, GLenum, GLint, GLenum, Ptr[GLint], Unit]): PFNGLGETTEXTURELEVELPARAMETERIVEXTPROC = o
    extension (v: PFNGLGETTEXTURELEVELPARAMETERIVEXTPROC)
      inline def value: CFuncPtr5[GLuint, GLenum, GLint, GLenum, Ptr[GLint], Unit] = v
      inline def toPtr: Ptr[?] = CFuncPtr.toPtr(v)

  opaque type PFNGLGETTEXTURELEVELPARAMETERIVPROC = CFuncPtr4[GLuint, GLint, GLenum, Ptr[GLint], Unit]
  object PFNGLGETTEXTURELEVELPARAMETERIVPROC:
    given _tag: Tag[PFNGLGETTEXTURELEVELPARAMETERIVPROC] = Tag.materializeCFuncPtr4[GLuint, GLint, GLenum, Ptr[GLint], Unit]
    inline def fromPtr(ptr: Ptr[Byte] | Ptr[?]): PFNGLGETTEXTURELEVELPARAMETERIVPROC = CFuncPtr.fromPtr(ptr.asInstanceOf[Ptr[Byte]])
    inline def apply(inline o: CFuncPtr4[GLuint, GLint, GLenum, Ptr[GLint], Unit]): PFNGLGETTEXTURELEVELPARAMETERIVPROC = o
    extension (v: PFNGLGETTEXTURELEVELPARAMETERIVPROC)
      inline def value: CFuncPtr4[GLuint, GLint, GLenum, Ptr[GLint], Unit] = v
      inline def toPtr: Ptr[?] = CFuncPtr.toPtr(v)

  opaque type PFNGLGETTEXTUREPARAMETERFVEXTPROC = CFuncPtr4[GLuint, GLenum, GLenum, Ptr[GLfloat], Unit]
  object PFNGLGETTEXTUREPARAMETERFVEXTPROC:
    given _tag: Tag[PFNGLGETTEXTUREPARAMETERFVEXTPROC] = Tag.materializeCFuncPtr4[GLuint, GLenum, GLenum, Ptr[GLfloat], Unit]
    inline def fromPtr(ptr: Ptr[Byte] | Ptr[?]): PFNGLGETTEXTUREPARAMETERFVEXTPROC = CFuncPtr.fromPtr(ptr.asInstanceOf[Ptr[Byte]])
    inline def apply(inline o: CFuncPtr4[GLuint, GLenum, GLenum, Ptr[GLfloat], Unit]): PFNGLGETTEXTUREPARAMETERFVEXTPROC = o
    extension (v: PFNGLGETTEXTUREPARAMETERFVEXTPROC)
      inline def value: CFuncPtr4[GLuint, GLenum, GLenum, Ptr[GLfloat], Unit] = v
      inline def toPtr: Ptr[?] = CFuncPtr.toPtr(v)

  opaque type PFNGLGETTEXTUREPARAMETERFVPROC = CFuncPtr3[GLuint, GLenum, Ptr[GLfloat], Unit]
  object PFNGLGETTEXTUREPARAMETERFVPROC:
    given _tag: Tag[PFNGLGETTEXTUREPARAMETERFVPROC] = Tag.materializeCFuncPtr3[GLuint, GLenum, Ptr[GLfloat], Unit]
    inline def fromPtr(ptr: Ptr[Byte] | Ptr[?]): PFNGLGETTEXTUREPARAMETERFVPROC = CFuncPtr.fromPtr(ptr.asInstanceOf[Ptr[Byte]])
    inline def apply(inline o: CFuncPtr3[GLuint, GLenum, Ptr[GLfloat], Unit]): PFNGLGETTEXTUREPARAMETERFVPROC = o
    extension (v: PFNGLGETTEXTUREPARAMETERFVPROC)
      inline def value: CFuncPtr3[GLuint, GLenum, Ptr[GLfloat], Unit] = v
      inline def toPtr: Ptr[?] = CFuncPtr.toPtr(v)

  opaque type PFNGLGETTEXTUREPARAMETERIIVEXTPROC = CFuncPtr4[GLuint, GLenum, GLenum, Ptr[GLint], Unit]
  object PFNGLGETTEXTUREPARAMETERIIVEXTPROC:
    given _tag: Tag[PFNGLGETTEXTUREPARAMETERIIVEXTPROC] = Tag.materializeCFuncPtr4[GLuint, GLenum, GLenum, Ptr[GLint], Unit]
    inline def fromPtr(ptr: Ptr[Byte] | Ptr[?]): PFNGLGETTEXTUREPARAMETERIIVEXTPROC = CFuncPtr.fromPtr(ptr.asInstanceOf[Ptr[Byte]])
    inline def apply(inline o: CFuncPtr4[GLuint, GLenum, GLenum, Ptr[GLint], Unit]): PFNGLGETTEXTUREPARAMETERIIVEXTPROC = o
    extension (v: PFNGLGETTEXTUREPARAMETERIIVEXTPROC)
      inline def value: CFuncPtr4[GLuint, GLenum, GLenum, Ptr[GLint], Unit] = v
      inline def toPtr: Ptr[?] = CFuncPtr.toPtr(v)

  opaque type PFNGLGETTEXTUREPARAMETERIIVPROC = CFuncPtr3[GLuint, GLenum, Ptr[GLint], Unit]
  object PFNGLGETTEXTUREPARAMETERIIVPROC:
    given _tag: Tag[PFNGLGETTEXTUREPARAMETERIIVPROC] = Tag.materializeCFuncPtr3[GLuint, GLenum, Ptr[GLint], Unit]
    inline def fromPtr(ptr: Ptr[Byte] | Ptr[?]): PFNGLGETTEXTUREPARAMETERIIVPROC = CFuncPtr.fromPtr(ptr.asInstanceOf[Ptr[Byte]])
    inline def apply(inline o: CFuncPtr3[GLuint, GLenum, Ptr[GLint], Unit]): PFNGLGETTEXTUREPARAMETERIIVPROC = o
    extension (v: PFNGLGETTEXTUREPARAMETERIIVPROC)
      inline def value: CFuncPtr3[GLuint, GLenum, Ptr[GLint], Unit] = v
      inline def toPtr: Ptr[?] = CFuncPtr.toPtr(v)

  opaque type PFNGLGETTEXTUREPARAMETERIUIVEXTPROC = CFuncPtr4[GLuint, GLenum, GLenum, Ptr[GLuint], Unit]
  object PFNGLGETTEXTUREPARAMETERIUIVEXTPROC:
    given _tag: Tag[PFNGLGETTEXTUREPARAMETERIUIVEXTPROC] = Tag.materializeCFuncPtr4[GLuint, GLenum, GLenum, Ptr[GLuint], Unit]
    inline def fromPtr(ptr: Ptr[Byte] | Ptr[?]): PFNGLGETTEXTUREPARAMETERIUIVEXTPROC = CFuncPtr.fromPtr(ptr.asInstanceOf[Ptr[Byte]])
    inline def apply(inline o: CFuncPtr4[GLuint, GLenum, GLenum, Ptr[GLuint], Unit]): PFNGLGETTEXTUREPARAMETERIUIVEXTPROC = o
    extension (v: PFNGLGETTEXTUREPARAMETERIUIVEXTPROC)
      inline def value: CFuncPtr4[GLuint, GLenum, GLenum, Ptr[GLuint], Unit] = v
      inline def toPtr: Ptr[?] = CFuncPtr.toPtr(v)

  opaque type PFNGLGETTEXTUREPARAMETERIUIVPROC = CFuncPtr3[GLuint, GLenum, Ptr[GLuint], Unit]
  object PFNGLGETTEXTUREPARAMETERIUIVPROC:
    given _tag: Tag[PFNGLGETTEXTUREPARAMETERIUIVPROC] = Tag.materializeCFuncPtr3[GLuint, GLenum, Ptr[GLuint], Unit]
    inline def fromPtr(ptr: Ptr[Byte] | Ptr[?]): PFNGLGETTEXTUREPARAMETERIUIVPROC = CFuncPtr.fromPtr(ptr.asInstanceOf[Ptr[Byte]])
    inline def apply(inline o: CFuncPtr3[GLuint, GLenum, Ptr[GLuint], Unit]): PFNGLGETTEXTUREPARAMETERIUIVPROC = o
    extension (v: PFNGLGETTEXTUREPARAMETERIUIVPROC)
      inline def value: CFuncPtr3[GLuint, GLenum, Ptr[GLuint], Unit] = v
      inline def toPtr: Ptr[?] = CFuncPtr.toPtr(v)

  opaque type PFNGLGETTEXTUREPARAMETERIVEXTPROC = CFuncPtr4[GLuint, GLenum, GLenum, Ptr[GLint], Unit]
  object PFNGLGETTEXTUREPARAMETERIVEXTPROC:
    given _tag: Tag[PFNGLGETTEXTUREPARAMETERIVEXTPROC] = Tag.materializeCFuncPtr4[GLuint, GLenum, GLenum, Ptr[GLint], Unit]
    inline def fromPtr(ptr: Ptr[Byte] | Ptr[?]): PFNGLGETTEXTUREPARAMETERIVEXTPROC = CFuncPtr.fromPtr(ptr.asInstanceOf[Ptr[Byte]])
    inline def apply(inline o: CFuncPtr4[GLuint, GLenum, GLenum, Ptr[GLint], Unit]): PFNGLGETTEXTUREPARAMETERIVEXTPROC = o
    extension (v: PFNGLGETTEXTUREPARAMETERIVEXTPROC)
      inline def value: CFuncPtr4[GLuint, GLenum, GLenum, Ptr[GLint], Unit] = v
      inline def toPtr: Ptr[?] = CFuncPtr.toPtr(v)

  opaque type PFNGLGETTEXTUREPARAMETERIVPROC = CFuncPtr3[GLuint, GLenum, Ptr[GLint], Unit]
  object PFNGLGETTEXTUREPARAMETERIVPROC:
    given _tag: Tag[PFNGLGETTEXTUREPARAMETERIVPROC] = Tag.materializeCFuncPtr3[GLuint, GLenum, Ptr[GLint], Unit]
    inline def fromPtr(ptr: Ptr[Byte] | Ptr[?]): PFNGLGETTEXTUREPARAMETERIVPROC = CFuncPtr.fromPtr(ptr.asInstanceOf[Ptr[Byte]])
    inline def apply(inline o: CFuncPtr3[GLuint, GLenum, Ptr[GLint], Unit]): PFNGLGETTEXTUREPARAMETERIVPROC = o
    extension (v: PFNGLGETTEXTUREPARAMETERIVPROC)
      inline def value: CFuncPtr3[GLuint, GLenum, Ptr[GLint], Unit] = v
      inline def toPtr: Ptr[?] = CFuncPtr.toPtr(v)

  opaque type PFNGLGETTEXTURESAMPLERHANDLEARBPROC = CFuncPtr2[GLuint, GLuint, GLuint64]
  object PFNGLGETTEXTURESAMPLERHANDLEARBPROC:
    given _tag: Tag[PFNGLGETTEXTURESAMPLERHANDLEARBPROC] = Tag.materializeCFuncPtr2[GLuint, GLuint, GLuint64]
    inline def fromPtr(ptr: Ptr[Byte] | Ptr[?]): PFNGLGETTEXTURESAMPLERHANDLEARBPROC = CFuncPtr.fromPtr(ptr.asInstanceOf[Ptr[Byte]])
    inline def apply(inline o: CFuncPtr2[GLuint, GLuint, GLuint64]): PFNGLGETTEXTURESAMPLERHANDLEARBPROC = o
    extension (v: PFNGLGETTEXTURESAMPLERHANDLEARBPROC)
      inline def value: CFuncPtr2[GLuint, GLuint, GLuint64] = v
      inline def toPtr: Ptr[?] = CFuncPtr.toPtr(v)

  opaque type PFNGLGETTEXTURESAMPLERHANDLEIMGPROC = CFuncPtr2[GLuint, GLuint, GLuint64]
  object PFNGLGETTEXTURESAMPLERHANDLEIMGPROC:
    given _tag: Tag[PFNGLGETTEXTURESAMPLERHANDLEIMGPROC] = Tag.materializeCFuncPtr2[GLuint, GLuint, GLuint64]
    inline def fromPtr(ptr: Ptr[Byte] | Ptr[?]): PFNGLGETTEXTURESAMPLERHANDLEIMGPROC = CFuncPtr.fromPtr(ptr.asInstanceOf[Ptr[Byte]])
    inline def apply(inline o: CFuncPtr2[GLuint, GLuint, GLuint64]): PFNGLGETTEXTURESAMPLERHANDLEIMGPROC = o
    extension (v: PFNGLGETTEXTURESAMPLERHANDLEIMGPROC)
      inline def value: CFuncPtr2[GLuint, GLuint, GLuint64] = v
      inline def toPtr: Ptr[?] = CFuncPtr.toPtr(v)

  opaque type PFNGLGETTEXTURESAMPLERHANDLENVPROC = CFuncPtr2[GLuint, GLuint, GLuint64]
  object PFNGLGETTEXTURESAMPLERHANDLENVPROC:
    given _tag: Tag[PFNGLGETTEXTURESAMPLERHANDLENVPROC] = Tag.materializeCFuncPtr2[GLuint, GLuint, GLuint64]
    inline def fromPtr(ptr: Ptr[Byte] | Ptr[?]): PFNGLGETTEXTURESAMPLERHANDLENVPROC = CFuncPtr.fromPtr(ptr.asInstanceOf[Ptr[Byte]])
    inline def apply(inline o: CFuncPtr2[GLuint, GLuint, GLuint64]): PFNGLGETTEXTURESAMPLERHANDLENVPROC = o
    extension (v: PFNGLGETTEXTURESAMPLERHANDLENVPROC)
      inline def value: CFuncPtr2[GLuint, GLuint, GLuint64] = v
      inline def toPtr: Ptr[?] = CFuncPtr.toPtr(v)

  opaque type PFNGLGETTEXTURESUBIMAGEPROC = CFuncPtr12[GLuint, GLint, GLint, GLint, GLint, GLsizei, GLsizei, GLsizei, GLenum, GLenum, GLsizei, Ptr[Byte], Unit]
  object PFNGLGETTEXTURESUBIMAGEPROC:
    given _tag: Tag[PFNGLGETTEXTURESUBIMAGEPROC] = Tag.materializeCFuncPtr12[GLuint, GLint, GLint, GLint, GLint, GLsizei, GLsizei, GLsizei, GLenum, GLenum, GLsizei, Ptr[Byte], Unit]
    inline def fromPtr(ptr: Ptr[Byte] | Ptr[?]): PFNGLGETTEXTURESUBIMAGEPROC = CFuncPtr.fromPtr(ptr.asInstanceOf[Ptr[Byte]])
    inline def apply(inline o: CFuncPtr12[GLuint, GLint, GLint, GLint, GLint, GLsizei, GLsizei, GLsizei, GLenum, GLenum, GLsizei, Ptr[Byte], Unit]): PFNGLGETTEXTURESUBIMAGEPROC = o
    extension (v: PFNGLGETTEXTURESUBIMAGEPROC)
      inline def value: CFuncPtr12[GLuint, GLint, GLint, GLint, GLint, GLsizei, GLsizei, GLsizei, GLenum, GLenum, GLsizei, Ptr[Byte], Unit] = v
      inline def toPtr: Ptr[?] = CFuncPtr.toPtr(v)

  opaque type PFNGLGETTRACKMATRIXIVNVPROC = CFuncPtr4[GLenum, GLuint, GLenum, Ptr[GLint], Unit]
  object PFNGLGETTRACKMATRIXIVNVPROC:
    given _tag: Tag[PFNGLGETTRACKMATRIXIVNVPROC] = Tag.materializeCFuncPtr4[GLenum, GLuint, GLenum, Ptr[GLint], Unit]
    inline def fromPtr(ptr: Ptr[Byte] | Ptr[?]): PFNGLGETTRACKMATRIXIVNVPROC = CFuncPtr.fromPtr(ptr.asInstanceOf[Ptr[Byte]])
    inline def apply(inline o: CFuncPtr4[GLenum, GLuint, GLenum, Ptr[GLint], Unit]): PFNGLGETTRACKMATRIXIVNVPROC = o
    extension (v: PFNGLGETTRACKMATRIXIVNVPROC)
      inline def value: CFuncPtr4[GLenum, GLuint, GLenum, Ptr[GLint], Unit] = v
      inline def toPtr: Ptr[?] = CFuncPtr.toPtr(v)

  opaque type PFNGLGETTRANSFORMFEEDBACKI64_VPROC = CFuncPtr4[GLuint, GLenum, GLuint, Ptr[GLint64], Unit]
  object PFNGLGETTRANSFORMFEEDBACKI64_VPROC:
    given _tag: Tag[PFNGLGETTRANSFORMFEEDBACKI64_VPROC] = Tag.materializeCFuncPtr4[GLuint, GLenum, GLuint, Ptr[GLint64], Unit]
    inline def fromPtr(ptr: Ptr[Byte] | Ptr[?]): PFNGLGETTRANSFORMFEEDBACKI64_VPROC = CFuncPtr.fromPtr(ptr.asInstanceOf[Ptr[Byte]])
    inline def apply(inline o: CFuncPtr4[GLuint, GLenum, GLuint, Ptr[GLint64], Unit]): PFNGLGETTRANSFORMFEEDBACKI64_VPROC = o
    extension (v: PFNGLGETTRANSFORMFEEDBACKI64_VPROC)
      inline def value: CFuncPtr4[GLuint, GLenum, GLuint, Ptr[GLint64], Unit] = v
      inline def toPtr: Ptr[?] = CFuncPtr.toPtr(v)

  opaque type PFNGLGETTRANSFORMFEEDBACKIVPROC = CFuncPtr3[GLuint, GLenum, Ptr[GLint], Unit]
  object PFNGLGETTRANSFORMFEEDBACKIVPROC:
    given _tag: Tag[PFNGLGETTRANSFORMFEEDBACKIVPROC] = Tag.materializeCFuncPtr3[GLuint, GLenum, Ptr[GLint], Unit]
    inline def fromPtr(ptr: Ptr[Byte] | Ptr[?]): PFNGLGETTRANSFORMFEEDBACKIVPROC = CFuncPtr.fromPtr(ptr.asInstanceOf[Ptr[Byte]])
    inline def apply(inline o: CFuncPtr3[GLuint, GLenum, Ptr[GLint], Unit]): PFNGLGETTRANSFORMFEEDBACKIVPROC = o
    extension (v: PFNGLGETTRANSFORMFEEDBACKIVPROC)
      inline def value: CFuncPtr3[GLuint, GLenum, Ptr[GLint], Unit] = v
      inline def toPtr: Ptr[?] = CFuncPtr.toPtr(v)

  opaque type PFNGLGETTRANSFORMFEEDBACKI_VPROC = CFuncPtr4[GLuint, GLenum, GLuint, Ptr[GLint], Unit]
  object PFNGLGETTRANSFORMFEEDBACKI_VPROC:
    given _tag: Tag[PFNGLGETTRANSFORMFEEDBACKI_VPROC] = Tag.materializeCFuncPtr4[GLuint, GLenum, GLuint, Ptr[GLint], Unit]
    inline def fromPtr(ptr: Ptr[Byte] | Ptr[?]): PFNGLGETTRANSFORMFEEDBACKI_VPROC = CFuncPtr.fromPtr(ptr.asInstanceOf[Ptr[Byte]])
    inline def apply(inline o: CFuncPtr4[GLuint, GLenum, GLuint, Ptr[GLint], Unit]): PFNGLGETTRANSFORMFEEDBACKI_VPROC = o
    extension (v: PFNGLGETTRANSFORMFEEDBACKI_VPROC)
      inline def value: CFuncPtr4[GLuint, GLenum, GLuint, Ptr[GLint], Unit] = v
      inline def toPtr: Ptr[?] = CFuncPtr.toPtr(v)

  opaque type PFNGLGETTRANSFORMFEEDBACKVARYINGEXTPROC = CFuncPtr7[GLuint, GLuint, GLsizei, Ptr[GLsizei], Ptr[GLsizei], Ptr[GLenum], Ptr[GLchar], Unit]
  object PFNGLGETTRANSFORMFEEDBACKVARYINGEXTPROC:
    given _tag: Tag[PFNGLGETTRANSFORMFEEDBACKVARYINGEXTPROC] = Tag.materializeCFuncPtr7[GLuint, GLuint, GLsizei, Ptr[GLsizei], Ptr[GLsizei], Ptr[GLenum], Ptr[GLchar], Unit]
    inline def fromPtr(ptr: Ptr[Byte] | Ptr[?]): PFNGLGETTRANSFORMFEEDBACKVARYINGEXTPROC = CFuncPtr.fromPtr(ptr.asInstanceOf[Ptr[Byte]])
    inline def apply(inline o: CFuncPtr7[GLuint, GLuint, GLsizei, Ptr[GLsizei], Ptr[GLsizei], Ptr[GLenum], Ptr[GLchar], Unit]): PFNGLGETTRANSFORMFEEDBACKVARYINGEXTPROC = o
    extension (v: PFNGLGETTRANSFORMFEEDBACKVARYINGEXTPROC)
      inline def value: CFuncPtr7[GLuint, GLuint, GLsizei, Ptr[GLsizei], Ptr[GLsizei], Ptr[GLenum], Ptr[GLchar], Unit] = v
      inline def toPtr: Ptr[?] = CFuncPtr.toPtr(v)

  opaque type PFNGLGETTRANSFORMFEEDBACKVARYINGNVPROC = CFuncPtr3[GLuint, GLuint, Ptr[GLint], Unit]
  object PFNGLGETTRANSFORMFEEDBACKVARYINGNVPROC:
    given _tag: Tag[PFNGLGETTRANSFORMFEEDBACKVARYINGNVPROC] = Tag.materializeCFuncPtr3[GLuint, GLuint, Ptr[GLint], Unit]
    inline def fromPtr(ptr: Ptr[Byte] | Ptr[?]): PFNGLGETTRANSFORMFEEDBACKVARYINGNVPROC = CFuncPtr.fromPtr(ptr.asInstanceOf[Ptr[Byte]])
    inline def apply(inline o: CFuncPtr3[GLuint, GLuint, Ptr[GLint], Unit]): PFNGLGETTRANSFORMFEEDBACKVARYINGNVPROC = o
    extension (v: PFNGLGETTRANSFORMFEEDBACKVARYINGNVPROC)
      inline def value: CFuncPtr3[GLuint, GLuint, Ptr[GLint], Unit] = v
      inline def toPtr: Ptr[?] = CFuncPtr.toPtr(v)

  opaque type PFNGLGETTRANSFORMFEEDBACKVARYINGPROC = CFuncPtr7[GLuint, GLuint, GLsizei, Ptr[GLsizei], Ptr[GLsizei], Ptr[GLenum], Ptr[GLchar], Unit]
  object PFNGLGETTRANSFORMFEEDBACKVARYINGPROC:
    given _tag: Tag[PFNGLGETTRANSFORMFEEDBACKVARYINGPROC] = Tag.materializeCFuncPtr7[GLuint, GLuint, GLsizei, Ptr[GLsizei], Ptr[GLsizei], Ptr[GLenum], Ptr[GLchar], Unit]
    inline def fromPtr(ptr: Ptr[Byte] | Ptr[?]): PFNGLGETTRANSFORMFEEDBACKVARYINGPROC = CFuncPtr.fromPtr(ptr.asInstanceOf[Ptr[Byte]])
    inline def apply(inline o: CFuncPtr7[GLuint, GLuint, GLsizei, Ptr[GLsizei], Ptr[GLsizei], Ptr[GLenum], Ptr[GLchar], Unit]): PFNGLGETTRANSFORMFEEDBACKVARYINGPROC = o
    extension (v: PFNGLGETTRANSFORMFEEDBACKVARYINGPROC)
      inline def value: CFuncPtr7[GLuint, GLuint, GLsizei, Ptr[GLsizei], Ptr[GLsizei], Ptr[GLenum], Ptr[GLchar], Unit] = v
      inline def toPtr: Ptr[?] = CFuncPtr.toPtr(v)

  opaque type PFNGLGETTRANSLATEDSHADERSOURCEANGLEPROC = CFuncPtr4[GLuint, GLsizei, Ptr[GLsizei], Ptr[GLchar], Unit]
  object PFNGLGETTRANSLATEDSHADERSOURCEANGLEPROC:
    given _tag: Tag[PFNGLGETTRANSLATEDSHADERSOURCEANGLEPROC] = Tag.materializeCFuncPtr4[GLuint, GLsizei, Ptr[GLsizei], Ptr[GLchar], Unit]
    inline def fromPtr(ptr: Ptr[Byte] | Ptr[?]): PFNGLGETTRANSLATEDSHADERSOURCEANGLEPROC = CFuncPtr.fromPtr(ptr.asInstanceOf[Ptr[Byte]])
    inline def apply(inline o: CFuncPtr4[GLuint, GLsizei, Ptr[GLsizei], Ptr[GLchar], Unit]): PFNGLGETTRANSLATEDSHADERSOURCEANGLEPROC = o
    extension (v: PFNGLGETTRANSLATEDSHADERSOURCEANGLEPROC)
      inline def value: CFuncPtr4[GLuint, GLsizei, Ptr[GLsizei], Ptr[GLchar], Unit] = v
      inline def toPtr: Ptr[?] = CFuncPtr.toPtr(v)

  opaque type PFNGLGETUNIFORMBLOCKINDEXPROC = CFuncPtr2[GLuint, Ptr[GLchar], GLuint]
  object PFNGLGETUNIFORMBLOCKINDEXPROC:
    given _tag: Tag[PFNGLGETUNIFORMBLOCKINDEXPROC] = Tag.materializeCFuncPtr2[GLuint, Ptr[GLchar], GLuint]
    inline def fromPtr(ptr: Ptr[Byte] | Ptr[?]): PFNGLGETUNIFORMBLOCKINDEXPROC = CFuncPtr.fromPtr(ptr.asInstanceOf[Ptr[Byte]])
    inline def apply(inline o: CFuncPtr2[GLuint, Ptr[GLchar], GLuint]): PFNGLGETUNIFORMBLOCKINDEXPROC = o
    extension (v: PFNGLGETUNIFORMBLOCKINDEXPROC)
      inline def value: CFuncPtr2[GLuint, Ptr[GLchar], GLuint] = v
      inline def toPtr: Ptr[?] = CFuncPtr.toPtr(v)

  opaque type PFNGLGETUNIFORMBUFFERSIZEEXTPROC = CFuncPtr2[GLuint, GLint, GLint]
  object PFNGLGETUNIFORMBUFFERSIZEEXTPROC:
    given _tag: Tag[PFNGLGETUNIFORMBUFFERSIZEEXTPROC] = Tag.materializeCFuncPtr2[GLuint, GLint, GLint]
    inline def fromPtr(ptr: Ptr[Byte] | Ptr[?]): PFNGLGETUNIFORMBUFFERSIZEEXTPROC = CFuncPtr.fromPtr(ptr.asInstanceOf[Ptr[Byte]])
    inline def apply(inline o: CFuncPtr2[GLuint, GLint, GLint]): PFNGLGETUNIFORMBUFFERSIZEEXTPROC = o
    extension (v: PFNGLGETUNIFORMBUFFERSIZEEXTPROC)
      inline def value: CFuncPtr2[GLuint, GLint, GLint] = v
      inline def toPtr: Ptr[?] = CFuncPtr.toPtr(v)

  opaque type PFNGLGETUNIFORMDVPROC = CFuncPtr3[GLuint, GLint, Ptr[GLdouble], Unit]
  object PFNGLGETUNIFORMDVPROC:
    given _tag: Tag[PFNGLGETUNIFORMDVPROC] = Tag.materializeCFuncPtr3[GLuint, GLint, Ptr[GLdouble], Unit]
    inline def fromPtr(ptr: Ptr[Byte] | Ptr[?]): PFNGLGETUNIFORMDVPROC = CFuncPtr.fromPtr(ptr.asInstanceOf[Ptr[Byte]])
    inline def apply(inline o: CFuncPtr3[GLuint, GLint, Ptr[GLdouble], Unit]): PFNGLGETUNIFORMDVPROC = o
    extension (v: PFNGLGETUNIFORMDVPROC)
      inline def value: CFuncPtr3[GLuint, GLint, Ptr[GLdouble], Unit] = v
      inline def toPtr: Ptr[?] = CFuncPtr.toPtr(v)

  opaque type PFNGLGETUNIFORMFVARBPROC = CFuncPtr3[GLhandleARB, GLint, Ptr[GLfloat], Unit]
  object PFNGLGETUNIFORMFVARBPROC:
    given _tag: Tag[PFNGLGETUNIFORMFVARBPROC] = Tag.materializeCFuncPtr3[GLhandleARB, GLint, Ptr[GLfloat], Unit]
    inline def fromPtr(ptr: Ptr[Byte] | Ptr[?]): PFNGLGETUNIFORMFVARBPROC = CFuncPtr.fromPtr(ptr.asInstanceOf[Ptr[Byte]])
    inline def apply(inline o: CFuncPtr3[GLhandleARB, GLint, Ptr[GLfloat], Unit]): PFNGLGETUNIFORMFVARBPROC = o
    extension (v: PFNGLGETUNIFORMFVARBPROC)
      inline def value: CFuncPtr3[GLhandleARB, GLint, Ptr[GLfloat], Unit] = v
      inline def toPtr: Ptr[?] = CFuncPtr.toPtr(v)

  opaque type PFNGLGETUNIFORMFVPROC = CFuncPtr3[GLuint, GLint, Ptr[GLfloat], Unit]
  object PFNGLGETUNIFORMFVPROC:
    given _tag: Tag[PFNGLGETUNIFORMFVPROC] = Tag.materializeCFuncPtr3[GLuint, GLint, Ptr[GLfloat], Unit]
    inline def fromPtr(ptr: Ptr[Byte] | Ptr[?]): PFNGLGETUNIFORMFVPROC = CFuncPtr.fromPtr(ptr.asInstanceOf[Ptr[Byte]])
    inline def apply(inline o: CFuncPtr3[GLuint, GLint, Ptr[GLfloat], Unit]): PFNGLGETUNIFORMFVPROC = o
    extension (v: PFNGLGETUNIFORMFVPROC)
      inline def value: CFuncPtr3[GLuint, GLint, Ptr[GLfloat], Unit] = v
      inline def toPtr: Ptr[?] = CFuncPtr.toPtr(v)

  opaque type PFNGLGETUNIFORMI64VARBPROC = CFuncPtr3[GLuint, GLint, Ptr[GLint64], Unit]
  object PFNGLGETUNIFORMI64VARBPROC:
    given _tag: Tag[PFNGLGETUNIFORMI64VARBPROC] = Tag.materializeCFuncPtr3[GLuint, GLint, Ptr[GLint64], Unit]
    inline def fromPtr(ptr: Ptr[Byte] | Ptr[?]): PFNGLGETUNIFORMI64VARBPROC = CFuncPtr.fromPtr(ptr.asInstanceOf[Ptr[Byte]])
    inline def apply(inline o: CFuncPtr3[GLuint, GLint, Ptr[GLint64], Unit]): PFNGLGETUNIFORMI64VARBPROC = o
    extension (v: PFNGLGETUNIFORMI64VARBPROC)
      inline def value: CFuncPtr3[GLuint, GLint, Ptr[GLint64], Unit] = v
      inline def toPtr: Ptr[?] = CFuncPtr.toPtr(v)

  opaque type PFNGLGETUNIFORMI64VNVPROC = CFuncPtr3[GLuint, GLint, Ptr[GLint64EXT], Unit]
  object PFNGLGETUNIFORMI64VNVPROC:
    given _tag: Tag[PFNGLGETUNIFORMI64VNVPROC] = Tag.materializeCFuncPtr3[GLuint, GLint, Ptr[GLint64EXT], Unit]
    inline def fromPtr(ptr: Ptr[Byte] | Ptr[?]): PFNGLGETUNIFORMI64VNVPROC = CFuncPtr.fromPtr(ptr.asInstanceOf[Ptr[Byte]])
    inline def apply(inline o: CFuncPtr3[GLuint, GLint, Ptr[GLint64EXT], Unit]): PFNGLGETUNIFORMI64VNVPROC = o
    extension (v: PFNGLGETUNIFORMI64VNVPROC)
      inline def value: CFuncPtr3[GLuint, GLint, Ptr[GLint64EXT], Unit] = v
      inline def toPtr: Ptr[?] = CFuncPtr.toPtr(v)

  opaque type PFNGLGETUNIFORMINDICESPROC = CFuncPtr4[GLuint, GLsizei, Ptr[Ptr[GLchar]], Ptr[GLuint], Unit]
  object PFNGLGETUNIFORMINDICESPROC:
    given _tag: Tag[PFNGLGETUNIFORMINDICESPROC] = Tag.materializeCFuncPtr4[GLuint, GLsizei, Ptr[Ptr[GLchar]], Ptr[GLuint], Unit]
    inline def fromPtr(ptr: Ptr[Byte] | Ptr[?]): PFNGLGETUNIFORMINDICESPROC = CFuncPtr.fromPtr(ptr.asInstanceOf[Ptr[Byte]])
    inline def apply(inline o: CFuncPtr4[GLuint, GLsizei, Ptr[Ptr[GLchar]], Ptr[GLuint], Unit]): PFNGLGETUNIFORMINDICESPROC = o
    extension (v: PFNGLGETUNIFORMINDICESPROC)
      inline def value: CFuncPtr4[GLuint, GLsizei, Ptr[Ptr[GLchar]], Ptr[GLuint], Unit] = v
      inline def toPtr: Ptr[?] = CFuncPtr.toPtr(v)

  opaque type PFNGLGETUNIFORMIVARBPROC = CFuncPtr3[GLhandleARB, GLint, Ptr[GLint], Unit]
  object PFNGLGETUNIFORMIVARBPROC:
    given _tag: Tag[PFNGLGETUNIFORMIVARBPROC] = Tag.materializeCFuncPtr3[GLhandleARB, GLint, Ptr[GLint], Unit]
    inline def fromPtr(ptr: Ptr[Byte] | Ptr[?]): PFNGLGETUNIFORMIVARBPROC = CFuncPtr.fromPtr(ptr.asInstanceOf[Ptr[Byte]])
    inline def apply(inline o: CFuncPtr3[GLhandleARB, GLint, Ptr[GLint], Unit]): PFNGLGETUNIFORMIVARBPROC = o
    extension (v: PFNGLGETUNIFORMIVARBPROC)
      inline def value: CFuncPtr3[GLhandleARB, GLint, Ptr[GLint], Unit] = v
      inline def toPtr: Ptr[?] = CFuncPtr.toPtr(v)

  opaque type PFNGLGETUNIFORMIVPROC = CFuncPtr3[GLuint, GLint, Ptr[GLint], Unit]
  object PFNGLGETUNIFORMIVPROC:
    given _tag: Tag[PFNGLGETUNIFORMIVPROC] = Tag.materializeCFuncPtr3[GLuint, GLint, Ptr[GLint], Unit]
    inline def fromPtr(ptr: Ptr[Byte] | Ptr[?]): PFNGLGETUNIFORMIVPROC = CFuncPtr.fromPtr(ptr.asInstanceOf[Ptr[Byte]])
    inline def apply(inline o: CFuncPtr3[GLuint, GLint, Ptr[GLint], Unit]): PFNGLGETUNIFORMIVPROC = o
    extension (v: PFNGLGETUNIFORMIVPROC)
      inline def value: CFuncPtr3[GLuint, GLint, Ptr[GLint], Unit] = v
      inline def toPtr: Ptr[?] = CFuncPtr.toPtr(v)

  opaque type PFNGLGETUNIFORMLOCATIONARBPROC = CFuncPtr2[GLhandleARB, Ptr[GLcharARB], GLint]
  object PFNGLGETUNIFORMLOCATIONARBPROC:
    given _tag: Tag[PFNGLGETUNIFORMLOCATIONARBPROC] = Tag.materializeCFuncPtr2[GLhandleARB, Ptr[GLcharARB], GLint]
    inline def fromPtr(ptr: Ptr[Byte] | Ptr[?]): PFNGLGETUNIFORMLOCATIONARBPROC = CFuncPtr.fromPtr(ptr.asInstanceOf[Ptr[Byte]])
    inline def apply(inline o: CFuncPtr2[GLhandleARB, Ptr[GLcharARB], GLint]): PFNGLGETUNIFORMLOCATIONARBPROC = o
    extension (v: PFNGLGETUNIFORMLOCATIONARBPROC)
      inline def value: CFuncPtr2[GLhandleARB, Ptr[GLcharARB], GLint] = v
      inline def toPtr: Ptr[?] = CFuncPtr.toPtr(v)

  opaque type PFNGLGETUNIFORMLOCATIONPROC = CFuncPtr2[GLuint, Ptr[GLchar], GLint]
  object PFNGLGETUNIFORMLOCATIONPROC:
    given _tag: Tag[PFNGLGETUNIFORMLOCATIONPROC] = Tag.materializeCFuncPtr2[GLuint, Ptr[GLchar], GLint]
    inline def fromPtr(ptr: Ptr[Byte] | Ptr[?]): PFNGLGETUNIFORMLOCATIONPROC = CFuncPtr.fromPtr(ptr.asInstanceOf[Ptr[Byte]])
    inline def apply(inline o: CFuncPtr2[GLuint, Ptr[GLchar], GLint]): PFNGLGETUNIFORMLOCATIONPROC = o
    extension (v: PFNGLGETUNIFORMLOCATIONPROC)
      inline def value: CFuncPtr2[GLuint, Ptr[GLchar], GLint] = v
      inline def toPtr: Ptr[?] = CFuncPtr.toPtr(v)

  opaque type PFNGLGETUNIFORMOFFSETEXTPROC = CFuncPtr2[GLuint, GLint, GLintptr]
  object PFNGLGETUNIFORMOFFSETEXTPROC:
    given _tag: Tag[PFNGLGETUNIFORMOFFSETEXTPROC] = Tag.materializeCFuncPtr2[GLuint, GLint, GLintptr]
    inline def fromPtr(ptr: Ptr[Byte] | Ptr[?]): PFNGLGETUNIFORMOFFSETEXTPROC = CFuncPtr.fromPtr(ptr.asInstanceOf[Ptr[Byte]])
    inline def apply(inline o: CFuncPtr2[GLuint, GLint, GLintptr]): PFNGLGETUNIFORMOFFSETEXTPROC = o
    extension (v: PFNGLGETUNIFORMOFFSETEXTPROC)
      inline def value: CFuncPtr2[GLuint, GLint, GLintptr] = v
      inline def toPtr: Ptr[?] = CFuncPtr.toPtr(v)

  opaque type PFNGLGETUNIFORMSUBROUTINEUIVPROC = CFuncPtr3[GLenum, GLint, Ptr[GLuint], Unit]
  object PFNGLGETUNIFORMSUBROUTINEUIVPROC:
    given _tag: Tag[PFNGLGETUNIFORMSUBROUTINEUIVPROC] = Tag.materializeCFuncPtr3[GLenum, GLint, Ptr[GLuint], Unit]
    inline def fromPtr(ptr: Ptr[Byte] | Ptr[?]): PFNGLGETUNIFORMSUBROUTINEUIVPROC = CFuncPtr.fromPtr(ptr.asInstanceOf[Ptr[Byte]])
    inline def apply(inline o: CFuncPtr3[GLenum, GLint, Ptr[GLuint], Unit]): PFNGLGETUNIFORMSUBROUTINEUIVPROC = o
    extension (v: PFNGLGETUNIFORMSUBROUTINEUIVPROC)
      inline def value: CFuncPtr3[GLenum, GLint, Ptr[GLuint], Unit] = v
      inline def toPtr: Ptr[?] = CFuncPtr.toPtr(v)

  opaque type PFNGLGETUNIFORMUI64VARBPROC = CFuncPtr3[GLuint, GLint, Ptr[GLuint64], Unit]
  object PFNGLGETUNIFORMUI64VARBPROC:
    given _tag: Tag[PFNGLGETUNIFORMUI64VARBPROC] = Tag.materializeCFuncPtr3[GLuint, GLint, Ptr[GLuint64], Unit]
    inline def fromPtr(ptr: Ptr[Byte] | Ptr[?]): PFNGLGETUNIFORMUI64VARBPROC = CFuncPtr.fromPtr(ptr.asInstanceOf[Ptr[Byte]])
    inline def apply(inline o: CFuncPtr3[GLuint, GLint, Ptr[GLuint64], Unit]): PFNGLGETUNIFORMUI64VARBPROC = o
    extension (v: PFNGLGETUNIFORMUI64VARBPROC)
      inline def value: CFuncPtr3[GLuint, GLint, Ptr[GLuint64], Unit] = v
      inline def toPtr: Ptr[?] = CFuncPtr.toPtr(v)

  opaque type PFNGLGETUNIFORMUI64VNVPROC = CFuncPtr3[GLuint, GLint, Ptr[GLuint64EXT], Unit]
  object PFNGLGETUNIFORMUI64VNVPROC:
    given _tag: Tag[PFNGLGETUNIFORMUI64VNVPROC] = Tag.materializeCFuncPtr3[GLuint, GLint, Ptr[GLuint64EXT], Unit]
    inline def fromPtr(ptr: Ptr[Byte] | Ptr[?]): PFNGLGETUNIFORMUI64VNVPROC = CFuncPtr.fromPtr(ptr.asInstanceOf[Ptr[Byte]])
    inline def apply(inline o: CFuncPtr3[GLuint, GLint, Ptr[GLuint64EXT], Unit]): PFNGLGETUNIFORMUI64VNVPROC = o
    extension (v: PFNGLGETUNIFORMUI64VNVPROC)
      inline def value: CFuncPtr3[GLuint, GLint, Ptr[GLuint64EXT], Unit] = v
      inline def toPtr: Ptr[?] = CFuncPtr.toPtr(v)

  opaque type PFNGLGETUNIFORMUIVEXTPROC = CFuncPtr3[GLuint, GLint, Ptr[GLuint], Unit]
  object PFNGLGETUNIFORMUIVEXTPROC:
    given _tag: Tag[PFNGLGETUNIFORMUIVEXTPROC] = Tag.materializeCFuncPtr3[GLuint, GLint, Ptr[GLuint], Unit]
    inline def fromPtr(ptr: Ptr[Byte] | Ptr[?]): PFNGLGETUNIFORMUIVEXTPROC = CFuncPtr.fromPtr(ptr.asInstanceOf[Ptr[Byte]])
    inline def apply(inline o: CFuncPtr3[GLuint, GLint, Ptr[GLuint], Unit]): PFNGLGETUNIFORMUIVEXTPROC = o
    extension (v: PFNGLGETUNIFORMUIVEXTPROC)
      inline def value: CFuncPtr3[GLuint, GLint, Ptr[GLuint], Unit] = v
      inline def toPtr: Ptr[?] = CFuncPtr.toPtr(v)

  opaque type PFNGLGETUNIFORMUIVPROC = CFuncPtr3[GLuint, GLint, Ptr[GLuint], Unit]
  object PFNGLGETUNIFORMUIVPROC:
    given _tag: Tag[PFNGLGETUNIFORMUIVPROC] = Tag.materializeCFuncPtr3[GLuint, GLint, Ptr[GLuint], Unit]
    inline def fromPtr(ptr: Ptr[Byte] | Ptr[?]): PFNGLGETUNIFORMUIVPROC = CFuncPtr.fromPtr(ptr.asInstanceOf[Ptr[Byte]])
    inline def apply(inline o: CFuncPtr3[GLuint, GLint, Ptr[GLuint], Unit]): PFNGLGETUNIFORMUIVPROC = o
    extension (v: PFNGLGETUNIFORMUIVPROC)
      inline def value: CFuncPtr3[GLuint, GLint, Ptr[GLuint], Unit] = v
      inline def toPtr: Ptr[?] = CFuncPtr.toPtr(v)

  opaque type PFNGLGETUNSIGNEDBYTEI_VEXTPROC = CFuncPtr3[GLenum, GLuint, Ptr[GLubyte], Unit]
  object PFNGLGETUNSIGNEDBYTEI_VEXTPROC:
    given _tag: Tag[PFNGLGETUNSIGNEDBYTEI_VEXTPROC] = Tag.materializeCFuncPtr3[GLenum, GLuint, Ptr[GLubyte], Unit]
    inline def fromPtr(ptr: Ptr[Byte] | Ptr[?]): PFNGLGETUNSIGNEDBYTEI_VEXTPROC = CFuncPtr.fromPtr(ptr.asInstanceOf[Ptr[Byte]])
    inline def apply(inline o: CFuncPtr3[GLenum, GLuint, Ptr[GLubyte], Unit]): PFNGLGETUNSIGNEDBYTEI_VEXTPROC = o
    extension (v: PFNGLGETUNSIGNEDBYTEI_VEXTPROC)
      inline def value: CFuncPtr3[GLenum, GLuint, Ptr[GLubyte], Unit] = v
      inline def toPtr: Ptr[?] = CFuncPtr.toPtr(v)

  opaque type PFNGLGETUNSIGNEDBYTEVEXTPROC = CFuncPtr2[GLenum, Ptr[GLubyte], Unit]
  object PFNGLGETUNSIGNEDBYTEVEXTPROC:
    given _tag: Tag[PFNGLGETUNSIGNEDBYTEVEXTPROC] = Tag.materializeCFuncPtr2[GLenum, Ptr[GLubyte], Unit]
    inline def fromPtr(ptr: Ptr[Byte] | Ptr[?]): PFNGLGETUNSIGNEDBYTEVEXTPROC = CFuncPtr.fromPtr(ptr.asInstanceOf[Ptr[Byte]])
    inline def apply(inline o: CFuncPtr2[GLenum, Ptr[GLubyte], Unit]): PFNGLGETUNSIGNEDBYTEVEXTPROC = o
    extension (v: PFNGLGETUNSIGNEDBYTEVEXTPROC)
      inline def value: CFuncPtr2[GLenum, Ptr[GLubyte], Unit] = v
      inline def toPtr: Ptr[?] = CFuncPtr.toPtr(v)

  opaque type PFNGLGETVARIANTARRAYOBJECTFVATIPROC = CFuncPtr3[GLuint, GLenum, Ptr[GLfloat], Unit]
  object PFNGLGETVARIANTARRAYOBJECTFVATIPROC:
    given _tag: Tag[PFNGLGETVARIANTARRAYOBJECTFVATIPROC] = Tag.materializeCFuncPtr3[GLuint, GLenum, Ptr[GLfloat], Unit]
    inline def fromPtr(ptr: Ptr[Byte] | Ptr[?]): PFNGLGETVARIANTARRAYOBJECTFVATIPROC = CFuncPtr.fromPtr(ptr.asInstanceOf[Ptr[Byte]])
    inline def apply(inline o: CFuncPtr3[GLuint, GLenum, Ptr[GLfloat], Unit]): PFNGLGETVARIANTARRAYOBJECTFVATIPROC = o
    extension (v: PFNGLGETVARIANTARRAYOBJECTFVATIPROC)
      inline def value: CFuncPtr3[GLuint, GLenum, Ptr[GLfloat], Unit] = v
      inline def toPtr: Ptr[?] = CFuncPtr.toPtr(v)

  opaque type PFNGLGETVARIANTARRAYOBJECTIVATIPROC = CFuncPtr3[GLuint, GLenum, Ptr[GLint], Unit]
  object PFNGLGETVARIANTARRAYOBJECTIVATIPROC:
    given _tag: Tag[PFNGLGETVARIANTARRAYOBJECTIVATIPROC] = Tag.materializeCFuncPtr3[GLuint, GLenum, Ptr[GLint], Unit]
    inline def fromPtr(ptr: Ptr[Byte] | Ptr[?]): PFNGLGETVARIANTARRAYOBJECTIVATIPROC = CFuncPtr.fromPtr(ptr.asInstanceOf[Ptr[Byte]])
    inline def apply(inline o: CFuncPtr3[GLuint, GLenum, Ptr[GLint], Unit]): PFNGLGETVARIANTARRAYOBJECTIVATIPROC = o
    extension (v: PFNGLGETVARIANTARRAYOBJECTIVATIPROC)
      inline def value: CFuncPtr3[GLuint, GLenum, Ptr[GLint], Unit] = v
      inline def toPtr: Ptr[?] = CFuncPtr.toPtr(v)

  opaque type PFNGLGETVARIANTBOOLEANVEXTPROC = CFuncPtr3[GLuint, GLenum, Ptr[GLboolean], Unit]
  object PFNGLGETVARIANTBOOLEANVEXTPROC:
    given _tag: Tag[PFNGLGETVARIANTBOOLEANVEXTPROC] = Tag.materializeCFuncPtr3[GLuint, GLenum, Ptr[GLboolean], Unit]
    inline def fromPtr(ptr: Ptr[Byte] | Ptr[?]): PFNGLGETVARIANTBOOLEANVEXTPROC = CFuncPtr.fromPtr(ptr.asInstanceOf[Ptr[Byte]])
    inline def apply(inline o: CFuncPtr3[GLuint, GLenum, Ptr[GLboolean], Unit]): PFNGLGETVARIANTBOOLEANVEXTPROC = o
    extension (v: PFNGLGETVARIANTBOOLEANVEXTPROC)
      inline def value: CFuncPtr3[GLuint, GLenum, Ptr[GLboolean], Unit] = v
      inline def toPtr: Ptr[?] = CFuncPtr.toPtr(v)

  opaque type PFNGLGETVARIANTFLOATVEXTPROC = CFuncPtr3[GLuint, GLenum, Ptr[GLfloat], Unit]
  object PFNGLGETVARIANTFLOATVEXTPROC:
    given _tag: Tag[PFNGLGETVARIANTFLOATVEXTPROC] = Tag.materializeCFuncPtr3[GLuint, GLenum, Ptr[GLfloat], Unit]
    inline def fromPtr(ptr: Ptr[Byte] | Ptr[?]): PFNGLGETVARIANTFLOATVEXTPROC = CFuncPtr.fromPtr(ptr.asInstanceOf[Ptr[Byte]])
    inline def apply(inline o: CFuncPtr3[GLuint, GLenum, Ptr[GLfloat], Unit]): PFNGLGETVARIANTFLOATVEXTPROC = o
    extension (v: PFNGLGETVARIANTFLOATVEXTPROC)
      inline def value: CFuncPtr3[GLuint, GLenum, Ptr[GLfloat], Unit] = v
      inline def toPtr: Ptr[?] = CFuncPtr.toPtr(v)

  opaque type PFNGLGETVARIANTINTEGERVEXTPROC = CFuncPtr3[GLuint, GLenum, Ptr[GLint], Unit]
  object PFNGLGETVARIANTINTEGERVEXTPROC:
    given _tag: Tag[PFNGLGETVARIANTINTEGERVEXTPROC] = Tag.materializeCFuncPtr3[GLuint, GLenum, Ptr[GLint], Unit]
    inline def fromPtr(ptr: Ptr[Byte] | Ptr[?]): PFNGLGETVARIANTINTEGERVEXTPROC = CFuncPtr.fromPtr(ptr.asInstanceOf[Ptr[Byte]])
    inline def apply(inline o: CFuncPtr3[GLuint, GLenum, Ptr[GLint], Unit]): PFNGLGETVARIANTINTEGERVEXTPROC = o
    extension (v: PFNGLGETVARIANTINTEGERVEXTPROC)
      inline def value: CFuncPtr3[GLuint, GLenum, Ptr[GLint], Unit] = v
      inline def toPtr: Ptr[?] = CFuncPtr.toPtr(v)

  opaque type PFNGLGETVARIANTPOINTERVEXTPROC = CFuncPtr3[GLuint, GLenum, Ptr[Ptr[Byte]], Unit]
  object PFNGLGETVARIANTPOINTERVEXTPROC:
    given _tag: Tag[PFNGLGETVARIANTPOINTERVEXTPROC] = Tag.materializeCFuncPtr3[GLuint, GLenum, Ptr[Ptr[Byte]], Unit]
    inline def fromPtr(ptr: Ptr[Byte] | Ptr[?]): PFNGLGETVARIANTPOINTERVEXTPROC = CFuncPtr.fromPtr(ptr.asInstanceOf[Ptr[Byte]])
    inline def apply(inline o: CFuncPtr3[GLuint, GLenum, Ptr[Ptr[Byte]], Unit]): PFNGLGETVARIANTPOINTERVEXTPROC = o
    extension (v: PFNGLGETVARIANTPOINTERVEXTPROC)
      inline def value: CFuncPtr3[GLuint, GLenum, Ptr[Ptr[Byte]], Unit] = v
      inline def toPtr: Ptr[?] = CFuncPtr.toPtr(v)

  opaque type PFNGLGETVARYINGLOCATIONNVPROC = CFuncPtr2[GLuint, Ptr[GLchar], GLint]
  object PFNGLGETVARYINGLOCATIONNVPROC:
    given _tag: Tag[PFNGLGETVARYINGLOCATIONNVPROC] = Tag.materializeCFuncPtr2[GLuint, Ptr[GLchar], GLint]
    inline def fromPtr(ptr: Ptr[Byte] | Ptr[?]): PFNGLGETVARYINGLOCATIONNVPROC = CFuncPtr.fromPtr(ptr.asInstanceOf[Ptr[Byte]])
    inline def apply(inline o: CFuncPtr2[GLuint, Ptr[GLchar], GLint]): PFNGLGETVARYINGLOCATIONNVPROC = o
    extension (v: PFNGLGETVARYINGLOCATIONNVPROC)
      inline def value: CFuncPtr2[GLuint, Ptr[GLchar], GLint] = v
      inline def toPtr: Ptr[?] = CFuncPtr.toPtr(v)

  opaque type PFNGLGETVECTOROPERATIONSGIXPROC = CFuncPtr1[GLenum, Unit]
  object PFNGLGETVECTOROPERATIONSGIXPROC:
    given _tag: Tag[PFNGLGETVECTOROPERATIONSGIXPROC] = Tag.materializeCFuncPtr1[GLenum, Unit]
    inline def fromPtr(ptr: Ptr[Byte] | Ptr[?]): PFNGLGETVECTOROPERATIONSGIXPROC = CFuncPtr.fromPtr(ptr.asInstanceOf[Ptr[Byte]])
    inline def apply(inline o: CFuncPtr1[GLenum, Unit]): PFNGLGETVECTOROPERATIONSGIXPROC = o
    extension (v: PFNGLGETVECTOROPERATIONSGIXPROC)
      inline def value: CFuncPtr1[GLenum, Unit] = v
      inline def toPtr: Ptr[?] = CFuncPtr.toPtr(v)

  opaque type PFNGLGETVERTEXARRAYINDEXED64IVPROC = CFuncPtr4[GLuint, GLuint, GLenum, Ptr[GLint64], Unit]
  object PFNGLGETVERTEXARRAYINDEXED64IVPROC:
    given _tag: Tag[PFNGLGETVERTEXARRAYINDEXED64IVPROC] = Tag.materializeCFuncPtr4[GLuint, GLuint, GLenum, Ptr[GLint64], Unit]
    inline def fromPtr(ptr: Ptr[Byte] | Ptr[?]): PFNGLGETVERTEXARRAYINDEXED64IVPROC = CFuncPtr.fromPtr(ptr.asInstanceOf[Ptr[Byte]])
    inline def apply(inline o: CFuncPtr4[GLuint, GLuint, GLenum, Ptr[GLint64], Unit]): PFNGLGETVERTEXARRAYINDEXED64IVPROC = o
    extension (v: PFNGLGETVERTEXARRAYINDEXED64IVPROC)
      inline def value: CFuncPtr4[GLuint, GLuint, GLenum, Ptr[GLint64], Unit] = v
      inline def toPtr: Ptr[?] = CFuncPtr.toPtr(v)

  opaque type PFNGLGETVERTEXARRAYINDEXEDIVPROC = CFuncPtr4[GLuint, GLuint, GLenum, Ptr[GLint], Unit]
  object PFNGLGETVERTEXARRAYINDEXEDIVPROC:
    given _tag: Tag[PFNGLGETVERTEXARRAYINDEXEDIVPROC] = Tag.materializeCFuncPtr4[GLuint, GLuint, GLenum, Ptr[GLint], Unit]
    inline def fromPtr(ptr: Ptr[Byte] | Ptr[?]): PFNGLGETVERTEXARRAYINDEXEDIVPROC = CFuncPtr.fromPtr(ptr.asInstanceOf[Ptr[Byte]])
    inline def apply(inline o: CFuncPtr4[GLuint, GLuint, GLenum, Ptr[GLint], Unit]): PFNGLGETVERTEXARRAYINDEXEDIVPROC = o
    extension (v: PFNGLGETVERTEXARRAYINDEXEDIVPROC)
      inline def value: CFuncPtr4[GLuint, GLuint, GLenum, Ptr[GLint], Unit] = v
      inline def toPtr: Ptr[?] = CFuncPtr.toPtr(v)

  opaque type PFNGLGETVERTEXARRAYINTEGERI_VEXTPROC = CFuncPtr4[GLuint, GLuint, GLenum, Ptr[GLint], Unit]
  object PFNGLGETVERTEXARRAYINTEGERI_VEXTPROC:
    given _tag: Tag[PFNGLGETVERTEXARRAYINTEGERI_VEXTPROC] = Tag.materializeCFuncPtr4[GLuint, GLuint, GLenum, Ptr[GLint], Unit]
    inline def fromPtr(ptr: Ptr[Byte] | Ptr[?]): PFNGLGETVERTEXARRAYINTEGERI_VEXTPROC = CFuncPtr.fromPtr(ptr.asInstanceOf[Ptr[Byte]])
    inline def apply(inline o: CFuncPtr4[GLuint, GLuint, GLenum, Ptr[GLint], Unit]): PFNGLGETVERTEXARRAYINTEGERI_VEXTPROC = o
    extension (v: PFNGLGETVERTEXARRAYINTEGERI_VEXTPROC)
      inline def value: CFuncPtr4[GLuint, GLuint, GLenum, Ptr[GLint], Unit] = v
      inline def toPtr: Ptr[?] = CFuncPtr.toPtr(v)

  opaque type PFNGLGETVERTEXARRAYINTEGERVEXTPROC = CFuncPtr3[GLuint, GLenum, Ptr[GLint], Unit]
  object PFNGLGETVERTEXARRAYINTEGERVEXTPROC:
    given _tag: Tag[PFNGLGETVERTEXARRAYINTEGERVEXTPROC] = Tag.materializeCFuncPtr3[GLuint, GLenum, Ptr[GLint], Unit]
    inline def fromPtr(ptr: Ptr[Byte] | Ptr[?]): PFNGLGETVERTEXARRAYINTEGERVEXTPROC = CFuncPtr.fromPtr(ptr.asInstanceOf[Ptr[Byte]])
    inline def apply(inline o: CFuncPtr3[GLuint, GLenum, Ptr[GLint], Unit]): PFNGLGETVERTEXARRAYINTEGERVEXTPROC = o
    extension (v: PFNGLGETVERTEXARRAYINTEGERVEXTPROC)
      inline def value: CFuncPtr3[GLuint, GLenum, Ptr[GLint], Unit] = v
      inline def toPtr: Ptr[?] = CFuncPtr.toPtr(v)

  opaque type PFNGLGETVERTEXARRAYIVPROC = CFuncPtr3[GLuint, GLenum, Ptr[GLint], Unit]
  object PFNGLGETVERTEXARRAYIVPROC:
    given _tag: Tag[PFNGLGETVERTEXARRAYIVPROC] = Tag.materializeCFuncPtr3[GLuint, GLenum, Ptr[GLint], Unit]
    inline def fromPtr(ptr: Ptr[Byte] | Ptr[?]): PFNGLGETVERTEXARRAYIVPROC = CFuncPtr.fromPtr(ptr.asInstanceOf[Ptr[Byte]])
    inline def apply(inline o: CFuncPtr3[GLuint, GLenum, Ptr[GLint], Unit]): PFNGLGETVERTEXARRAYIVPROC = o
    extension (v: PFNGLGETVERTEXARRAYIVPROC)
      inline def value: CFuncPtr3[GLuint, GLenum, Ptr[GLint], Unit] = v
      inline def toPtr: Ptr[?] = CFuncPtr.toPtr(v)

  opaque type PFNGLGETVERTEXARRAYPOINTERI_VEXTPROC = CFuncPtr4[GLuint, GLuint, GLenum, Ptr[Ptr[Byte]], Unit]
  object PFNGLGETVERTEXARRAYPOINTERI_VEXTPROC:
    given _tag: Tag[PFNGLGETVERTEXARRAYPOINTERI_VEXTPROC] = Tag.materializeCFuncPtr4[GLuint, GLuint, GLenum, Ptr[Ptr[Byte]], Unit]
    inline def fromPtr(ptr: Ptr[Byte] | Ptr[?]): PFNGLGETVERTEXARRAYPOINTERI_VEXTPROC = CFuncPtr.fromPtr(ptr.asInstanceOf[Ptr[Byte]])
    inline def apply(inline o: CFuncPtr4[GLuint, GLuint, GLenum, Ptr[Ptr[Byte]], Unit]): PFNGLGETVERTEXARRAYPOINTERI_VEXTPROC = o
    extension (v: PFNGLGETVERTEXARRAYPOINTERI_VEXTPROC)
      inline def value: CFuncPtr4[GLuint, GLuint, GLenum, Ptr[Ptr[Byte]], Unit] = v
      inline def toPtr: Ptr[?] = CFuncPtr.toPtr(v)

  opaque type PFNGLGETVERTEXARRAYPOINTERVEXTPROC = CFuncPtr3[GLuint, GLenum, Ptr[Ptr[Byte]], Unit]
  object PFNGLGETVERTEXARRAYPOINTERVEXTPROC:
    given _tag: Tag[PFNGLGETVERTEXARRAYPOINTERVEXTPROC] = Tag.materializeCFuncPtr3[GLuint, GLenum, Ptr[Ptr[Byte]], Unit]
    inline def fromPtr(ptr: Ptr[Byte] | Ptr[?]): PFNGLGETVERTEXARRAYPOINTERVEXTPROC = CFuncPtr.fromPtr(ptr.asInstanceOf[Ptr[Byte]])
    inline def apply(inline o: CFuncPtr3[GLuint, GLenum, Ptr[Ptr[Byte]], Unit]): PFNGLGETVERTEXARRAYPOINTERVEXTPROC = o
    extension (v: PFNGLGETVERTEXARRAYPOINTERVEXTPROC)
      inline def value: CFuncPtr3[GLuint, GLenum, Ptr[Ptr[Byte]], Unit] = v
      inline def toPtr: Ptr[?] = CFuncPtr.toPtr(v)

  opaque type PFNGLGETVERTEXATTRIBARRAYOBJECTFVATIPROC = CFuncPtr3[GLuint, GLenum, Ptr[GLfloat], Unit]
  object PFNGLGETVERTEXATTRIBARRAYOBJECTFVATIPROC:
    given _tag: Tag[PFNGLGETVERTEXATTRIBARRAYOBJECTFVATIPROC] = Tag.materializeCFuncPtr3[GLuint, GLenum, Ptr[GLfloat], Unit]
    inline def fromPtr(ptr: Ptr[Byte] | Ptr[?]): PFNGLGETVERTEXATTRIBARRAYOBJECTFVATIPROC = CFuncPtr.fromPtr(ptr.asInstanceOf[Ptr[Byte]])
    inline def apply(inline o: CFuncPtr3[GLuint, GLenum, Ptr[GLfloat], Unit]): PFNGLGETVERTEXATTRIBARRAYOBJECTFVATIPROC = o
    extension (v: PFNGLGETVERTEXATTRIBARRAYOBJECTFVATIPROC)
      inline def value: CFuncPtr3[GLuint, GLenum, Ptr[GLfloat], Unit] = v
      inline def toPtr: Ptr[?] = CFuncPtr.toPtr(v)

  opaque type PFNGLGETVERTEXATTRIBARRAYOBJECTIVATIPROC = CFuncPtr3[GLuint, GLenum, Ptr[GLint], Unit]
  object PFNGLGETVERTEXATTRIBARRAYOBJECTIVATIPROC:
    given _tag: Tag[PFNGLGETVERTEXATTRIBARRAYOBJECTIVATIPROC] = Tag.materializeCFuncPtr3[GLuint, GLenum, Ptr[GLint], Unit]
    inline def fromPtr(ptr: Ptr[Byte] | Ptr[?]): PFNGLGETVERTEXATTRIBARRAYOBJECTIVATIPROC = CFuncPtr.fromPtr(ptr.asInstanceOf[Ptr[Byte]])
    inline def apply(inline o: CFuncPtr3[GLuint, GLenum, Ptr[GLint], Unit]): PFNGLGETVERTEXATTRIBARRAYOBJECTIVATIPROC = o
    extension (v: PFNGLGETVERTEXATTRIBARRAYOBJECTIVATIPROC)
      inline def value: CFuncPtr3[GLuint, GLenum, Ptr[GLint], Unit] = v
      inline def toPtr: Ptr[?] = CFuncPtr.toPtr(v)

  opaque type PFNGLGETVERTEXATTRIBDVARBPROC = CFuncPtr3[GLuint, GLenum, Ptr[GLdouble], Unit]
  object PFNGLGETVERTEXATTRIBDVARBPROC:
    given _tag: Tag[PFNGLGETVERTEXATTRIBDVARBPROC] = Tag.materializeCFuncPtr3[GLuint, GLenum, Ptr[GLdouble], Unit]
    inline def fromPtr(ptr: Ptr[Byte] | Ptr[?]): PFNGLGETVERTEXATTRIBDVARBPROC = CFuncPtr.fromPtr(ptr.asInstanceOf[Ptr[Byte]])
    inline def apply(inline o: CFuncPtr3[GLuint, GLenum, Ptr[GLdouble], Unit]): PFNGLGETVERTEXATTRIBDVARBPROC = o
    extension (v: PFNGLGETVERTEXATTRIBDVARBPROC)
      inline def value: CFuncPtr3[GLuint, GLenum, Ptr[GLdouble], Unit] = v
      inline def toPtr: Ptr[?] = CFuncPtr.toPtr(v)

  opaque type PFNGLGETVERTEXATTRIBDVNVPROC = CFuncPtr3[GLuint, GLenum, Ptr[GLdouble], Unit]
  object PFNGLGETVERTEXATTRIBDVNVPROC:
    given _tag: Tag[PFNGLGETVERTEXATTRIBDVNVPROC] = Tag.materializeCFuncPtr3[GLuint, GLenum, Ptr[GLdouble], Unit]
    inline def fromPtr(ptr: Ptr[Byte] | Ptr[?]): PFNGLGETVERTEXATTRIBDVNVPROC = CFuncPtr.fromPtr(ptr.asInstanceOf[Ptr[Byte]])
    inline def apply(inline o: CFuncPtr3[GLuint, GLenum, Ptr[GLdouble], Unit]): PFNGLGETVERTEXATTRIBDVNVPROC = o
    extension (v: PFNGLGETVERTEXATTRIBDVNVPROC)
      inline def value: CFuncPtr3[GLuint, GLenum, Ptr[GLdouble], Unit] = v
      inline def toPtr: Ptr[?] = CFuncPtr.toPtr(v)

  opaque type PFNGLGETVERTEXATTRIBDVPROC = CFuncPtr3[GLuint, GLenum, Ptr[GLdouble], Unit]
  object PFNGLGETVERTEXATTRIBDVPROC:
    given _tag: Tag[PFNGLGETVERTEXATTRIBDVPROC] = Tag.materializeCFuncPtr3[GLuint, GLenum, Ptr[GLdouble], Unit]
    inline def fromPtr(ptr: Ptr[Byte] | Ptr[?]): PFNGLGETVERTEXATTRIBDVPROC = CFuncPtr.fromPtr(ptr.asInstanceOf[Ptr[Byte]])
    inline def apply(inline o: CFuncPtr3[GLuint, GLenum, Ptr[GLdouble], Unit]): PFNGLGETVERTEXATTRIBDVPROC = o
    extension (v: PFNGLGETVERTEXATTRIBDVPROC)
      inline def value: CFuncPtr3[GLuint, GLenum, Ptr[GLdouble], Unit] = v
      inline def toPtr: Ptr[?] = CFuncPtr.toPtr(v)

  opaque type PFNGLGETVERTEXATTRIBFVARBPROC = CFuncPtr3[GLuint, GLenum, Ptr[GLfloat], Unit]
  object PFNGLGETVERTEXATTRIBFVARBPROC:
    given _tag: Tag[PFNGLGETVERTEXATTRIBFVARBPROC] = Tag.materializeCFuncPtr3[GLuint, GLenum, Ptr[GLfloat], Unit]
    inline def fromPtr(ptr: Ptr[Byte] | Ptr[?]): PFNGLGETVERTEXATTRIBFVARBPROC = CFuncPtr.fromPtr(ptr.asInstanceOf[Ptr[Byte]])
    inline def apply(inline o: CFuncPtr3[GLuint, GLenum, Ptr[GLfloat], Unit]): PFNGLGETVERTEXATTRIBFVARBPROC = o
    extension (v: PFNGLGETVERTEXATTRIBFVARBPROC)
      inline def value: CFuncPtr3[GLuint, GLenum, Ptr[GLfloat], Unit] = v
      inline def toPtr: Ptr[?] = CFuncPtr.toPtr(v)

  opaque type PFNGLGETVERTEXATTRIBFVNVPROC = CFuncPtr3[GLuint, GLenum, Ptr[GLfloat], Unit]
  object PFNGLGETVERTEXATTRIBFVNVPROC:
    given _tag: Tag[PFNGLGETVERTEXATTRIBFVNVPROC] = Tag.materializeCFuncPtr3[GLuint, GLenum, Ptr[GLfloat], Unit]
    inline def fromPtr(ptr: Ptr[Byte] | Ptr[?]): PFNGLGETVERTEXATTRIBFVNVPROC = CFuncPtr.fromPtr(ptr.asInstanceOf[Ptr[Byte]])
    inline def apply(inline o: CFuncPtr3[GLuint, GLenum, Ptr[GLfloat], Unit]): PFNGLGETVERTEXATTRIBFVNVPROC = o
    extension (v: PFNGLGETVERTEXATTRIBFVNVPROC)
      inline def value: CFuncPtr3[GLuint, GLenum, Ptr[GLfloat], Unit] = v
      inline def toPtr: Ptr[?] = CFuncPtr.toPtr(v)

  opaque type PFNGLGETVERTEXATTRIBFVPROC = CFuncPtr3[GLuint, GLenum, Ptr[GLfloat], Unit]
  object PFNGLGETVERTEXATTRIBFVPROC:
    given _tag: Tag[PFNGLGETVERTEXATTRIBFVPROC] = Tag.materializeCFuncPtr3[GLuint, GLenum, Ptr[GLfloat], Unit]
    inline def fromPtr(ptr: Ptr[Byte] | Ptr[?]): PFNGLGETVERTEXATTRIBFVPROC = CFuncPtr.fromPtr(ptr.asInstanceOf[Ptr[Byte]])
    inline def apply(inline o: CFuncPtr3[GLuint, GLenum, Ptr[GLfloat], Unit]): PFNGLGETVERTEXATTRIBFVPROC = o
    extension (v: PFNGLGETVERTEXATTRIBFVPROC)
      inline def value: CFuncPtr3[GLuint, GLenum, Ptr[GLfloat], Unit] = v
      inline def toPtr: Ptr[?] = CFuncPtr.toPtr(v)

  opaque type PFNGLGETVERTEXATTRIBIIVEXTPROC = CFuncPtr3[GLuint, GLenum, Ptr[GLint], Unit]
  object PFNGLGETVERTEXATTRIBIIVEXTPROC:
    given _tag: Tag[PFNGLGETVERTEXATTRIBIIVEXTPROC] = Tag.materializeCFuncPtr3[GLuint, GLenum, Ptr[GLint], Unit]
    inline def fromPtr(ptr: Ptr[Byte] | Ptr[?]): PFNGLGETVERTEXATTRIBIIVEXTPROC = CFuncPtr.fromPtr(ptr.asInstanceOf[Ptr[Byte]])
    inline def apply(inline o: CFuncPtr3[GLuint, GLenum, Ptr[GLint], Unit]): PFNGLGETVERTEXATTRIBIIVEXTPROC = o
    extension (v: PFNGLGETVERTEXATTRIBIIVEXTPROC)
      inline def value: CFuncPtr3[GLuint, GLenum, Ptr[GLint], Unit] = v
      inline def toPtr: Ptr[?] = CFuncPtr.toPtr(v)

  opaque type PFNGLGETVERTEXATTRIBIIVPROC = CFuncPtr3[GLuint, GLenum, Ptr[GLint], Unit]
  object PFNGLGETVERTEXATTRIBIIVPROC:
    given _tag: Tag[PFNGLGETVERTEXATTRIBIIVPROC] = Tag.materializeCFuncPtr3[GLuint, GLenum, Ptr[GLint], Unit]
    inline def fromPtr(ptr: Ptr[Byte] | Ptr[?]): PFNGLGETVERTEXATTRIBIIVPROC = CFuncPtr.fromPtr(ptr.asInstanceOf[Ptr[Byte]])
    inline def apply(inline o: CFuncPtr3[GLuint, GLenum, Ptr[GLint], Unit]): PFNGLGETVERTEXATTRIBIIVPROC = o
    extension (v: PFNGLGETVERTEXATTRIBIIVPROC)
      inline def value: CFuncPtr3[GLuint, GLenum, Ptr[GLint], Unit] = v
      inline def toPtr: Ptr[?] = CFuncPtr.toPtr(v)

  opaque type PFNGLGETVERTEXATTRIBIUIVEXTPROC = CFuncPtr3[GLuint, GLenum, Ptr[GLuint], Unit]
  object PFNGLGETVERTEXATTRIBIUIVEXTPROC:
    given _tag: Tag[PFNGLGETVERTEXATTRIBIUIVEXTPROC] = Tag.materializeCFuncPtr3[GLuint, GLenum, Ptr[GLuint], Unit]
    inline def fromPtr(ptr: Ptr[Byte] | Ptr[?]): PFNGLGETVERTEXATTRIBIUIVEXTPROC = CFuncPtr.fromPtr(ptr.asInstanceOf[Ptr[Byte]])
    inline def apply(inline o: CFuncPtr3[GLuint, GLenum, Ptr[GLuint], Unit]): PFNGLGETVERTEXATTRIBIUIVEXTPROC = o
    extension (v: PFNGLGETVERTEXATTRIBIUIVEXTPROC)
      inline def value: CFuncPtr3[GLuint, GLenum, Ptr[GLuint], Unit] = v
      inline def toPtr: Ptr[?] = CFuncPtr.toPtr(v)

  opaque type PFNGLGETVERTEXATTRIBIUIVPROC = CFuncPtr3[GLuint, GLenum, Ptr[GLuint], Unit]
  object PFNGLGETVERTEXATTRIBIUIVPROC:
    given _tag: Tag[PFNGLGETVERTEXATTRIBIUIVPROC] = Tag.materializeCFuncPtr3[GLuint, GLenum, Ptr[GLuint], Unit]
    inline def fromPtr(ptr: Ptr[Byte] | Ptr[?]): PFNGLGETVERTEXATTRIBIUIVPROC = CFuncPtr.fromPtr(ptr.asInstanceOf[Ptr[Byte]])
    inline def apply(inline o: CFuncPtr3[GLuint, GLenum, Ptr[GLuint], Unit]): PFNGLGETVERTEXATTRIBIUIVPROC = o
    extension (v: PFNGLGETVERTEXATTRIBIUIVPROC)
      inline def value: CFuncPtr3[GLuint, GLenum, Ptr[GLuint], Unit] = v
      inline def toPtr: Ptr[?] = CFuncPtr.toPtr(v)

  opaque type PFNGLGETVERTEXATTRIBIVARBPROC = CFuncPtr3[GLuint, GLenum, Ptr[GLint], Unit]
  object PFNGLGETVERTEXATTRIBIVARBPROC:
    given _tag: Tag[PFNGLGETVERTEXATTRIBIVARBPROC] = Tag.materializeCFuncPtr3[GLuint, GLenum, Ptr[GLint], Unit]
    inline def fromPtr(ptr: Ptr[Byte] | Ptr[?]): PFNGLGETVERTEXATTRIBIVARBPROC = CFuncPtr.fromPtr(ptr.asInstanceOf[Ptr[Byte]])
    inline def apply(inline o: CFuncPtr3[GLuint, GLenum, Ptr[GLint], Unit]): PFNGLGETVERTEXATTRIBIVARBPROC = o
    extension (v: PFNGLGETVERTEXATTRIBIVARBPROC)
      inline def value: CFuncPtr3[GLuint, GLenum, Ptr[GLint], Unit] = v
      inline def toPtr: Ptr[?] = CFuncPtr.toPtr(v)

  opaque type PFNGLGETVERTEXATTRIBIVNVPROC = CFuncPtr3[GLuint, GLenum, Ptr[GLint], Unit]
  object PFNGLGETVERTEXATTRIBIVNVPROC:
    given _tag: Tag[PFNGLGETVERTEXATTRIBIVNVPROC] = Tag.materializeCFuncPtr3[GLuint, GLenum, Ptr[GLint], Unit]
    inline def fromPtr(ptr: Ptr[Byte] | Ptr[?]): PFNGLGETVERTEXATTRIBIVNVPROC = CFuncPtr.fromPtr(ptr.asInstanceOf[Ptr[Byte]])
    inline def apply(inline o: CFuncPtr3[GLuint, GLenum, Ptr[GLint], Unit]): PFNGLGETVERTEXATTRIBIVNVPROC = o
    extension (v: PFNGLGETVERTEXATTRIBIVNVPROC)
      inline def value: CFuncPtr3[GLuint, GLenum, Ptr[GLint], Unit] = v
      inline def toPtr: Ptr[?] = CFuncPtr.toPtr(v)

  opaque type PFNGLGETVERTEXATTRIBIVPROC = CFuncPtr3[GLuint, GLenum, Ptr[GLint], Unit]
  object PFNGLGETVERTEXATTRIBIVPROC:
    given _tag: Tag[PFNGLGETVERTEXATTRIBIVPROC] = Tag.materializeCFuncPtr3[GLuint, GLenum, Ptr[GLint], Unit]
    inline def fromPtr(ptr: Ptr[Byte] | Ptr[?]): PFNGLGETVERTEXATTRIBIVPROC = CFuncPtr.fromPtr(ptr.asInstanceOf[Ptr[Byte]])
    inline def apply(inline o: CFuncPtr3[GLuint, GLenum, Ptr[GLint], Unit]): PFNGLGETVERTEXATTRIBIVPROC = o
    extension (v: PFNGLGETVERTEXATTRIBIVPROC)
      inline def value: CFuncPtr3[GLuint, GLenum, Ptr[GLint], Unit] = v
      inline def toPtr: Ptr[?] = CFuncPtr.toPtr(v)

  opaque type PFNGLGETVERTEXATTRIBLDVEXTPROC = CFuncPtr3[GLuint, GLenum, Ptr[GLdouble], Unit]
  object PFNGLGETVERTEXATTRIBLDVEXTPROC:
    given _tag: Tag[PFNGLGETVERTEXATTRIBLDVEXTPROC] = Tag.materializeCFuncPtr3[GLuint, GLenum, Ptr[GLdouble], Unit]
    inline def fromPtr(ptr: Ptr[Byte] | Ptr[?]): PFNGLGETVERTEXATTRIBLDVEXTPROC = CFuncPtr.fromPtr(ptr.asInstanceOf[Ptr[Byte]])
    inline def apply(inline o: CFuncPtr3[GLuint, GLenum, Ptr[GLdouble], Unit]): PFNGLGETVERTEXATTRIBLDVEXTPROC = o
    extension (v: PFNGLGETVERTEXATTRIBLDVEXTPROC)
      inline def value: CFuncPtr3[GLuint, GLenum, Ptr[GLdouble], Unit] = v
      inline def toPtr: Ptr[?] = CFuncPtr.toPtr(v)

  opaque type PFNGLGETVERTEXATTRIBLDVPROC = CFuncPtr3[GLuint, GLenum, Ptr[GLdouble], Unit]
  object PFNGLGETVERTEXATTRIBLDVPROC:
    given _tag: Tag[PFNGLGETVERTEXATTRIBLDVPROC] = Tag.materializeCFuncPtr3[GLuint, GLenum, Ptr[GLdouble], Unit]
    inline def fromPtr(ptr: Ptr[Byte] | Ptr[?]): PFNGLGETVERTEXATTRIBLDVPROC = CFuncPtr.fromPtr(ptr.asInstanceOf[Ptr[Byte]])
    inline def apply(inline o: CFuncPtr3[GLuint, GLenum, Ptr[GLdouble], Unit]): PFNGLGETVERTEXATTRIBLDVPROC = o
    extension (v: PFNGLGETVERTEXATTRIBLDVPROC)
      inline def value: CFuncPtr3[GLuint, GLenum, Ptr[GLdouble], Unit] = v
      inline def toPtr: Ptr[?] = CFuncPtr.toPtr(v)

  opaque type PFNGLGETVERTEXATTRIBLI64VNVPROC = CFuncPtr3[GLuint, GLenum, Ptr[GLint64EXT], Unit]
  object PFNGLGETVERTEXATTRIBLI64VNVPROC:
    given _tag: Tag[PFNGLGETVERTEXATTRIBLI64VNVPROC] = Tag.materializeCFuncPtr3[GLuint, GLenum, Ptr[GLint64EXT], Unit]
    inline def fromPtr(ptr: Ptr[Byte] | Ptr[?]): PFNGLGETVERTEXATTRIBLI64VNVPROC = CFuncPtr.fromPtr(ptr.asInstanceOf[Ptr[Byte]])
    inline def apply(inline o: CFuncPtr3[GLuint, GLenum, Ptr[GLint64EXT], Unit]): PFNGLGETVERTEXATTRIBLI64VNVPROC = o
    extension (v: PFNGLGETVERTEXATTRIBLI64VNVPROC)
      inline def value: CFuncPtr3[GLuint, GLenum, Ptr[GLint64EXT], Unit] = v
      inline def toPtr: Ptr[?] = CFuncPtr.toPtr(v)

  opaque type PFNGLGETVERTEXATTRIBLUI64VARBPROC = CFuncPtr3[GLuint, GLenum, Ptr[GLuint64EXT], Unit]
  object PFNGLGETVERTEXATTRIBLUI64VARBPROC:
    given _tag: Tag[PFNGLGETVERTEXATTRIBLUI64VARBPROC] = Tag.materializeCFuncPtr3[GLuint, GLenum, Ptr[GLuint64EXT], Unit]
    inline def fromPtr(ptr: Ptr[Byte] | Ptr[?]): PFNGLGETVERTEXATTRIBLUI64VARBPROC = CFuncPtr.fromPtr(ptr.asInstanceOf[Ptr[Byte]])
    inline def apply(inline o: CFuncPtr3[GLuint, GLenum, Ptr[GLuint64EXT], Unit]): PFNGLGETVERTEXATTRIBLUI64VARBPROC = o
    extension (v: PFNGLGETVERTEXATTRIBLUI64VARBPROC)
      inline def value: CFuncPtr3[GLuint, GLenum, Ptr[GLuint64EXT], Unit] = v
      inline def toPtr: Ptr[?] = CFuncPtr.toPtr(v)

  opaque type PFNGLGETVERTEXATTRIBLUI64VNVPROC = CFuncPtr3[GLuint, GLenum, Ptr[GLuint64EXT], Unit]
  object PFNGLGETVERTEXATTRIBLUI64VNVPROC:
    given _tag: Tag[PFNGLGETVERTEXATTRIBLUI64VNVPROC] = Tag.materializeCFuncPtr3[GLuint, GLenum, Ptr[GLuint64EXT], Unit]
    inline def fromPtr(ptr: Ptr[Byte] | Ptr[?]): PFNGLGETVERTEXATTRIBLUI64VNVPROC = CFuncPtr.fromPtr(ptr.asInstanceOf[Ptr[Byte]])
    inline def apply(inline o: CFuncPtr3[GLuint, GLenum, Ptr[GLuint64EXT], Unit]): PFNGLGETVERTEXATTRIBLUI64VNVPROC = o
    extension (v: PFNGLGETVERTEXATTRIBLUI64VNVPROC)
      inline def value: CFuncPtr3[GLuint, GLenum, Ptr[GLuint64EXT], Unit] = v
      inline def toPtr: Ptr[?] = CFuncPtr.toPtr(v)

  opaque type PFNGLGETVERTEXATTRIBPOINTERVARBPROC = CFuncPtr3[GLuint, GLenum, Ptr[Ptr[Byte]], Unit]
  object PFNGLGETVERTEXATTRIBPOINTERVARBPROC:
    given _tag: Tag[PFNGLGETVERTEXATTRIBPOINTERVARBPROC] = Tag.materializeCFuncPtr3[GLuint, GLenum, Ptr[Ptr[Byte]], Unit]
    inline def fromPtr(ptr: Ptr[Byte] | Ptr[?]): PFNGLGETVERTEXATTRIBPOINTERVARBPROC = CFuncPtr.fromPtr(ptr.asInstanceOf[Ptr[Byte]])
    inline def apply(inline o: CFuncPtr3[GLuint, GLenum, Ptr[Ptr[Byte]], Unit]): PFNGLGETVERTEXATTRIBPOINTERVARBPROC = o
    extension (v: PFNGLGETVERTEXATTRIBPOINTERVARBPROC)
      inline def value: CFuncPtr3[GLuint, GLenum, Ptr[Ptr[Byte]], Unit] = v
      inline def toPtr: Ptr[?] = CFuncPtr.toPtr(v)

  opaque type PFNGLGETVERTEXATTRIBPOINTERVNVPROC = CFuncPtr3[GLuint, GLenum, Ptr[Ptr[Byte]], Unit]
  object PFNGLGETVERTEXATTRIBPOINTERVNVPROC:
    given _tag: Tag[PFNGLGETVERTEXATTRIBPOINTERVNVPROC] = Tag.materializeCFuncPtr3[GLuint, GLenum, Ptr[Ptr[Byte]], Unit]
    inline def fromPtr(ptr: Ptr[Byte] | Ptr[?]): PFNGLGETVERTEXATTRIBPOINTERVNVPROC = CFuncPtr.fromPtr(ptr.asInstanceOf[Ptr[Byte]])
    inline def apply(inline o: CFuncPtr3[GLuint, GLenum, Ptr[Ptr[Byte]], Unit]): PFNGLGETVERTEXATTRIBPOINTERVNVPROC = o
    extension (v: PFNGLGETVERTEXATTRIBPOINTERVNVPROC)
      inline def value: CFuncPtr3[GLuint, GLenum, Ptr[Ptr[Byte]], Unit] = v
      inline def toPtr: Ptr[?] = CFuncPtr.toPtr(v)

  opaque type PFNGLGETVERTEXATTRIBPOINTERVPROC = CFuncPtr3[GLuint, GLenum, Ptr[Ptr[Byte]], Unit]
  object PFNGLGETVERTEXATTRIBPOINTERVPROC:
    given _tag: Tag[PFNGLGETVERTEXATTRIBPOINTERVPROC] = Tag.materializeCFuncPtr3[GLuint, GLenum, Ptr[Ptr[Byte]], Unit]
    inline def fromPtr(ptr: Ptr[Byte] | Ptr[?]): PFNGLGETVERTEXATTRIBPOINTERVPROC = CFuncPtr.fromPtr(ptr.asInstanceOf[Ptr[Byte]])
    inline def apply(inline o: CFuncPtr3[GLuint, GLenum, Ptr[Ptr[Byte]], Unit]): PFNGLGETVERTEXATTRIBPOINTERVPROC = o
    extension (v: PFNGLGETVERTEXATTRIBPOINTERVPROC)
      inline def value: CFuncPtr3[GLuint, GLenum, Ptr[Ptr[Byte]], Unit] = v
      inline def toPtr: Ptr[?] = CFuncPtr.toPtr(v)

  opaque type PFNGLGETVIDEOCAPTUREIVNVPROC = CFuncPtr3[GLuint, GLenum, Ptr[GLint], Unit]
  object PFNGLGETVIDEOCAPTUREIVNVPROC:
    given _tag: Tag[PFNGLGETVIDEOCAPTUREIVNVPROC] = Tag.materializeCFuncPtr3[GLuint, GLenum, Ptr[GLint], Unit]
    inline def fromPtr(ptr: Ptr[Byte] | Ptr[?]): PFNGLGETVIDEOCAPTUREIVNVPROC = CFuncPtr.fromPtr(ptr.asInstanceOf[Ptr[Byte]])
    inline def apply(inline o: CFuncPtr3[GLuint, GLenum, Ptr[GLint], Unit]): PFNGLGETVIDEOCAPTUREIVNVPROC = o
    extension (v: PFNGLGETVIDEOCAPTUREIVNVPROC)
      inline def value: CFuncPtr3[GLuint, GLenum, Ptr[GLint], Unit] = v
      inline def toPtr: Ptr[?] = CFuncPtr.toPtr(v)

  opaque type PFNGLGETVIDEOCAPTURESTREAMDVNVPROC = CFuncPtr4[GLuint, GLuint, GLenum, Ptr[GLdouble], Unit]
  object PFNGLGETVIDEOCAPTURESTREAMDVNVPROC:
    given _tag: Tag[PFNGLGETVIDEOCAPTURESTREAMDVNVPROC] = Tag.materializeCFuncPtr4[GLuint, GLuint, GLenum, Ptr[GLdouble], Unit]
    inline def fromPtr(ptr: Ptr[Byte] | Ptr[?]): PFNGLGETVIDEOCAPTURESTREAMDVNVPROC = CFuncPtr.fromPtr(ptr.asInstanceOf[Ptr[Byte]])
    inline def apply(inline o: CFuncPtr4[GLuint, GLuint, GLenum, Ptr[GLdouble], Unit]): PFNGLGETVIDEOCAPTURESTREAMDVNVPROC = o
    extension (v: PFNGLGETVIDEOCAPTURESTREAMDVNVPROC)
      inline def value: CFuncPtr4[GLuint, GLuint, GLenum, Ptr[GLdouble], Unit] = v
      inline def toPtr: Ptr[?] = CFuncPtr.toPtr(v)

  opaque type PFNGLGETVIDEOCAPTURESTREAMFVNVPROC = CFuncPtr4[GLuint, GLuint, GLenum, Ptr[GLfloat], Unit]
  object PFNGLGETVIDEOCAPTURESTREAMFVNVPROC:
    given _tag: Tag[PFNGLGETVIDEOCAPTURESTREAMFVNVPROC] = Tag.materializeCFuncPtr4[GLuint, GLuint, GLenum, Ptr[GLfloat], Unit]
    inline def fromPtr(ptr: Ptr[Byte] | Ptr[?]): PFNGLGETVIDEOCAPTURESTREAMFVNVPROC = CFuncPtr.fromPtr(ptr.asInstanceOf[Ptr[Byte]])
    inline def apply(inline o: CFuncPtr4[GLuint, GLuint, GLenum, Ptr[GLfloat], Unit]): PFNGLGETVIDEOCAPTURESTREAMFVNVPROC = o
    extension (v: PFNGLGETVIDEOCAPTURESTREAMFVNVPROC)
      inline def value: CFuncPtr4[GLuint, GLuint, GLenum, Ptr[GLfloat], Unit] = v
      inline def toPtr: Ptr[?] = CFuncPtr.toPtr(v)

  opaque type PFNGLGETVIDEOCAPTURESTREAMIVNVPROC = CFuncPtr4[GLuint, GLuint, GLenum, Ptr[GLint], Unit]
  object PFNGLGETVIDEOCAPTURESTREAMIVNVPROC:
    given _tag: Tag[PFNGLGETVIDEOCAPTURESTREAMIVNVPROC] = Tag.materializeCFuncPtr4[GLuint, GLuint, GLenum, Ptr[GLint], Unit]
    inline def fromPtr(ptr: Ptr[Byte] | Ptr[?]): PFNGLGETVIDEOCAPTURESTREAMIVNVPROC = CFuncPtr.fromPtr(ptr.asInstanceOf[Ptr[Byte]])
    inline def apply(inline o: CFuncPtr4[GLuint, GLuint, GLenum, Ptr[GLint], Unit]): PFNGLGETVIDEOCAPTURESTREAMIVNVPROC = o
    extension (v: PFNGLGETVIDEOCAPTURESTREAMIVNVPROC)
      inline def value: CFuncPtr4[GLuint, GLuint, GLenum, Ptr[GLint], Unit] = v
      inline def toPtr: Ptr[?] = CFuncPtr.toPtr(v)

  opaque type PFNGLGETVIDEOI64VNVPROC = CFuncPtr3[GLuint, GLenum, Ptr[GLint64EXT], Unit]
  object PFNGLGETVIDEOI64VNVPROC:
    given _tag: Tag[PFNGLGETVIDEOI64VNVPROC] = Tag.materializeCFuncPtr3[GLuint, GLenum, Ptr[GLint64EXT], Unit]
    inline def fromPtr(ptr: Ptr[Byte] | Ptr[?]): PFNGLGETVIDEOI64VNVPROC = CFuncPtr.fromPtr(ptr.asInstanceOf[Ptr[Byte]])
    inline def apply(inline o: CFuncPtr3[GLuint, GLenum, Ptr[GLint64EXT], Unit]): PFNGLGETVIDEOI64VNVPROC = o
    extension (v: PFNGLGETVIDEOI64VNVPROC)
      inline def value: CFuncPtr3[GLuint, GLenum, Ptr[GLint64EXT], Unit] = v
      inline def toPtr: Ptr[?] = CFuncPtr.toPtr(v)

  opaque type PFNGLGETVIDEOIVNVPROC = CFuncPtr3[GLuint, GLenum, Ptr[GLint], Unit]
  object PFNGLGETVIDEOIVNVPROC:
    given _tag: Tag[PFNGLGETVIDEOIVNVPROC] = Tag.materializeCFuncPtr3[GLuint, GLenum, Ptr[GLint], Unit]
    inline def fromPtr(ptr: Ptr[Byte] | Ptr[?]): PFNGLGETVIDEOIVNVPROC = CFuncPtr.fromPtr(ptr.asInstanceOf[Ptr[Byte]])
    inline def apply(inline o: CFuncPtr3[GLuint, GLenum, Ptr[GLint], Unit]): PFNGLGETVIDEOIVNVPROC = o
    extension (v: PFNGLGETVIDEOIVNVPROC)
      inline def value: CFuncPtr3[GLuint, GLenum, Ptr[GLint], Unit] = v
      inline def toPtr: Ptr[?] = CFuncPtr.toPtr(v)

  opaque type PFNGLGETVIDEOUI64VNVPROC = CFuncPtr3[GLuint, GLenum, Ptr[GLuint64EXT], Unit]
  object PFNGLGETVIDEOUI64VNVPROC:
    given _tag: Tag[PFNGLGETVIDEOUI64VNVPROC] = Tag.materializeCFuncPtr3[GLuint, GLenum, Ptr[GLuint64EXT], Unit]
    inline def fromPtr(ptr: Ptr[Byte] | Ptr[?]): PFNGLGETVIDEOUI64VNVPROC = CFuncPtr.fromPtr(ptr.asInstanceOf[Ptr[Byte]])
    inline def apply(inline o: CFuncPtr3[GLuint, GLenum, Ptr[GLuint64EXT], Unit]): PFNGLGETVIDEOUI64VNVPROC = o
    extension (v: PFNGLGETVIDEOUI64VNVPROC)
      inline def value: CFuncPtr3[GLuint, GLenum, Ptr[GLuint64EXT], Unit] = v
      inline def toPtr: Ptr[?] = CFuncPtr.toPtr(v)

  opaque type PFNGLGETVIDEOUIVNVPROC = CFuncPtr3[GLuint, GLenum, Ptr[GLuint], Unit]
  object PFNGLGETVIDEOUIVNVPROC:
    given _tag: Tag[PFNGLGETVIDEOUIVNVPROC] = Tag.materializeCFuncPtr3[GLuint, GLenum, Ptr[GLuint], Unit]
    inline def fromPtr(ptr: Ptr[Byte] | Ptr[?]): PFNGLGETVIDEOUIVNVPROC = CFuncPtr.fromPtr(ptr.asInstanceOf[Ptr[Byte]])
    inline def apply(inline o: CFuncPtr3[GLuint, GLenum, Ptr[GLuint], Unit]): PFNGLGETVIDEOUIVNVPROC = o
    extension (v: PFNGLGETVIDEOUIVNVPROC)
      inline def value: CFuncPtr3[GLuint, GLenum, Ptr[GLuint], Unit] = v
      inline def toPtr: Ptr[?] = CFuncPtr.toPtr(v)

  opaque type PFNGLGETVKPROCADDRNVPROC = CFuncPtr1[Ptr[GLchar], GLVULKANPROCNV]
  object PFNGLGETVKPROCADDRNVPROC:
    given _tag: Tag[PFNGLGETVKPROCADDRNVPROC] = Tag.materializeCFuncPtr1[Ptr[GLchar], GLVULKANPROCNV]
    inline def fromPtr(ptr: Ptr[Byte] | Ptr[?]): PFNGLGETVKPROCADDRNVPROC = CFuncPtr.fromPtr(ptr.asInstanceOf[Ptr[Byte]])
    inline def apply(inline o: CFuncPtr1[Ptr[GLchar], GLVULKANPROCNV]): PFNGLGETVKPROCADDRNVPROC = o
    extension (v: PFNGLGETVKPROCADDRNVPROC)
      inline def value: CFuncPtr1[Ptr[GLchar], GLVULKANPROCNV] = v
      inline def toPtr: Ptr[?] = CFuncPtr.toPtr(v)

  opaque type PFNGLGLOBALALPHAFACTORBSUNPROC = CFuncPtr1[GLbyte, Unit]
  object PFNGLGLOBALALPHAFACTORBSUNPROC:
    given _tag: Tag[PFNGLGLOBALALPHAFACTORBSUNPROC] = Tag.materializeCFuncPtr1[GLbyte, Unit]
    inline def fromPtr(ptr: Ptr[Byte] | Ptr[?]): PFNGLGLOBALALPHAFACTORBSUNPROC = CFuncPtr.fromPtr(ptr.asInstanceOf[Ptr[Byte]])
    inline def apply(inline o: CFuncPtr1[GLbyte, Unit]): PFNGLGLOBALALPHAFACTORBSUNPROC = o
    extension (v: PFNGLGLOBALALPHAFACTORBSUNPROC)
      inline def value: CFuncPtr1[GLbyte, Unit] = v
      inline def toPtr: Ptr[?] = CFuncPtr.toPtr(v)

  opaque type PFNGLGLOBALALPHAFACTORDSUNPROC = CFuncPtr1[GLdouble, Unit]
  object PFNGLGLOBALALPHAFACTORDSUNPROC:
    given _tag: Tag[PFNGLGLOBALALPHAFACTORDSUNPROC] = Tag.materializeCFuncPtr1[GLdouble, Unit]
    inline def fromPtr(ptr: Ptr[Byte] | Ptr[?]): PFNGLGLOBALALPHAFACTORDSUNPROC = CFuncPtr.fromPtr(ptr.asInstanceOf[Ptr[Byte]])
    inline def apply(inline o: CFuncPtr1[GLdouble, Unit]): PFNGLGLOBALALPHAFACTORDSUNPROC = o
    extension (v: PFNGLGLOBALALPHAFACTORDSUNPROC)
      inline def value: CFuncPtr1[GLdouble, Unit] = v
      inline def toPtr: Ptr[?] = CFuncPtr.toPtr(v)

  opaque type PFNGLGLOBALALPHAFACTORFSUNPROC = CFuncPtr1[GLfloat, Unit]
  object PFNGLGLOBALALPHAFACTORFSUNPROC:
    given _tag: Tag[PFNGLGLOBALALPHAFACTORFSUNPROC] = Tag.materializeCFuncPtr1[GLfloat, Unit]
    inline def fromPtr(ptr: Ptr[Byte] | Ptr[?]): PFNGLGLOBALALPHAFACTORFSUNPROC = CFuncPtr.fromPtr(ptr.asInstanceOf[Ptr[Byte]])
    inline def apply(inline o: CFuncPtr1[GLfloat, Unit]): PFNGLGLOBALALPHAFACTORFSUNPROC = o
    extension (v: PFNGLGLOBALALPHAFACTORFSUNPROC)
      inline def value: CFuncPtr1[GLfloat, Unit] = v
      inline def toPtr: Ptr[?] = CFuncPtr.toPtr(v)

  opaque type PFNGLGLOBALALPHAFACTORISUNPROC = CFuncPtr1[GLint, Unit]
  object PFNGLGLOBALALPHAFACTORISUNPROC:
    given _tag: Tag[PFNGLGLOBALALPHAFACTORISUNPROC] = Tag.materializeCFuncPtr1[GLint, Unit]
    inline def fromPtr(ptr: Ptr[Byte] | Ptr[?]): PFNGLGLOBALALPHAFACTORISUNPROC = CFuncPtr.fromPtr(ptr.asInstanceOf[Ptr[Byte]])
    inline def apply(inline o: CFuncPtr1[GLint, Unit]): PFNGLGLOBALALPHAFACTORISUNPROC = o
    extension (v: PFNGLGLOBALALPHAFACTORISUNPROC)
      inline def value: CFuncPtr1[GLint, Unit] = v
      inline def toPtr: Ptr[?] = CFuncPtr.toPtr(v)

  opaque type PFNGLGLOBALALPHAFACTORSSUNPROC = CFuncPtr1[GLshort, Unit]
  object PFNGLGLOBALALPHAFACTORSSUNPROC:
    given _tag: Tag[PFNGLGLOBALALPHAFACTORSSUNPROC] = Tag.materializeCFuncPtr1[GLshort, Unit]
    inline def fromPtr(ptr: Ptr[Byte] | Ptr[?]): PFNGLGLOBALALPHAFACTORSSUNPROC = CFuncPtr.fromPtr(ptr.asInstanceOf[Ptr[Byte]])
    inline def apply(inline o: CFuncPtr1[GLshort, Unit]): PFNGLGLOBALALPHAFACTORSSUNPROC = o
    extension (v: PFNGLGLOBALALPHAFACTORSSUNPROC)
      inline def value: CFuncPtr1[GLshort, Unit] = v
      inline def toPtr: Ptr[?] = CFuncPtr.toPtr(v)

  opaque type PFNGLGLOBALALPHAFACTORUBSUNPROC = CFuncPtr1[GLubyte, Unit]
  object PFNGLGLOBALALPHAFACTORUBSUNPROC:
    given _tag: Tag[PFNGLGLOBALALPHAFACTORUBSUNPROC] = Tag.materializeCFuncPtr1[GLubyte, Unit]
    inline def fromPtr(ptr: Ptr[Byte] | Ptr[?]): PFNGLGLOBALALPHAFACTORUBSUNPROC = CFuncPtr.fromPtr(ptr.asInstanceOf[Ptr[Byte]])
    inline def apply(inline o: CFuncPtr1[GLubyte, Unit]): PFNGLGLOBALALPHAFACTORUBSUNPROC = o
    extension (v: PFNGLGLOBALALPHAFACTORUBSUNPROC)
      inline def value: CFuncPtr1[GLubyte, Unit] = v
      inline def toPtr: Ptr[?] = CFuncPtr.toPtr(v)

  opaque type PFNGLGLOBALALPHAFACTORUISUNPROC = CFuncPtr1[GLuint, Unit]
  object PFNGLGLOBALALPHAFACTORUISUNPROC:
    given _tag: Tag[PFNGLGLOBALALPHAFACTORUISUNPROC] = Tag.materializeCFuncPtr1[GLuint, Unit]
    inline def fromPtr(ptr: Ptr[Byte] | Ptr[?]): PFNGLGLOBALALPHAFACTORUISUNPROC = CFuncPtr.fromPtr(ptr.asInstanceOf[Ptr[Byte]])
    inline def apply(inline o: CFuncPtr1[GLuint, Unit]): PFNGLGLOBALALPHAFACTORUISUNPROC = o
    extension (v: PFNGLGLOBALALPHAFACTORUISUNPROC)
      inline def value: CFuncPtr1[GLuint, Unit] = v
      inline def toPtr: Ptr[?] = CFuncPtr.toPtr(v)

  opaque type PFNGLGLOBALALPHAFACTORUSSUNPROC = CFuncPtr1[GLushort, Unit]
  object PFNGLGLOBALALPHAFACTORUSSUNPROC:
    given _tag: Tag[PFNGLGLOBALALPHAFACTORUSSUNPROC] = Tag.materializeCFuncPtr1[GLushort, Unit]
    inline def fromPtr(ptr: Ptr[Byte] | Ptr[?]): PFNGLGLOBALALPHAFACTORUSSUNPROC = CFuncPtr.fromPtr(ptr.asInstanceOf[Ptr[Byte]])
    inline def apply(inline o: CFuncPtr1[GLushort, Unit]): PFNGLGLOBALALPHAFACTORUSSUNPROC = o
    extension (v: PFNGLGLOBALALPHAFACTORUSSUNPROC)
      inline def value: CFuncPtr1[GLushort, Unit] = v
      inline def toPtr: Ptr[?] = CFuncPtr.toPtr(v)

  opaque type PFNGLHISTOGRAMEXTPROC = CFuncPtr4[GLenum, GLsizei, GLenum, GLboolean, Unit]
  object PFNGLHISTOGRAMEXTPROC:
    given _tag: Tag[PFNGLHISTOGRAMEXTPROC] = Tag.materializeCFuncPtr4[GLenum, GLsizei, GLenum, GLboolean, Unit]
    inline def fromPtr(ptr: Ptr[Byte] | Ptr[?]): PFNGLHISTOGRAMEXTPROC = CFuncPtr.fromPtr(ptr.asInstanceOf[Ptr[Byte]])
    inline def apply(inline o: CFuncPtr4[GLenum, GLsizei, GLenum, GLboolean, Unit]): PFNGLHISTOGRAMEXTPROC = o
    extension (v: PFNGLHISTOGRAMEXTPROC)
      inline def value: CFuncPtr4[GLenum, GLsizei, GLenum, GLboolean, Unit] = v
      inline def toPtr: Ptr[?] = CFuncPtr.toPtr(v)

  opaque type PFNGLHISTOGRAMPROC = CFuncPtr4[GLenum, GLsizei, GLenum, GLboolean, Unit]
  object PFNGLHISTOGRAMPROC:
    given _tag: Tag[PFNGLHISTOGRAMPROC] = Tag.materializeCFuncPtr4[GLenum, GLsizei, GLenum, GLboolean, Unit]
    inline def fromPtr(ptr: Ptr[Byte] | Ptr[?]): PFNGLHISTOGRAMPROC = CFuncPtr.fromPtr(ptr.asInstanceOf[Ptr[Byte]])
    inline def apply(inline o: CFuncPtr4[GLenum, GLsizei, GLenum, GLboolean, Unit]): PFNGLHISTOGRAMPROC = o
    extension (v: PFNGLHISTOGRAMPROC)
      inline def value: CFuncPtr4[GLenum, GLsizei, GLenum, GLboolean, Unit] = v
      inline def toPtr: Ptr[?] = CFuncPtr.toPtr(v)

  opaque type PFNGLIGLOOINTERFACESGIXPROC = CFuncPtr2[GLenum, Ptr[Byte], Unit]
  object PFNGLIGLOOINTERFACESGIXPROC:
    given _tag: Tag[PFNGLIGLOOINTERFACESGIXPROC] = Tag.materializeCFuncPtr2[GLenum, Ptr[Byte], Unit]
    inline def fromPtr(ptr: Ptr[Byte] | Ptr[?]): PFNGLIGLOOINTERFACESGIXPROC = CFuncPtr.fromPtr(ptr.asInstanceOf[Ptr[Byte]])
    inline def apply(inline o: CFuncPtr2[GLenum, Ptr[Byte], Unit]): PFNGLIGLOOINTERFACESGIXPROC = o
    extension (v: PFNGLIGLOOINTERFACESGIXPROC)
      inline def value: CFuncPtr2[GLenum, Ptr[Byte], Unit] = v
      inline def toPtr: Ptr[?] = CFuncPtr.toPtr(v)

  opaque type PFNGLIMAGETRANSFORMPARAMETERFHPPROC = CFuncPtr3[GLenum, GLenum, GLfloat, Unit]
  object PFNGLIMAGETRANSFORMPARAMETERFHPPROC:
    given _tag: Tag[PFNGLIMAGETRANSFORMPARAMETERFHPPROC] = Tag.materializeCFuncPtr3[GLenum, GLenum, GLfloat, Unit]
    inline def fromPtr(ptr: Ptr[Byte] | Ptr[?]): PFNGLIMAGETRANSFORMPARAMETERFHPPROC = CFuncPtr.fromPtr(ptr.asInstanceOf[Ptr[Byte]])
    inline def apply(inline o: CFuncPtr3[GLenum, GLenum, GLfloat, Unit]): PFNGLIMAGETRANSFORMPARAMETERFHPPROC = o
    extension (v: PFNGLIMAGETRANSFORMPARAMETERFHPPROC)
      inline def value: CFuncPtr3[GLenum, GLenum, GLfloat, Unit] = v
      inline def toPtr: Ptr[?] = CFuncPtr.toPtr(v)

  opaque type PFNGLIMAGETRANSFORMPARAMETERFVHPPROC = CFuncPtr3[GLenum, GLenum, Ptr[GLfloat], Unit]
  object PFNGLIMAGETRANSFORMPARAMETERFVHPPROC:
    given _tag: Tag[PFNGLIMAGETRANSFORMPARAMETERFVHPPROC] = Tag.materializeCFuncPtr3[GLenum, GLenum, Ptr[GLfloat], Unit]
    inline def fromPtr(ptr: Ptr[Byte] | Ptr[?]): PFNGLIMAGETRANSFORMPARAMETERFVHPPROC = CFuncPtr.fromPtr(ptr.asInstanceOf[Ptr[Byte]])
    inline def apply(inline o: CFuncPtr3[GLenum, GLenum, Ptr[GLfloat], Unit]): PFNGLIMAGETRANSFORMPARAMETERFVHPPROC = o
    extension (v: PFNGLIMAGETRANSFORMPARAMETERFVHPPROC)
      inline def value: CFuncPtr3[GLenum, GLenum, Ptr[GLfloat], Unit] = v
      inline def toPtr: Ptr[?] = CFuncPtr.toPtr(v)

  opaque type PFNGLIMAGETRANSFORMPARAMETERIHPPROC = CFuncPtr3[GLenum, GLenum, GLint, Unit]
  object PFNGLIMAGETRANSFORMPARAMETERIHPPROC:
    given _tag: Tag[PFNGLIMAGETRANSFORMPARAMETERIHPPROC] = Tag.materializeCFuncPtr3[GLenum, GLenum, GLint, Unit]
    inline def fromPtr(ptr: Ptr[Byte] | Ptr[?]): PFNGLIMAGETRANSFORMPARAMETERIHPPROC = CFuncPtr.fromPtr(ptr.asInstanceOf[Ptr[Byte]])
    inline def apply(inline o: CFuncPtr3[GLenum, GLenum, GLint, Unit]): PFNGLIMAGETRANSFORMPARAMETERIHPPROC = o
    extension (v: PFNGLIMAGETRANSFORMPARAMETERIHPPROC)
      inline def value: CFuncPtr3[GLenum, GLenum, GLint, Unit] = v
      inline def toPtr: Ptr[?] = CFuncPtr.toPtr(v)

  opaque type PFNGLIMAGETRANSFORMPARAMETERIVHPPROC = CFuncPtr3[GLenum, GLenum, Ptr[GLint], Unit]
  object PFNGLIMAGETRANSFORMPARAMETERIVHPPROC:
    given _tag: Tag[PFNGLIMAGETRANSFORMPARAMETERIVHPPROC] = Tag.materializeCFuncPtr3[GLenum, GLenum, Ptr[GLint], Unit]
    inline def fromPtr(ptr: Ptr[Byte] | Ptr[?]): PFNGLIMAGETRANSFORMPARAMETERIVHPPROC = CFuncPtr.fromPtr(ptr.asInstanceOf[Ptr[Byte]])
    inline def apply(inline o: CFuncPtr3[GLenum, GLenum, Ptr[GLint], Unit]): PFNGLIMAGETRANSFORMPARAMETERIVHPPROC = o
    extension (v: PFNGLIMAGETRANSFORMPARAMETERIVHPPROC)
      inline def value: CFuncPtr3[GLenum, GLenum, Ptr[GLint], Unit] = v
      inline def toPtr: Ptr[?] = CFuncPtr.toPtr(v)

  opaque type PFNGLIMPORTMEMORYFDEXTPROC = CFuncPtr4[GLuint, GLuint64, GLenum, GLint, Unit]
  object PFNGLIMPORTMEMORYFDEXTPROC:
    given _tag: Tag[PFNGLIMPORTMEMORYFDEXTPROC] = Tag.materializeCFuncPtr4[GLuint, GLuint64, GLenum, GLint, Unit]
    inline def fromPtr(ptr: Ptr[Byte] | Ptr[?]): PFNGLIMPORTMEMORYFDEXTPROC = CFuncPtr.fromPtr(ptr.asInstanceOf[Ptr[Byte]])
    inline def apply(inline o: CFuncPtr4[GLuint, GLuint64, GLenum, GLint, Unit]): PFNGLIMPORTMEMORYFDEXTPROC = o
    extension (v: PFNGLIMPORTMEMORYFDEXTPROC)
      inline def value: CFuncPtr4[GLuint, GLuint64, GLenum, GLint, Unit] = v
      inline def toPtr: Ptr[?] = CFuncPtr.toPtr(v)

  opaque type PFNGLIMPORTMEMORYWIN32HANDLEEXTPROC = CFuncPtr4[GLuint, GLuint64, GLenum, Ptr[Byte], Unit]
  object PFNGLIMPORTMEMORYWIN32HANDLEEXTPROC:
    given _tag: Tag[PFNGLIMPORTMEMORYWIN32HANDLEEXTPROC] = Tag.materializeCFuncPtr4[GLuint, GLuint64, GLenum, Ptr[Byte], Unit]
    inline def fromPtr(ptr: Ptr[Byte] | Ptr[?]): PFNGLIMPORTMEMORYWIN32HANDLEEXTPROC = CFuncPtr.fromPtr(ptr.asInstanceOf[Ptr[Byte]])
    inline def apply(inline o: CFuncPtr4[GLuint, GLuint64, GLenum, Ptr[Byte], Unit]): PFNGLIMPORTMEMORYWIN32HANDLEEXTPROC = o
    extension (v: PFNGLIMPORTMEMORYWIN32HANDLEEXTPROC)
      inline def value: CFuncPtr4[GLuint, GLuint64, GLenum, Ptr[Byte], Unit] = v
      inline def toPtr: Ptr[?] = CFuncPtr.toPtr(v)

  opaque type PFNGLIMPORTMEMORYWIN32NAMEEXTPROC = CFuncPtr4[GLuint, GLuint64, GLenum, Ptr[Byte], Unit]
  object PFNGLIMPORTMEMORYWIN32NAMEEXTPROC:
    given _tag: Tag[PFNGLIMPORTMEMORYWIN32NAMEEXTPROC] = Tag.materializeCFuncPtr4[GLuint, GLuint64, GLenum, Ptr[Byte], Unit]
    inline def fromPtr(ptr: Ptr[Byte] | Ptr[?]): PFNGLIMPORTMEMORYWIN32NAMEEXTPROC = CFuncPtr.fromPtr(ptr.asInstanceOf[Ptr[Byte]])
    inline def apply(inline o: CFuncPtr4[GLuint, GLuint64, GLenum, Ptr[Byte], Unit]): PFNGLIMPORTMEMORYWIN32NAMEEXTPROC = o
    extension (v: PFNGLIMPORTMEMORYWIN32NAMEEXTPROC)
      inline def value: CFuncPtr4[GLuint, GLuint64, GLenum, Ptr[Byte], Unit] = v
      inline def toPtr: Ptr[?] = CFuncPtr.toPtr(v)

  opaque type PFNGLIMPORTSEMAPHOREFDEXTPROC = CFuncPtr3[GLuint, GLenum, GLint, Unit]
  object PFNGLIMPORTSEMAPHOREFDEXTPROC:
    given _tag: Tag[PFNGLIMPORTSEMAPHOREFDEXTPROC] = Tag.materializeCFuncPtr3[GLuint, GLenum, GLint, Unit]
    inline def fromPtr(ptr: Ptr[Byte] | Ptr[?]): PFNGLIMPORTSEMAPHOREFDEXTPROC = CFuncPtr.fromPtr(ptr.asInstanceOf[Ptr[Byte]])
    inline def apply(inline o: CFuncPtr3[GLuint, GLenum, GLint, Unit]): PFNGLIMPORTSEMAPHOREFDEXTPROC = o
    extension (v: PFNGLIMPORTSEMAPHOREFDEXTPROC)
      inline def value: CFuncPtr3[GLuint, GLenum, GLint, Unit] = v
      inline def toPtr: Ptr[?] = CFuncPtr.toPtr(v)

  opaque type PFNGLIMPORTSEMAPHOREWIN32HANDLEEXTPROC = CFuncPtr3[GLuint, GLenum, Ptr[Byte], Unit]
  object PFNGLIMPORTSEMAPHOREWIN32HANDLEEXTPROC:
    given _tag: Tag[PFNGLIMPORTSEMAPHOREWIN32HANDLEEXTPROC] = Tag.materializeCFuncPtr3[GLuint, GLenum, Ptr[Byte], Unit]
    inline def fromPtr(ptr: Ptr[Byte] | Ptr[?]): PFNGLIMPORTSEMAPHOREWIN32HANDLEEXTPROC = CFuncPtr.fromPtr(ptr.asInstanceOf[Ptr[Byte]])
    inline def apply(inline o: CFuncPtr3[GLuint, GLenum, Ptr[Byte], Unit]): PFNGLIMPORTSEMAPHOREWIN32HANDLEEXTPROC = o
    extension (v: PFNGLIMPORTSEMAPHOREWIN32HANDLEEXTPROC)
      inline def value: CFuncPtr3[GLuint, GLenum, Ptr[Byte], Unit] = v
      inline def toPtr: Ptr[?] = CFuncPtr.toPtr(v)

  opaque type PFNGLIMPORTSEMAPHOREWIN32NAMEEXTPROC = CFuncPtr3[GLuint, GLenum, Ptr[Byte], Unit]
  object PFNGLIMPORTSEMAPHOREWIN32NAMEEXTPROC:
    given _tag: Tag[PFNGLIMPORTSEMAPHOREWIN32NAMEEXTPROC] = Tag.materializeCFuncPtr3[GLuint, GLenum, Ptr[Byte], Unit]
    inline def fromPtr(ptr: Ptr[Byte] | Ptr[?]): PFNGLIMPORTSEMAPHOREWIN32NAMEEXTPROC = CFuncPtr.fromPtr(ptr.asInstanceOf[Ptr[Byte]])
    inline def apply(inline o: CFuncPtr3[GLuint, GLenum, Ptr[Byte], Unit]): PFNGLIMPORTSEMAPHOREWIN32NAMEEXTPROC = o
    extension (v: PFNGLIMPORTSEMAPHOREWIN32NAMEEXTPROC)
      inline def value: CFuncPtr3[GLuint, GLenum, Ptr[Byte], Unit] = v
      inline def toPtr: Ptr[?] = CFuncPtr.toPtr(v)

  opaque type PFNGLIMPORTSYNCEXTPROC = CFuncPtr3[GLenum, GLintptr, GLbitfield, GLsync]
  object PFNGLIMPORTSYNCEXTPROC:
    given _tag: Tag[PFNGLIMPORTSYNCEXTPROC] = Tag.materializeCFuncPtr3[GLenum, GLintptr, GLbitfield, GLsync]
    inline def fromPtr(ptr: Ptr[Byte] | Ptr[?]): PFNGLIMPORTSYNCEXTPROC = CFuncPtr.fromPtr(ptr.asInstanceOf[Ptr[Byte]])
    inline def apply(inline o: CFuncPtr3[GLenum, GLintptr, GLbitfield, GLsync]): PFNGLIMPORTSYNCEXTPROC = o
    extension (v: PFNGLIMPORTSYNCEXTPROC)
      inline def value: CFuncPtr3[GLenum, GLintptr, GLbitfield, GLsync] = v
      inline def toPtr: Ptr[?] = CFuncPtr.toPtr(v)

  opaque type PFNGLINDEXFORMATNVPROC = CFuncPtr2[GLenum, GLsizei, Unit]
  object PFNGLINDEXFORMATNVPROC:
    given _tag: Tag[PFNGLINDEXFORMATNVPROC] = Tag.materializeCFuncPtr2[GLenum, GLsizei, Unit]
    inline def fromPtr(ptr: Ptr[Byte] | Ptr[?]): PFNGLINDEXFORMATNVPROC = CFuncPtr.fromPtr(ptr.asInstanceOf[Ptr[Byte]])
    inline def apply(inline o: CFuncPtr2[GLenum, GLsizei, Unit]): PFNGLINDEXFORMATNVPROC = o
    extension (v: PFNGLINDEXFORMATNVPROC)
      inline def value: CFuncPtr2[GLenum, GLsizei, Unit] = v
      inline def toPtr: Ptr[?] = CFuncPtr.toPtr(v)

  opaque type PFNGLINDEXFUNCEXTPROC = CFuncPtr2[GLenum, GLfloat, Unit]
  object PFNGLINDEXFUNCEXTPROC:
    given _tag: Tag[PFNGLINDEXFUNCEXTPROC] = Tag.materializeCFuncPtr2[GLenum, GLfloat, Unit]
    inline def fromPtr(ptr: Ptr[Byte] | Ptr[?]): PFNGLINDEXFUNCEXTPROC = CFuncPtr.fromPtr(ptr.asInstanceOf[Ptr[Byte]])
    inline def apply(inline o: CFuncPtr2[GLenum, GLfloat, Unit]): PFNGLINDEXFUNCEXTPROC = o
    extension (v: PFNGLINDEXFUNCEXTPROC)
      inline def value: CFuncPtr2[GLenum, GLfloat, Unit] = v
      inline def toPtr: Ptr[?] = CFuncPtr.toPtr(v)

  opaque type PFNGLINDEXMATERIALEXTPROC = CFuncPtr2[GLenum, GLenum, Unit]
  object PFNGLINDEXMATERIALEXTPROC:
    given _tag: Tag[PFNGLINDEXMATERIALEXTPROC] = Tag.materializeCFuncPtr2[GLenum, GLenum, Unit]
    inline def fromPtr(ptr: Ptr[Byte] | Ptr[?]): PFNGLINDEXMATERIALEXTPROC = CFuncPtr.fromPtr(ptr.asInstanceOf[Ptr[Byte]])
    inline def apply(inline o: CFuncPtr2[GLenum, GLenum, Unit]): PFNGLINDEXMATERIALEXTPROC = o
    extension (v: PFNGLINDEXMATERIALEXTPROC)
      inline def value: CFuncPtr2[GLenum, GLenum, Unit] = v
      inline def toPtr: Ptr[?] = CFuncPtr.toPtr(v)

  opaque type PFNGLINDEXPOINTEREXTPROC = CFuncPtr4[GLenum, GLsizei, GLsizei, Ptr[Byte], Unit]
  object PFNGLINDEXPOINTEREXTPROC:
    given _tag: Tag[PFNGLINDEXPOINTEREXTPROC] = Tag.materializeCFuncPtr4[GLenum, GLsizei, GLsizei, Ptr[Byte], Unit]
    inline def fromPtr(ptr: Ptr[Byte] | Ptr[?]): PFNGLINDEXPOINTEREXTPROC = CFuncPtr.fromPtr(ptr.asInstanceOf[Ptr[Byte]])
    inline def apply(inline o: CFuncPtr4[GLenum, GLsizei, GLsizei, Ptr[Byte], Unit]): PFNGLINDEXPOINTEREXTPROC = o
    extension (v: PFNGLINDEXPOINTEREXTPROC)
      inline def value: CFuncPtr4[GLenum, GLsizei, GLsizei, Ptr[Byte], Unit] = v
      inline def toPtr: Ptr[?] = CFuncPtr.toPtr(v)

  opaque type PFNGLINDEXPOINTERLISTIBMPROC = CFuncPtr4[GLenum, GLint, Ptr[Ptr[Byte]], GLint, Unit]
  object PFNGLINDEXPOINTERLISTIBMPROC:
    given _tag: Tag[PFNGLINDEXPOINTERLISTIBMPROC] = Tag.materializeCFuncPtr4[GLenum, GLint, Ptr[Ptr[Byte]], GLint, Unit]
    inline def fromPtr(ptr: Ptr[Byte] | Ptr[?]): PFNGLINDEXPOINTERLISTIBMPROC = CFuncPtr.fromPtr(ptr.asInstanceOf[Ptr[Byte]])
    inline def apply(inline o: CFuncPtr4[GLenum, GLint, Ptr[Ptr[Byte]], GLint, Unit]): PFNGLINDEXPOINTERLISTIBMPROC = o
    extension (v: PFNGLINDEXPOINTERLISTIBMPROC)
      inline def value: CFuncPtr4[GLenum, GLint, Ptr[Ptr[Byte]], GLint, Unit] = v
      inline def toPtr: Ptr[?] = CFuncPtr.toPtr(v)

  opaque type PFNGLINSERTCOMPONENTEXTPROC = CFuncPtr3[GLuint, GLuint, GLuint, Unit]
  object PFNGLINSERTCOMPONENTEXTPROC:
    given _tag: Tag[PFNGLINSERTCOMPONENTEXTPROC] = Tag.materializeCFuncPtr3[GLuint, GLuint, GLuint, Unit]
    inline def fromPtr(ptr: Ptr[Byte] | Ptr[?]): PFNGLINSERTCOMPONENTEXTPROC = CFuncPtr.fromPtr(ptr.asInstanceOf[Ptr[Byte]])
    inline def apply(inline o: CFuncPtr3[GLuint, GLuint, GLuint, Unit]): PFNGLINSERTCOMPONENTEXTPROC = o
    extension (v: PFNGLINSERTCOMPONENTEXTPROC)
      inline def value: CFuncPtr3[GLuint, GLuint, GLuint, Unit] = v
      inline def toPtr: Ptr[?] = CFuncPtr.toPtr(v)

  opaque type PFNGLINSERTEVENTMARKEREXTPROC = CFuncPtr2[GLsizei, Ptr[GLchar], Unit]
  object PFNGLINSERTEVENTMARKEREXTPROC:
    given _tag: Tag[PFNGLINSERTEVENTMARKEREXTPROC] = Tag.materializeCFuncPtr2[GLsizei, Ptr[GLchar], Unit]
    inline def fromPtr(ptr: Ptr[Byte] | Ptr[?]): PFNGLINSERTEVENTMARKEREXTPROC = CFuncPtr.fromPtr(ptr.asInstanceOf[Ptr[Byte]])
    inline def apply(inline o: CFuncPtr2[GLsizei, Ptr[GLchar], Unit]): PFNGLINSERTEVENTMARKEREXTPROC = o
    extension (v: PFNGLINSERTEVENTMARKEREXTPROC)
      inline def value: CFuncPtr2[GLsizei, Ptr[GLchar], Unit] = v
      inline def toPtr: Ptr[?] = CFuncPtr.toPtr(v)

  opaque type PFNGLINTERLEAVEDTEXTURECOORDSETSSGISPROC = CFuncPtr1[GLint, Unit]
  object PFNGLINTERLEAVEDTEXTURECOORDSETSSGISPROC:
    given _tag: Tag[PFNGLINTERLEAVEDTEXTURECOORDSETSSGISPROC] = Tag.materializeCFuncPtr1[GLint, Unit]
    inline def fromPtr(ptr: Ptr[Byte] | Ptr[?]): PFNGLINTERLEAVEDTEXTURECOORDSETSSGISPROC = CFuncPtr.fromPtr(ptr.asInstanceOf[Ptr[Byte]])
    inline def apply(inline o: CFuncPtr1[GLint, Unit]): PFNGLINTERLEAVEDTEXTURECOORDSETSSGISPROC = o
    extension (v: PFNGLINTERLEAVEDTEXTURECOORDSETSSGISPROC)
      inline def value: CFuncPtr1[GLint, Unit] = v
      inline def toPtr: Ptr[?] = CFuncPtr.toPtr(v)

  opaque type PFNGLINTERPOLATEPATHSNVPROC = CFuncPtr4[GLuint, GLuint, GLuint, GLfloat, Unit]
  object PFNGLINTERPOLATEPATHSNVPROC:
    given _tag: Tag[PFNGLINTERPOLATEPATHSNVPROC] = Tag.materializeCFuncPtr4[GLuint, GLuint, GLuint, GLfloat, Unit]
    inline def fromPtr(ptr: Ptr[Byte] | Ptr[?]): PFNGLINTERPOLATEPATHSNVPROC = CFuncPtr.fromPtr(ptr.asInstanceOf[Ptr[Byte]])
    inline def apply(inline o: CFuncPtr4[GLuint, GLuint, GLuint, GLfloat, Unit]): PFNGLINTERPOLATEPATHSNVPROC = o
    extension (v: PFNGLINTERPOLATEPATHSNVPROC)
      inline def value: CFuncPtr4[GLuint, GLuint, GLuint, GLfloat, Unit] = v
      inline def toPtr: Ptr[?] = CFuncPtr.toPtr(v)

  opaque type PFNGLINVALIDATEBUFFERDATAPROC = CFuncPtr1[GLuint, Unit]
  object PFNGLINVALIDATEBUFFERDATAPROC:
    given _tag: Tag[PFNGLINVALIDATEBUFFERDATAPROC] = Tag.materializeCFuncPtr1[GLuint, Unit]
    inline def fromPtr(ptr: Ptr[Byte] | Ptr[?]): PFNGLINVALIDATEBUFFERDATAPROC = CFuncPtr.fromPtr(ptr.asInstanceOf[Ptr[Byte]])
    inline def apply(inline o: CFuncPtr1[GLuint, Unit]): PFNGLINVALIDATEBUFFERDATAPROC = o
    extension (v: PFNGLINVALIDATEBUFFERDATAPROC)
      inline def value: CFuncPtr1[GLuint, Unit] = v
      inline def toPtr: Ptr[?] = CFuncPtr.toPtr(v)

  opaque type PFNGLINVALIDATEBUFFERSUBDATAPROC = CFuncPtr3[GLuint, GLintptr, GLsizeiptr, Unit]
  object PFNGLINVALIDATEBUFFERSUBDATAPROC:
    given _tag: Tag[PFNGLINVALIDATEBUFFERSUBDATAPROC] = Tag.materializeCFuncPtr3[GLuint, GLintptr, GLsizeiptr, Unit]
    inline def fromPtr(ptr: Ptr[Byte] | Ptr[?]): PFNGLINVALIDATEBUFFERSUBDATAPROC = CFuncPtr.fromPtr(ptr.asInstanceOf[Ptr[Byte]])
    inline def apply(inline o: CFuncPtr3[GLuint, GLintptr, GLsizeiptr, Unit]): PFNGLINVALIDATEBUFFERSUBDATAPROC = o
    extension (v: PFNGLINVALIDATEBUFFERSUBDATAPROC)
      inline def value: CFuncPtr3[GLuint, GLintptr, GLsizeiptr, Unit] = v
      inline def toPtr: Ptr[?] = CFuncPtr.toPtr(v)

  opaque type PFNGLINVALIDATEFRAMEBUFFERPROC = CFuncPtr3[GLenum, GLsizei, Ptr[GLenum], Unit]
  object PFNGLINVALIDATEFRAMEBUFFERPROC:
    given _tag: Tag[PFNGLINVALIDATEFRAMEBUFFERPROC] = Tag.materializeCFuncPtr3[GLenum, GLsizei, Ptr[GLenum], Unit]
    inline def fromPtr(ptr: Ptr[Byte] | Ptr[?]): PFNGLINVALIDATEFRAMEBUFFERPROC = CFuncPtr.fromPtr(ptr.asInstanceOf[Ptr[Byte]])
    inline def apply(inline o: CFuncPtr3[GLenum, GLsizei, Ptr[GLenum], Unit]): PFNGLINVALIDATEFRAMEBUFFERPROC = o
    extension (v: PFNGLINVALIDATEFRAMEBUFFERPROC)
      inline def value: CFuncPtr3[GLenum, GLsizei, Ptr[GLenum], Unit] = v
      inline def toPtr: Ptr[?] = CFuncPtr.toPtr(v)

  opaque type PFNGLINVALIDATENAMEDFRAMEBUFFERDATAPROC = CFuncPtr3[GLuint, GLsizei, Ptr[GLenum], Unit]
  object PFNGLINVALIDATENAMEDFRAMEBUFFERDATAPROC:
    given _tag: Tag[PFNGLINVALIDATENAMEDFRAMEBUFFERDATAPROC] = Tag.materializeCFuncPtr3[GLuint, GLsizei, Ptr[GLenum], Unit]
    inline def fromPtr(ptr: Ptr[Byte] | Ptr[?]): PFNGLINVALIDATENAMEDFRAMEBUFFERDATAPROC = CFuncPtr.fromPtr(ptr.asInstanceOf[Ptr[Byte]])
    inline def apply(inline o: CFuncPtr3[GLuint, GLsizei, Ptr[GLenum], Unit]): PFNGLINVALIDATENAMEDFRAMEBUFFERDATAPROC = o
    extension (v: PFNGLINVALIDATENAMEDFRAMEBUFFERDATAPROC)
      inline def value: CFuncPtr3[GLuint, GLsizei, Ptr[GLenum], Unit] = v
      inline def toPtr: Ptr[?] = CFuncPtr.toPtr(v)

  opaque type PFNGLINVALIDATENAMEDFRAMEBUFFERSUBDATAPROC = CFuncPtr7[GLuint, GLsizei, Ptr[GLenum], GLint, GLint, GLsizei, GLsizei, Unit]
  object PFNGLINVALIDATENAMEDFRAMEBUFFERSUBDATAPROC:
    given _tag: Tag[PFNGLINVALIDATENAMEDFRAMEBUFFERSUBDATAPROC] = Tag.materializeCFuncPtr7[GLuint, GLsizei, Ptr[GLenum], GLint, GLint, GLsizei, GLsizei, Unit]
    inline def fromPtr(ptr: Ptr[Byte] | Ptr[?]): PFNGLINVALIDATENAMEDFRAMEBUFFERSUBDATAPROC = CFuncPtr.fromPtr(ptr.asInstanceOf[Ptr[Byte]])
    inline def apply(inline o: CFuncPtr7[GLuint, GLsizei, Ptr[GLenum], GLint, GLint, GLsizei, GLsizei, Unit]): PFNGLINVALIDATENAMEDFRAMEBUFFERSUBDATAPROC = o
    extension (v: PFNGLINVALIDATENAMEDFRAMEBUFFERSUBDATAPROC)
      inline def value: CFuncPtr7[GLuint, GLsizei, Ptr[GLenum], GLint, GLint, GLsizei, GLsizei, Unit] = v
      inline def toPtr: Ptr[?] = CFuncPtr.toPtr(v)

  opaque type PFNGLINVALIDATESUBFRAMEBUFFERPROC = CFuncPtr7[GLenum, GLsizei, Ptr[GLenum], GLint, GLint, GLsizei, GLsizei, Unit]
  object PFNGLINVALIDATESUBFRAMEBUFFERPROC:
    given _tag: Tag[PFNGLINVALIDATESUBFRAMEBUFFERPROC] = Tag.materializeCFuncPtr7[GLenum, GLsizei, Ptr[GLenum], GLint, GLint, GLsizei, GLsizei, Unit]
    inline def fromPtr(ptr: Ptr[Byte] | Ptr[?]): PFNGLINVALIDATESUBFRAMEBUFFERPROC = CFuncPtr.fromPtr(ptr.asInstanceOf[Ptr[Byte]])
    inline def apply(inline o: CFuncPtr7[GLenum, GLsizei, Ptr[GLenum], GLint, GLint, GLsizei, GLsizei, Unit]): PFNGLINVALIDATESUBFRAMEBUFFERPROC = o
    extension (v: PFNGLINVALIDATESUBFRAMEBUFFERPROC)
      inline def value: CFuncPtr7[GLenum, GLsizei, Ptr[GLenum], GLint, GLint, GLsizei, GLsizei, Unit] = v
      inline def toPtr: Ptr[?] = CFuncPtr.toPtr(v)

  opaque type PFNGLINVALIDATETEXIMAGEPROC = CFuncPtr2[GLuint, GLint, Unit]
  object PFNGLINVALIDATETEXIMAGEPROC:
    given _tag: Tag[PFNGLINVALIDATETEXIMAGEPROC] = Tag.materializeCFuncPtr2[GLuint, GLint, Unit]
    inline def fromPtr(ptr: Ptr[Byte] | Ptr[?]): PFNGLINVALIDATETEXIMAGEPROC = CFuncPtr.fromPtr(ptr.asInstanceOf[Ptr[Byte]])
    inline def apply(inline o: CFuncPtr2[GLuint, GLint, Unit]): PFNGLINVALIDATETEXIMAGEPROC = o
    extension (v: PFNGLINVALIDATETEXIMAGEPROC)
      inline def value: CFuncPtr2[GLuint, GLint, Unit] = v
      inline def toPtr: Ptr[?] = CFuncPtr.toPtr(v)

  opaque type PFNGLINVALIDATETEXSUBIMAGEPROC = CFuncPtr8[GLuint, GLint, GLint, GLint, GLint, GLsizei, GLsizei, GLsizei, Unit]
  object PFNGLINVALIDATETEXSUBIMAGEPROC:
    given _tag: Tag[PFNGLINVALIDATETEXSUBIMAGEPROC] = Tag.materializeCFuncPtr8[GLuint, GLint, GLint, GLint, GLint, GLsizei, GLsizei, GLsizei, Unit]
    inline def fromPtr(ptr: Ptr[Byte] | Ptr[?]): PFNGLINVALIDATETEXSUBIMAGEPROC = CFuncPtr.fromPtr(ptr.asInstanceOf[Ptr[Byte]])
    inline def apply(inline o: CFuncPtr8[GLuint, GLint, GLint, GLint, GLint, GLsizei, GLsizei, GLsizei, Unit]): PFNGLINVALIDATETEXSUBIMAGEPROC = o
    extension (v: PFNGLINVALIDATETEXSUBIMAGEPROC)
      inline def value: CFuncPtr8[GLuint, GLint, GLint, GLint, GLint, GLsizei, GLsizei, GLsizei, Unit] = v
      inline def toPtr: Ptr[?] = CFuncPtr.toPtr(v)

  opaque type PFNGLISASYNCMARKERSGIXPROC = CFuncPtr1[GLuint, GLboolean]
  object PFNGLISASYNCMARKERSGIXPROC:
    given _tag: Tag[PFNGLISASYNCMARKERSGIXPROC] = Tag.materializeCFuncPtr1[GLuint, GLboolean]
    inline def fromPtr(ptr: Ptr[Byte] | Ptr[?]): PFNGLISASYNCMARKERSGIXPROC = CFuncPtr.fromPtr(ptr.asInstanceOf[Ptr[Byte]])
    inline def apply(inline o: CFuncPtr1[GLuint, GLboolean]): PFNGLISASYNCMARKERSGIXPROC = o
    extension (v: PFNGLISASYNCMARKERSGIXPROC)
      inline def value: CFuncPtr1[GLuint, GLboolean] = v
      inline def toPtr: Ptr[?] = CFuncPtr.toPtr(v)

  opaque type PFNGLISBUFFERARBPROC = CFuncPtr1[GLuint, GLboolean]
  object PFNGLISBUFFERARBPROC:
    given _tag: Tag[PFNGLISBUFFERARBPROC] = Tag.materializeCFuncPtr1[GLuint, GLboolean]
    inline def fromPtr(ptr: Ptr[Byte] | Ptr[?]): PFNGLISBUFFERARBPROC = CFuncPtr.fromPtr(ptr.asInstanceOf[Ptr[Byte]])
    inline def apply(inline o: CFuncPtr1[GLuint, GLboolean]): PFNGLISBUFFERARBPROC = o
    extension (v: PFNGLISBUFFERARBPROC)
      inline def value: CFuncPtr1[GLuint, GLboolean] = v
      inline def toPtr: Ptr[?] = CFuncPtr.toPtr(v)

  opaque type PFNGLISBUFFERPROC = CFuncPtr1[GLuint, GLboolean]
  object PFNGLISBUFFERPROC:
    given _tag: Tag[PFNGLISBUFFERPROC] = Tag.materializeCFuncPtr1[GLuint, GLboolean]
    inline def fromPtr(ptr: Ptr[Byte] | Ptr[?]): PFNGLISBUFFERPROC = CFuncPtr.fromPtr(ptr.asInstanceOf[Ptr[Byte]])
    inline def apply(inline o: CFuncPtr1[GLuint, GLboolean]): PFNGLISBUFFERPROC = o
    extension (v: PFNGLISBUFFERPROC)
      inline def value: CFuncPtr1[GLuint, GLboolean] = v
      inline def toPtr: Ptr[?] = CFuncPtr.toPtr(v)

  opaque type PFNGLISBUFFERRESIDENTNVPROC = CFuncPtr1[GLenum, GLboolean]
  object PFNGLISBUFFERRESIDENTNVPROC:
    given _tag: Tag[PFNGLISBUFFERRESIDENTNVPROC] = Tag.materializeCFuncPtr1[GLenum, GLboolean]
    inline def fromPtr(ptr: Ptr[Byte] | Ptr[?]): PFNGLISBUFFERRESIDENTNVPROC = CFuncPtr.fromPtr(ptr.asInstanceOf[Ptr[Byte]])
    inline def apply(inline o: CFuncPtr1[GLenum, GLboolean]): PFNGLISBUFFERRESIDENTNVPROC = o
    extension (v: PFNGLISBUFFERRESIDENTNVPROC)
      inline def value: CFuncPtr1[GLenum, GLboolean] = v
      inline def toPtr: Ptr[?] = CFuncPtr.toPtr(v)

  opaque type PFNGLISCOMMANDLISTNVPROC = CFuncPtr1[GLuint, GLboolean]
  object PFNGLISCOMMANDLISTNVPROC:
    given _tag: Tag[PFNGLISCOMMANDLISTNVPROC] = Tag.materializeCFuncPtr1[GLuint, GLboolean]
    inline def fromPtr(ptr: Ptr[Byte] | Ptr[?]): PFNGLISCOMMANDLISTNVPROC = CFuncPtr.fromPtr(ptr.asInstanceOf[Ptr[Byte]])
    inline def apply(inline o: CFuncPtr1[GLuint, GLboolean]): PFNGLISCOMMANDLISTNVPROC = o
    extension (v: PFNGLISCOMMANDLISTNVPROC)
      inline def value: CFuncPtr1[GLuint, GLboolean] = v
      inline def toPtr: Ptr[?] = CFuncPtr.toPtr(v)

  opaque type PFNGLISENABLEDIEXTPROC = CFuncPtr2[GLenum, GLuint, GLboolean]
  object PFNGLISENABLEDIEXTPROC:
    given _tag: Tag[PFNGLISENABLEDIEXTPROC] = Tag.materializeCFuncPtr2[GLenum, GLuint, GLboolean]
    inline def fromPtr(ptr: Ptr[Byte] | Ptr[?]): PFNGLISENABLEDIEXTPROC = CFuncPtr.fromPtr(ptr.asInstanceOf[Ptr[Byte]])
    inline def apply(inline o: CFuncPtr2[GLenum, GLuint, GLboolean]): PFNGLISENABLEDIEXTPROC = o
    extension (v: PFNGLISENABLEDIEXTPROC)
      inline def value: CFuncPtr2[GLenum, GLuint, GLboolean] = v
      inline def toPtr: Ptr[?] = CFuncPtr.toPtr(v)

  opaque type PFNGLISENABLEDINDEXEDEXTPROC = CFuncPtr2[GLenum, GLuint, GLboolean]
  object PFNGLISENABLEDINDEXEDEXTPROC:
    given _tag: Tag[PFNGLISENABLEDINDEXEDEXTPROC] = Tag.materializeCFuncPtr2[GLenum, GLuint, GLboolean]
    inline def fromPtr(ptr: Ptr[Byte] | Ptr[?]): PFNGLISENABLEDINDEXEDEXTPROC = CFuncPtr.fromPtr(ptr.asInstanceOf[Ptr[Byte]])
    inline def apply(inline o: CFuncPtr2[GLenum, GLuint, GLboolean]): PFNGLISENABLEDINDEXEDEXTPROC = o
    extension (v: PFNGLISENABLEDINDEXEDEXTPROC)
      inline def value: CFuncPtr2[GLenum, GLuint, GLboolean] = v
      inline def toPtr: Ptr[?] = CFuncPtr.toPtr(v)

  opaque type PFNGLISENABLEDINVPROC = CFuncPtr2[GLenum, GLuint, GLboolean]
  object PFNGLISENABLEDINVPROC:
    given _tag: Tag[PFNGLISENABLEDINVPROC] = Tag.materializeCFuncPtr2[GLenum, GLuint, GLboolean]
    inline def fromPtr(ptr: Ptr[Byte] | Ptr[?]): PFNGLISENABLEDINVPROC = CFuncPtr.fromPtr(ptr.asInstanceOf[Ptr[Byte]])
    inline def apply(inline o: CFuncPtr2[GLenum, GLuint, GLboolean]): PFNGLISENABLEDINVPROC = o
    extension (v: PFNGLISENABLEDINVPROC)
      inline def value: CFuncPtr2[GLenum, GLuint, GLboolean] = v
      inline def toPtr: Ptr[?] = CFuncPtr.toPtr(v)

  opaque type PFNGLISENABLEDIOESPROC = CFuncPtr2[GLenum, GLuint, GLboolean]
  object PFNGLISENABLEDIOESPROC:
    given _tag: Tag[PFNGLISENABLEDIOESPROC] = Tag.materializeCFuncPtr2[GLenum, GLuint, GLboolean]
    inline def fromPtr(ptr: Ptr[Byte] | Ptr[?]): PFNGLISENABLEDIOESPROC = CFuncPtr.fromPtr(ptr.asInstanceOf[Ptr[Byte]])
    inline def apply(inline o: CFuncPtr2[GLenum, GLuint, GLboolean]): PFNGLISENABLEDIOESPROC = o
    extension (v: PFNGLISENABLEDIOESPROC)
      inline def value: CFuncPtr2[GLenum, GLuint, GLboolean] = v
      inline def toPtr: Ptr[?] = CFuncPtr.toPtr(v)

  opaque type PFNGLISENABLEDIPROC = CFuncPtr2[GLenum, GLuint, GLboolean]
  object PFNGLISENABLEDIPROC:
    given _tag: Tag[PFNGLISENABLEDIPROC] = Tag.materializeCFuncPtr2[GLenum, GLuint, GLboolean]
    inline def fromPtr(ptr: Ptr[Byte] | Ptr[?]): PFNGLISENABLEDIPROC = CFuncPtr.fromPtr(ptr.asInstanceOf[Ptr[Byte]])
    inline def apply(inline o: CFuncPtr2[GLenum, GLuint, GLboolean]): PFNGLISENABLEDIPROC = o
    extension (v: PFNGLISENABLEDIPROC)
      inline def value: CFuncPtr2[GLenum, GLuint, GLboolean] = v
      inline def toPtr: Ptr[?] = CFuncPtr.toPtr(v)

  opaque type PFNGLISFENCEAPPLEPROC = CFuncPtr1[GLuint, GLboolean]
  object PFNGLISFENCEAPPLEPROC:
    given _tag: Tag[PFNGLISFENCEAPPLEPROC] = Tag.materializeCFuncPtr1[GLuint, GLboolean]
    inline def fromPtr(ptr: Ptr[Byte] | Ptr[?]): PFNGLISFENCEAPPLEPROC = CFuncPtr.fromPtr(ptr.asInstanceOf[Ptr[Byte]])
    inline def apply(inline o: CFuncPtr1[GLuint, GLboolean]): PFNGLISFENCEAPPLEPROC = o
    extension (v: PFNGLISFENCEAPPLEPROC)
      inline def value: CFuncPtr1[GLuint, GLboolean] = v
      inline def toPtr: Ptr[?] = CFuncPtr.toPtr(v)

  opaque type PFNGLISFENCENVPROC = CFuncPtr1[GLuint, GLboolean]
  object PFNGLISFENCENVPROC:
    given _tag: Tag[PFNGLISFENCENVPROC] = Tag.materializeCFuncPtr1[GLuint, GLboolean]
    inline def fromPtr(ptr: Ptr[Byte] | Ptr[?]): PFNGLISFENCENVPROC = CFuncPtr.fromPtr(ptr.asInstanceOf[Ptr[Byte]])
    inline def apply(inline o: CFuncPtr1[GLuint, GLboolean]): PFNGLISFENCENVPROC = o
    extension (v: PFNGLISFENCENVPROC)
      inline def value: CFuncPtr1[GLuint, GLboolean] = v
      inline def toPtr: Ptr[?] = CFuncPtr.toPtr(v)

  opaque type PFNGLISFRAMEBUFFEREXTPROC = CFuncPtr1[GLuint, GLboolean]
  object PFNGLISFRAMEBUFFEREXTPROC:
    given _tag: Tag[PFNGLISFRAMEBUFFEREXTPROC] = Tag.materializeCFuncPtr1[GLuint, GLboolean]
    inline def fromPtr(ptr: Ptr[Byte] | Ptr[?]): PFNGLISFRAMEBUFFEREXTPROC = CFuncPtr.fromPtr(ptr.asInstanceOf[Ptr[Byte]])
    inline def apply(inline o: CFuncPtr1[GLuint, GLboolean]): PFNGLISFRAMEBUFFEREXTPROC = o
    extension (v: PFNGLISFRAMEBUFFEREXTPROC)
      inline def value: CFuncPtr1[GLuint, GLboolean] = v
      inline def toPtr: Ptr[?] = CFuncPtr.toPtr(v)

  opaque type PFNGLISFRAMEBUFFEROESPROC = CFuncPtr1[GLuint, GLboolean]
  object PFNGLISFRAMEBUFFEROESPROC:
    given _tag: Tag[PFNGLISFRAMEBUFFEROESPROC] = Tag.materializeCFuncPtr1[GLuint, GLboolean]
    inline def fromPtr(ptr: Ptr[Byte] | Ptr[?]): PFNGLISFRAMEBUFFEROESPROC = CFuncPtr.fromPtr(ptr.asInstanceOf[Ptr[Byte]])
    inline def apply(inline o: CFuncPtr1[GLuint, GLboolean]): PFNGLISFRAMEBUFFEROESPROC = o
    extension (v: PFNGLISFRAMEBUFFEROESPROC)
      inline def value: CFuncPtr1[GLuint, GLboolean] = v
      inline def toPtr: Ptr[?] = CFuncPtr.toPtr(v)

  opaque type PFNGLISFRAMEBUFFERPROC = CFuncPtr1[GLuint, GLboolean]
  object PFNGLISFRAMEBUFFERPROC:
    given _tag: Tag[PFNGLISFRAMEBUFFERPROC] = Tag.materializeCFuncPtr1[GLuint, GLboolean]
    inline def fromPtr(ptr: Ptr[Byte] | Ptr[?]): PFNGLISFRAMEBUFFERPROC = CFuncPtr.fromPtr(ptr.asInstanceOf[Ptr[Byte]])
    inline def apply(inline o: CFuncPtr1[GLuint, GLboolean]): PFNGLISFRAMEBUFFERPROC = o
    extension (v: PFNGLISFRAMEBUFFERPROC)
      inline def value: CFuncPtr1[GLuint, GLboolean] = v
      inline def toPtr: Ptr[?] = CFuncPtr.toPtr(v)

  opaque type PFNGLISIMAGEHANDLERESIDENTARBPROC = CFuncPtr1[GLuint64, GLboolean]
  object PFNGLISIMAGEHANDLERESIDENTARBPROC:
    given _tag: Tag[PFNGLISIMAGEHANDLERESIDENTARBPROC] = Tag.materializeCFuncPtr1[GLuint64, GLboolean]
    inline def fromPtr(ptr: Ptr[Byte] | Ptr[?]): PFNGLISIMAGEHANDLERESIDENTARBPROC = CFuncPtr.fromPtr(ptr.asInstanceOf[Ptr[Byte]])
    inline def apply(inline o: CFuncPtr1[GLuint64, GLboolean]): PFNGLISIMAGEHANDLERESIDENTARBPROC = o
    extension (v: PFNGLISIMAGEHANDLERESIDENTARBPROC)
      inline def value: CFuncPtr1[GLuint64, GLboolean] = v
      inline def toPtr: Ptr[?] = CFuncPtr.toPtr(v)

  opaque type PFNGLISIMAGEHANDLERESIDENTNVPROC = CFuncPtr1[GLuint64, GLboolean]
  object PFNGLISIMAGEHANDLERESIDENTNVPROC:
    given _tag: Tag[PFNGLISIMAGEHANDLERESIDENTNVPROC] = Tag.materializeCFuncPtr1[GLuint64, GLboolean]
    inline def fromPtr(ptr: Ptr[Byte] | Ptr[?]): PFNGLISIMAGEHANDLERESIDENTNVPROC = CFuncPtr.fromPtr(ptr.asInstanceOf[Ptr[Byte]])
    inline def apply(inline o: CFuncPtr1[GLuint64, GLboolean]): PFNGLISIMAGEHANDLERESIDENTNVPROC = o
    extension (v: PFNGLISIMAGEHANDLERESIDENTNVPROC)
      inline def value: CFuncPtr1[GLuint64, GLboolean] = v
      inline def toPtr: Ptr[?] = CFuncPtr.toPtr(v)

  opaque type PFNGLISMEMORYOBJECTEXTPROC = CFuncPtr1[GLuint, GLboolean]
  object PFNGLISMEMORYOBJECTEXTPROC:
    given _tag: Tag[PFNGLISMEMORYOBJECTEXTPROC] = Tag.materializeCFuncPtr1[GLuint, GLboolean]
    inline def fromPtr(ptr: Ptr[Byte] | Ptr[?]): PFNGLISMEMORYOBJECTEXTPROC = CFuncPtr.fromPtr(ptr.asInstanceOf[Ptr[Byte]])
    inline def apply(inline o: CFuncPtr1[GLuint, GLboolean]): PFNGLISMEMORYOBJECTEXTPROC = o
    extension (v: PFNGLISMEMORYOBJECTEXTPROC)
      inline def value: CFuncPtr1[GLuint, GLboolean] = v
      inline def toPtr: Ptr[?] = CFuncPtr.toPtr(v)

  opaque type PFNGLISMPEGPREDICTORSGIXPROC = CFuncPtr1[GLuint, GLboolean]
  object PFNGLISMPEGPREDICTORSGIXPROC:
    given _tag: Tag[PFNGLISMPEGPREDICTORSGIXPROC] = Tag.materializeCFuncPtr1[GLuint, GLboolean]
    inline def fromPtr(ptr: Ptr[Byte] | Ptr[?]): PFNGLISMPEGPREDICTORSGIXPROC = CFuncPtr.fromPtr(ptr.asInstanceOf[Ptr[Byte]])
    inline def apply(inline o: CFuncPtr1[GLuint, GLboolean]): PFNGLISMPEGPREDICTORSGIXPROC = o
    extension (v: PFNGLISMPEGPREDICTORSGIXPROC)
      inline def value: CFuncPtr1[GLuint, GLboolean] = v
      inline def toPtr: Ptr[?] = CFuncPtr.toPtr(v)

  opaque type PFNGLISNAMEAMDPROC = CFuncPtr2[GLenum, GLuint, GLboolean]
  object PFNGLISNAMEAMDPROC:
    given _tag: Tag[PFNGLISNAMEAMDPROC] = Tag.materializeCFuncPtr2[GLenum, GLuint, GLboolean]
    inline def fromPtr(ptr: Ptr[Byte] | Ptr[?]): PFNGLISNAMEAMDPROC = CFuncPtr.fromPtr(ptr.asInstanceOf[Ptr[Byte]])
    inline def apply(inline o: CFuncPtr2[GLenum, GLuint, GLboolean]): PFNGLISNAMEAMDPROC = o
    extension (v: PFNGLISNAMEAMDPROC)
      inline def value: CFuncPtr2[GLenum, GLuint, GLboolean] = v
      inline def toPtr: Ptr[?] = CFuncPtr.toPtr(v)

  opaque type PFNGLISNAMEDBUFFERRESIDENTNVPROC = CFuncPtr1[GLuint, GLboolean]
  object PFNGLISNAMEDBUFFERRESIDENTNVPROC:
    given _tag: Tag[PFNGLISNAMEDBUFFERRESIDENTNVPROC] = Tag.materializeCFuncPtr1[GLuint, GLboolean]
    inline def fromPtr(ptr: Ptr[Byte] | Ptr[?]): PFNGLISNAMEDBUFFERRESIDENTNVPROC = CFuncPtr.fromPtr(ptr.asInstanceOf[Ptr[Byte]])
    inline def apply(inline o: CFuncPtr1[GLuint, GLboolean]): PFNGLISNAMEDBUFFERRESIDENTNVPROC = o
    extension (v: PFNGLISNAMEDBUFFERRESIDENTNVPROC)
      inline def value: CFuncPtr1[GLuint, GLboolean] = v
      inline def toPtr: Ptr[?] = CFuncPtr.toPtr(v)

  opaque type PFNGLISNAMEDSTRINGARBPROC = CFuncPtr2[GLint, Ptr[GLchar], GLboolean]
  object PFNGLISNAMEDSTRINGARBPROC:
    given _tag: Tag[PFNGLISNAMEDSTRINGARBPROC] = Tag.materializeCFuncPtr2[GLint, Ptr[GLchar], GLboolean]
    inline def fromPtr(ptr: Ptr[Byte] | Ptr[?]): PFNGLISNAMEDSTRINGARBPROC = CFuncPtr.fromPtr(ptr.asInstanceOf[Ptr[Byte]])
    inline def apply(inline o: CFuncPtr2[GLint, Ptr[GLchar], GLboolean]): PFNGLISNAMEDSTRINGARBPROC = o
    extension (v: PFNGLISNAMEDSTRINGARBPROC)
      inline def value: CFuncPtr2[GLint, Ptr[GLchar], GLboolean] = v
      inline def toPtr: Ptr[?] = CFuncPtr.toPtr(v)

  opaque type PFNGLISOBJECTBUFFERATIPROC = CFuncPtr1[GLuint, GLboolean]
  object PFNGLISOBJECTBUFFERATIPROC:
    given _tag: Tag[PFNGLISOBJECTBUFFERATIPROC] = Tag.materializeCFuncPtr1[GLuint, GLboolean]
    inline def fromPtr(ptr: Ptr[Byte] | Ptr[?]): PFNGLISOBJECTBUFFERATIPROC = CFuncPtr.fromPtr(ptr.asInstanceOf[Ptr[Byte]])
    inline def apply(inline o: CFuncPtr1[GLuint, GLboolean]): PFNGLISOBJECTBUFFERATIPROC = o
    extension (v: PFNGLISOBJECTBUFFERATIPROC)
      inline def value: CFuncPtr1[GLuint, GLboolean] = v
      inline def toPtr: Ptr[?] = CFuncPtr.toPtr(v)

  opaque type PFNGLISOCCLUSIONQUERYNVPROC = CFuncPtr1[GLuint, GLboolean]
  object PFNGLISOCCLUSIONQUERYNVPROC:
    given _tag: Tag[PFNGLISOCCLUSIONQUERYNVPROC] = Tag.materializeCFuncPtr1[GLuint, GLboolean]
    inline def fromPtr(ptr: Ptr[Byte] | Ptr[?]): PFNGLISOCCLUSIONQUERYNVPROC = CFuncPtr.fromPtr(ptr.asInstanceOf[Ptr[Byte]])
    inline def apply(inline o: CFuncPtr1[GLuint, GLboolean]): PFNGLISOCCLUSIONQUERYNVPROC = o
    extension (v: PFNGLISOCCLUSIONQUERYNVPROC)
      inline def value: CFuncPtr1[GLuint, GLboolean] = v
      inline def toPtr: Ptr[?] = CFuncPtr.toPtr(v)

  opaque type PFNGLISPATHNVPROC = CFuncPtr1[GLuint, GLboolean]
  object PFNGLISPATHNVPROC:
    given _tag: Tag[PFNGLISPATHNVPROC] = Tag.materializeCFuncPtr1[GLuint, GLboolean]
    inline def fromPtr(ptr: Ptr[Byte] | Ptr[?]): PFNGLISPATHNVPROC = CFuncPtr.fromPtr(ptr.asInstanceOf[Ptr[Byte]])
    inline def apply(inline o: CFuncPtr1[GLuint, GLboolean]): PFNGLISPATHNVPROC = o
    extension (v: PFNGLISPATHNVPROC)
      inline def value: CFuncPtr1[GLuint, GLboolean] = v
      inline def toPtr: Ptr[?] = CFuncPtr.toPtr(v)

  opaque type PFNGLISPOINTINFILLPATHNVPROC = CFuncPtr4[GLuint, GLuint, GLfloat, GLfloat, GLboolean]
  object PFNGLISPOINTINFILLPATHNVPROC:
    given _tag: Tag[PFNGLISPOINTINFILLPATHNVPROC] = Tag.materializeCFuncPtr4[GLuint, GLuint, GLfloat, GLfloat, GLboolean]
    inline def fromPtr(ptr: Ptr[Byte] | Ptr[?]): PFNGLISPOINTINFILLPATHNVPROC = CFuncPtr.fromPtr(ptr.asInstanceOf[Ptr[Byte]])
    inline def apply(inline o: CFuncPtr4[GLuint, GLuint, GLfloat, GLfloat, GLboolean]): PFNGLISPOINTINFILLPATHNVPROC = o
    extension (v: PFNGLISPOINTINFILLPATHNVPROC)
      inline def value: CFuncPtr4[GLuint, GLuint, GLfloat, GLfloat, GLboolean] = v
      inline def toPtr: Ptr[?] = CFuncPtr.toPtr(v)

  opaque type PFNGLISPOINTINSTROKEPATHNVPROC = CFuncPtr3[GLuint, GLfloat, GLfloat, GLboolean]
  object PFNGLISPOINTINSTROKEPATHNVPROC:
    given _tag: Tag[PFNGLISPOINTINSTROKEPATHNVPROC] = Tag.materializeCFuncPtr3[GLuint, GLfloat, GLfloat, GLboolean]
    inline def fromPtr(ptr: Ptr[Byte] | Ptr[?]): PFNGLISPOINTINSTROKEPATHNVPROC = CFuncPtr.fromPtr(ptr.asInstanceOf[Ptr[Byte]])
    inline def apply(inline o: CFuncPtr3[GLuint, GLfloat, GLfloat, GLboolean]): PFNGLISPOINTINSTROKEPATHNVPROC = o
    extension (v: PFNGLISPOINTINSTROKEPATHNVPROC)
      inline def value: CFuncPtr3[GLuint, GLfloat, GLfloat, GLboolean] = v
      inline def toPtr: Ptr[?] = CFuncPtr.toPtr(v)

  opaque type PFNGLISPROGRAMARBPROC = CFuncPtr1[GLuint, GLboolean]
  object PFNGLISPROGRAMARBPROC:
    given _tag: Tag[PFNGLISPROGRAMARBPROC] = Tag.materializeCFuncPtr1[GLuint, GLboolean]
    inline def fromPtr(ptr: Ptr[Byte] | Ptr[?]): PFNGLISPROGRAMARBPROC = CFuncPtr.fromPtr(ptr.asInstanceOf[Ptr[Byte]])
    inline def apply(inline o: CFuncPtr1[GLuint, GLboolean]): PFNGLISPROGRAMARBPROC = o
    extension (v: PFNGLISPROGRAMARBPROC)
      inline def value: CFuncPtr1[GLuint, GLboolean] = v
      inline def toPtr: Ptr[?] = CFuncPtr.toPtr(v)

  opaque type PFNGLISPROGRAMNVPROC = CFuncPtr1[GLuint, GLboolean]
  object PFNGLISPROGRAMNVPROC:
    given _tag: Tag[PFNGLISPROGRAMNVPROC] = Tag.materializeCFuncPtr1[GLuint, GLboolean]
    inline def fromPtr(ptr: Ptr[Byte] | Ptr[?]): PFNGLISPROGRAMNVPROC = CFuncPtr.fromPtr(ptr.asInstanceOf[Ptr[Byte]])
    inline def apply(inline o: CFuncPtr1[GLuint, GLboolean]): PFNGLISPROGRAMNVPROC = o
    extension (v: PFNGLISPROGRAMNVPROC)
      inline def value: CFuncPtr1[GLuint, GLboolean] = v
      inline def toPtr: Ptr[?] = CFuncPtr.toPtr(v)

  opaque type PFNGLISPROGRAMPIPELINEPROC = CFuncPtr1[GLuint, GLboolean]
  object PFNGLISPROGRAMPIPELINEPROC:
    given _tag: Tag[PFNGLISPROGRAMPIPELINEPROC] = Tag.materializeCFuncPtr1[GLuint, GLboolean]
    inline def fromPtr(ptr: Ptr[Byte] | Ptr[?]): PFNGLISPROGRAMPIPELINEPROC = CFuncPtr.fromPtr(ptr.asInstanceOf[Ptr[Byte]])
    inline def apply(inline o: CFuncPtr1[GLuint, GLboolean]): PFNGLISPROGRAMPIPELINEPROC = o
    extension (v: PFNGLISPROGRAMPIPELINEPROC)
      inline def value: CFuncPtr1[GLuint, GLboolean] = v
      inline def toPtr: Ptr[?] = CFuncPtr.toPtr(v)

  opaque type PFNGLISPROGRAMPROC = CFuncPtr1[GLuint, GLboolean]
  object PFNGLISPROGRAMPROC:
    given _tag: Tag[PFNGLISPROGRAMPROC] = Tag.materializeCFuncPtr1[GLuint, GLboolean]
    inline def fromPtr(ptr: Ptr[Byte] | Ptr[?]): PFNGLISPROGRAMPROC = CFuncPtr.fromPtr(ptr.asInstanceOf[Ptr[Byte]])
    inline def apply(inline o: CFuncPtr1[GLuint, GLboolean]): PFNGLISPROGRAMPROC = o
    extension (v: PFNGLISPROGRAMPROC)
      inline def value: CFuncPtr1[GLuint, GLboolean] = v
      inline def toPtr: Ptr[?] = CFuncPtr.toPtr(v)

  opaque type PFNGLISQUERYANGLEPROC = CFuncPtr1[GLuint, GLboolean]
  object PFNGLISQUERYANGLEPROC:
    given _tag: Tag[PFNGLISQUERYANGLEPROC] = Tag.materializeCFuncPtr1[GLuint, GLboolean]
    inline def fromPtr(ptr: Ptr[Byte] | Ptr[?]): PFNGLISQUERYANGLEPROC = CFuncPtr.fromPtr(ptr.asInstanceOf[Ptr[Byte]])
    inline def apply(inline o: CFuncPtr1[GLuint, GLboolean]): PFNGLISQUERYANGLEPROC = o
    extension (v: PFNGLISQUERYANGLEPROC)
      inline def value: CFuncPtr1[GLuint, GLboolean] = v
      inline def toPtr: Ptr[?] = CFuncPtr.toPtr(v)

  opaque type PFNGLISQUERYARBPROC = CFuncPtr1[GLuint, GLboolean]
  object PFNGLISQUERYARBPROC:
    given _tag: Tag[PFNGLISQUERYARBPROC] = Tag.materializeCFuncPtr1[GLuint, GLboolean]
    inline def fromPtr(ptr: Ptr[Byte] | Ptr[?]): PFNGLISQUERYARBPROC = CFuncPtr.fromPtr(ptr.asInstanceOf[Ptr[Byte]])
    inline def apply(inline o: CFuncPtr1[GLuint, GLboolean]): PFNGLISQUERYARBPROC = o
    extension (v: PFNGLISQUERYARBPROC)
      inline def value: CFuncPtr1[GLuint, GLboolean] = v
      inline def toPtr: Ptr[?] = CFuncPtr.toPtr(v)

  opaque type PFNGLISQUERYEXTPROC = CFuncPtr1[GLuint, GLboolean]
  object PFNGLISQUERYEXTPROC:
    given _tag: Tag[PFNGLISQUERYEXTPROC] = Tag.materializeCFuncPtr1[GLuint, GLboolean]
    inline def fromPtr(ptr: Ptr[Byte] | Ptr[?]): PFNGLISQUERYEXTPROC = CFuncPtr.fromPtr(ptr.asInstanceOf[Ptr[Byte]])
    inline def apply(inline o: CFuncPtr1[GLuint, GLboolean]): PFNGLISQUERYEXTPROC = o
    extension (v: PFNGLISQUERYEXTPROC)
      inline def value: CFuncPtr1[GLuint, GLboolean] = v
      inline def toPtr: Ptr[?] = CFuncPtr.toPtr(v)

  opaque type PFNGLISQUERYPROC = CFuncPtr1[GLuint, GLboolean]
  object PFNGLISQUERYPROC:
    given _tag: Tag[PFNGLISQUERYPROC] = Tag.materializeCFuncPtr1[GLuint, GLboolean]
    inline def fromPtr(ptr: Ptr[Byte] | Ptr[?]): PFNGLISQUERYPROC = CFuncPtr.fromPtr(ptr.asInstanceOf[Ptr[Byte]])
    inline def apply(inline o: CFuncPtr1[GLuint, GLboolean]): PFNGLISQUERYPROC = o
    extension (v: PFNGLISQUERYPROC)
      inline def value: CFuncPtr1[GLuint, GLboolean] = v
      inline def toPtr: Ptr[?] = CFuncPtr.toPtr(v)

  opaque type PFNGLISRENDERBUFFEREXTPROC = CFuncPtr1[GLuint, GLboolean]
  object PFNGLISRENDERBUFFEREXTPROC:
    given _tag: Tag[PFNGLISRENDERBUFFEREXTPROC] = Tag.materializeCFuncPtr1[GLuint, GLboolean]
    inline def fromPtr(ptr: Ptr[Byte] | Ptr[?]): PFNGLISRENDERBUFFEREXTPROC = CFuncPtr.fromPtr(ptr.asInstanceOf[Ptr[Byte]])
    inline def apply(inline o: CFuncPtr1[GLuint, GLboolean]): PFNGLISRENDERBUFFEREXTPROC = o
    extension (v: PFNGLISRENDERBUFFEREXTPROC)
      inline def value: CFuncPtr1[GLuint, GLboolean] = v
      inline def toPtr: Ptr[?] = CFuncPtr.toPtr(v)

  opaque type PFNGLISRENDERBUFFEROESPROC = CFuncPtr1[GLuint, GLboolean]
  object PFNGLISRENDERBUFFEROESPROC:
    given _tag: Tag[PFNGLISRENDERBUFFEROESPROC] = Tag.materializeCFuncPtr1[GLuint, GLboolean]
    inline def fromPtr(ptr: Ptr[Byte] | Ptr[?]): PFNGLISRENDERBUFFEROESPROC = CFuncPtr.fromPtr(ptr.asInstanceOf[Ptr[Byte]])
    inline def apply(inline o: CFuncPtr1[GLuint, GLboolean]): PFNGLISRENDERBUFFEROESPROC = o
    extension (v: PFNGLISRENDERBUFFEROESPROC)
      inline def value: CFuncPtr1[GLuint, GLboolean] = v
      inline def toPtr: Ptr[?] = CFuncPtr.toPtr(v)

  opaque type PFNGLISRENDERBUFFERPROC = CFuncPtr1[GLuint, GLboolean]
  object PFNGLISRENDERBUFFERPROC:
    given _tag: Tag[PFNGLISRENDERBUFFERPROC] = Tag.materializeCFuncPtr1[GLuint, GLboolean]
    inline def fromPtr(ptr: Ptr[Byte] | Ptr[?]): PFNGLISRENDERBUFFERPROC = CFuncPtr.fromPtr(ptr.asInstanceOf[Ptr[Byte]])
    inline def apply(inline o: CFuncPtr1[GLuint, GLboolean]): PFNGLISRENDERBUFFERPROC = o
    extension (v: PFNGLISRENDERBUFFERPROC)
      inline def value: CFuncPtr1[GLuint, GLboolean] = v
      inline def toPtr: Ptr[?] = CFuncPtr.toPtr(v)

  opaque type PFNGLISSAMPLERPROC = CFuncPtr1[GLuint, GLboolean]
  object PFNGLISSAMPLERPROC:
    given _tag: Tag[PFNGLISSAMPLERPROC] = Tag.materializeCFuncPtr1[GLuint, GLboolean]
    inline def fromPtr(ptr: Ptr[Byte] | Ptr[?]): PFNGLISSAMPLERPROC = CFuncPtr.fromPtr(ptr.asInstanceOf[Ptr[Byte]])
    inline def apply(inline o: CFuncPtr1[GLuint, GLboolean]): PFNGLISSAMPLERPROC = o
    extension (v: PFNGLISSAMPLERPROC)
      inline def value: CFuncPtr1[GLuint, GLboolean] = v
      inline def toPtr: Ptr[?] = CFuncPtr.toPtr(v)

  opaque type PFNGLISSEMAPHOREEXTPROC = CFuncPtr1[GLuint, GLboolean]
  object PFNGLISSEMAPHOREEXTPROC:
    given _tag: Tag[PFNGLISSEMAPHOREEXTPROC] = Tag.materializeCFuncPtr1[GLuint, GLboolean]
    inline def fromPtr(ptr: Ptr[Byte] | Ptr[?]): PFNGLISSEMAPHOREEXTPROC = CFuncPtr.fromPtr(ptr.asInstanceOf[Ptr[Byte]])
    inline def apply(inline o: CFuncPtr1[GLuint, GLboolean]): PFNGLISSEMAPHOREEXTPROC = o
    extension (v: PFNGLISSEMAPHOREEXTPROC)
      inline def value: CFuncPtr1[GLuint, GLboolean] = v
      inline def toPtr: Ptr[?] = CFuncPtr.toPtr(v)

  opaque type PFNGLISSHADERPROC = CFuncPtr1[GLuint, GLboolean]
  object PFNGLISSHADERPROC:
    given _tag: Tag[PFNGLISSHADERPROC] = Tag.materializeCFuncPtr1[GLuint, GLboolean]
    inline def fromPtr(ptr: Ptr[Byte] | Ptr[?]): PFNGLISSHADERPROC = CFuncPtr.fromPtr(ptr.asInstanceOf[Ptr[Byte]])
    inline def apply(inline o: CFuncPtr1[GLuint, GLboolean]): PFNGLISSHADERPROC = o
    extension (v: PFNGLISSHADERPROC)
      inline def value: CFuncPtr1[GLuint, GLboolean] = v
      inline def toPtr: Ptr[?] = CFuncPtr.toPtr(v)

  opaque type PFNGLISSTATENVPROC = CFuncPtr1[GLuint, GLboolean]
  object PFNGLISSTATENVPROC:
    given _tag: Tag[PFNGLISSTATENVPROC] = Tag.materializeCFuncPtr1[GLuint, GLboolean]
    inline def fromPtr(ptr: Ptr[Byte] | Ptr[?]): PFNGLISSTATENVPROC = CFuncPtr.fromPtr(ptr.asInstanceOf[Ptr[Byte]])
    inline def apply(inline o: CFuncPtr1[GLuint, GLboolean]): PFNGLISSTATENVPROC = o
    extension (v: PFNGLISSTATENVPROC)
      inline def value: CFuncPtr1[GLuint, GLboolean] = v
      inline def toPtr: Ptr[?] = CFuncPtr.toPtr(v)

  opaque type PFNGLISSUPPORTEDREGALPROC = CFuncPtr1[Ptr[GLchar], GLboolean]
  object PFNGLISSUPPORTEDREGALPROC:
    given _tag: Tag[PFNGLISSUPPORTEDREGALPROC] = Tag.materializeCFuncPtr1[Ptr[GLchar], GLboolean]
    inline def fromPtr(ptr: Ptr[Byte] | Ptr[?]): PFNGLISSUPPORTEDREGALPROC = CFuncPtr.fromPtr(ptr.asInstanceOf[Ptr[Byte]])
    inline def apply(inline o: CFuncPtr1[Ptr[GLchar], GLboolean]): PFNGLISSUPPORTEDREGALPROC = o
    extension (v: PFNGLISSUPPORTEDREGALPROC)
      inline def value: CFuncPtr1[Ptr[GLchar], GLboolean] = v
      inline def toPtr: Ptr[?] = CFuncPtr.toPtr(v)

  opaque type PFNGLISSYNCAPPLEPROC = CFuncPtr1[GLsync, GLboolean]
  object PFNGLISSYNCAPPLEPROC:
    given _tag: Tag[PFNGLISSYNCAPPLEPROC] = Tag.materializeCFuncPtr1[GLsync, GLboolean]
    inline def fromPtr(ptr: Ptr[Byte] | Ptr[?]): PFNGLISSYNCAPPLEPROC = CFuncPtr.fromPtr(ptr.asInstanceOf[Ptr[Byte]])
    inline def apply(inline o: CFuncPtr1[GLsync, GLboolean]): PFNGLISSYNCAPPLEPROC = o
    extension (v: PFNGLISSYNCAPPLEPROC)
      inline def value: CFuncPtr1[GLsync, GLboolean] = v
      inline def toPtr: Ptr[?] = CFuncPtr.toPtr(v)

  opaque type PFNGLISSYNCPROC = CFuncPtr1[GLsync, GLboolean]
  object PFNGLISSYNCPROC:
    given _tag: Tag[PFNGLISSYNCPROC] = Tag.materializeCFuncPtr1[GLsync, GLboolean]
    inline def fromPtr(ptr: Ptr[Byte] | Ptr[?]): PFNGLISSYNCPROC = CFuncPtr.fromPtr(ptr.asInstanceOf[Ptr[Byte]])
    inline def apply(inline o: CFuncPtr1[GLsync, GLboolean]): PFNGLISSYNCPROC = o
    extension (v: PFNGLISSYNCPROC)
      inline def value: CFuncPtr1[GLsync, GLboolean] = v
      inline def toPtr: Ptr[?] = CFuncPtr.toPtr(v)

  opaque type PFNGLISTEXTUREEXTPROC = CFuncPtr1[GLuint, GLboolean]
  object PFNGLISTEXTUREEXTPROC:
    given _tag: Tag[PFNGLISTEXTUREEXTPROC] = Tag.materializeCFuncPtr1[GLuint, GLboolean]
    inline def fromPtr(ptr: Ptr[Byte] | Ptr[?]): PFNGLISTEXTUREEXTPROC = CFuncPtr.fromPtr(ptr.asInstanceOf[Ptr[Byte]])
    inline def apply(inline o: CFuncPtr1[GLuint, GLboolean]): PFNGLISTEXTUREEXTPROC = o
    extension (v: PFNGLISTEXTUREEXTPROC)
      inline def value: CFuncPtr1[GLuint, GLboolean] = v
      inline def toPtr: Ptr[?] = CFuncPtr.toPtr(v)

  opaque type PFNGLISTEXTUREHANDLERESIDENTARBPROC = CFuncPtr1[GLuint64, GLboolean]
  object PFNGLISTEXTUREHANDLERESIDENTARBPROC:
    given _tag: Tag[PFNGLISTEXTUREHANDLERESIDENTARBPROC] = Tag.materializeCFuncPtr1[GLuint64, GLboolean]
    inline def fromPtr(ptr: Ptr[Byte] | Ptr[?]): PFNGLISTEXTUREHANDLERESIDENTARBPROC = CFuncPtr.fromPtr(ptr.asInstanceOf[Ptr[Byte]])
    inline def apply(inline o: CFuncPtr1[GLuint64, GLboolean]): PFNGLISTEXTUREHANDLERESIDENTARBPROC = o
    extension (v: PFNGLISTEXTUREHANDLERESIDENTARBPROC)
      inline def value: CFuncPtr1[GLuint64, GLboolean] = v
      inline def toPtr: Ptr[?] = CFuncPtr.toPtr(v)

  opaque type PFNGLISTEXTUREHANDLERESIDENTNVPROC = CFuncPtr1[GLuint64, GLboolean]
  object PFNGLISTEXTUREHANDLERESIDENTNVPROC:
    given _tag: Tag[PFNGLISTEXTUREHANDLERESIDENTNVPROC] = Tag.materializeCFuncPtr1[GLuint64, GLboolean]
    inline def fromPtr(ptr: Ptr[Byte] | Ptr[?]): PFNGLISTEXTUREHANDLERESIDENTNVPROC = CFuncPtr.fromPtr(ptr.asInstanceOf[Ptr[Byte]])
    inline def apply(inline o: CFuncPtr1[GLuint64, GLboolean]): PFNGLISTEXTUREHANDLERESIDENTNVPROC = o
    extension (v: PFNGLISTEXTUREHANDLERESIDENTNVPROC)
      inline def value: CFuncPtr1[GLuint64, GLboolean] = v
      inline def toPtr: Ptr[?] = CFuncPtr.toPtr(v)

  opaque type PFNGLISTRANSFORMFEEDBACKNVPROC = CFuncPtr1[GLuint, GLboolean]
  object PFNGLISTRANSFORMFEEDBACKNVPROC:
    given _tag: Tag[PFNGLISTRANSFORMFEEDBACKNVPROC] = Tag.materializeCFuncPtr1[GLuint, GLboolean]
    inline def fromPtr(ptr: Ptr[Byte] | Ptr[?]): PFNGLISTRANSFORMFEEDBACKNVPROC = CFuncPtr.fromPtr(ptr.asInstanceOf[Ptr[Byte]])
    inline def apply(inline o: CFuncPtr1[GLuint, GLboolean]): PFNGLISTRANSFORMFEEDBACKNVPROC = o
    extension (v: PFNGLISTRANSFORMFEEDBACKNVPROC)
      inline def value: CFuncPtr1[GLuint, GLboolean] = v
      inline def toPtr: Ptr[?] = CFuncPtr.toPtr(v)

  opaque type PFNGLISTRANSFORMFEEDBACKPROC = CFuncPtr1[GLuint, GLboolean]
  object PFNGLISTRANSFORMFEEDBACKPROC:
    given _tag: Tag[PFNGLISTRANSFORMFEEDBACKPROC] = Tag.materializeCFuncPtr1[GLuint, GLboolean]
    inline def fromPtr(ptr: Ptr[Byte] | Ptr[?]): PFNGLISTRANSFORMFEEDBACKPROC = CFuncPtr.fromPtr(ptr.asInstanceOf[Ptr[Byte]])
    inline def apply(inline o: CFuncPtr1[GLuint, GLboolean]): PFNGLISTRANSFORMFEEDBACKPROC = o
    extension (v: PFNGLISTRANSFORMFEEDBACKPROC)
      inline def value: CFuncPtr1[GLuint, GLboolean] = v
      inline def toPtr: Ptr[?] = CFuncPtr.toPtr(v)

  opaque type PFNGLISVARIANTENABLEDEXTPROC = CFuncPtr2[GLuint, GLenum, GLboolean]
  object PFNGLISVARIANTENABLEDEXTPROC:
    given _tag: Tag[PFNGLISVARIANTENABLEDEXTPROC] = Tag.materializeCFuncPtr2[GLuint, GLenum, GLboolean]
    inline def fromPtr(ptr: Ptr[Byte] | Ptr[?]): PFNGLISVARIANTENABLEDEXTPROC = CFuncPtr.fromPtr(ptr.asInstanceOf[Ptr[Byte]])
    inline def apply(inline o: CFuncPtr2[GLuint, GLenum, GLboolean]): PFNGLISVARIANTENABLEDEXTPROC = o
    extension (v: PFNGLISVARIANTENABLEDEXTPROC)
      inline def value: CFuncPtr2[GLuint, GLenum, GLboolean] = v
      inline def toPtr: Ptr[?] = CFuncPtr.toPtr(v)

  opaque type PFNGLISVERTEXARRAYAPPLEPROC = CFuncPtr1[GLuint, GLboolean]
  object PFNGLISVERTEXARRAYAPPLEPROC:
    given _tag: Tag[PFNGLISVERTEXARRAYAPPLEPROC] = Tag.materializeCFuncPtr1[GLuint, GLboolean]
    inline def fromPtr(ptr: Ptr[Byte] | Ptr[?]): PFNGLISVERTEXARRAYAPPLEPROC = CFuncPtr.fromPtr(ptr.asInstanceOf[Ptr[Byte]])
    inline def apply(inline o: CFuncPtr1[GLuint, GLboolean]): PFNGLISVERTEXARRAYAPPLEPROC = o
    extension (v: PFNGLISVERTEXARRAYAPPLEPROC)
      inline def value: CFuncPtr1[GLuint, GLboolean] = v
      inline def toPtr: Ptr[?] = CFuncPtr.toPtr(v)

  opaque type PFNGLISVERTEXARRAYOESPROC = CFuncPtr1[GLuint, GLboolean]
  object PFNGLISVERTEXARRAYOESPROC:
    given _tag: Tag[PFNGLISVERTEXARRAYOESPROC] = Tag.materializeCFuncPtr1[GLuint, GLboolean]
    inline def fromPtr(ptr: Ptr[Byte] | Ptr[?]): PFNGLISVERTEXARRAYOESPROC = CFuncPtr.fromPtr(ptr.asInstanceOf[Ptr[Byte]])
    inline def apply(inline o: CFuncPtr1[GLuint, GLboolean]): PFNGLISVERTEXARRAYOESPROC = o
    extension (v: PFNGLISVERTEXARRAYOESPROC)
      inline def value: CFuncPtr1[GLuint, GLboolean] = v
      inline def toPtr: Ptr[?] = CFuncPtr.toPtr(v)

  opaque type PFNGLISVERTEXARRAYPROC = CFuncPtr1[GLuint, GLboolean]
  object PFNGLISVERTEXARRAYPROC:
    given _tag: Tag[PFNGLISVERTEXARRAYPROC] = Tag.materializeCFuncPtr1[GLuint, GLboolean]
    inline def fromPtr(ptr: Ptr[Byte] | Ptr[?]): PFNGLISVERTEXARRAYPROC = CFuncPtr.fromPtr(ptr.asInstanceOf[Ptr[Byte]])
    inline def apply(inline o: CFuncPtr1[GLuint, GLboolean]): PFNGLISVERTEXARRAYPROC = o
    extension (v: PFNGLISVERTEXARRAYPROC)
      inline def value: CFuncPtr1[GLuint, GLboolean] = v
      inline def toPtr: Ptr[?] = CFuncPtr.toPtr(v)

  opaque type PFNGLISVERTEXARRAYSGIXPROC = CFuncPtr1[GLuint, GLboolean]
  object PFNGLISVERTEXARRAYSGIXPROC:
    given _tag: Tag[PFNGLISVERTEXARRAYSGIXPROC] = Tag.materializeCFuncPtr1[GLuint, GLboolean]
    inline def fromPtr(ptr: Ptr[Byte] | Ptr[?]): PFNGLISVERTEXARRAYSGIXPROC = CFuncPtr.fromPtr(ptr.asInstanceOf[Ptr[Byte]])
    inline def apply(inline o: CFuncPtr1[GLuint, GLboolean]): PFNGLISVERTEXARRAYSGIXPROC = o
    extension (v: PFNGLISVERTEXARRAYSGIXPROC)
      inline def value: CFuncPtr1[GLuint, GLboolean] = v
      inline def toPtr: Ptr[?] = CFuncPtr.toPtr(v)

  opaque type PFNGLISVERTEXATTRIBENABLEDAPPLEPROC = CFuncPtr2[GLuint, GLenum, GLboolean]
  object PFNGLISVERTEXATTRIBENABLEDAPPLEPROC:
    given _tag: Tag[PFNGLISVERTEXATTRIBENABLEDAPPLEPROC] = Tag.materializeCFuncPtr2[GLuint, GLenum, GLboolean]
    inline def fromPtr(ptr: Ptr[Byte] | Ptr[?]): PFNGLISVERTEXATTRIBENABLEDAPPLEPROC = CFuncPtr.fromPtr(ptr.asInstanceOf[Ptr[Byte]])
    inline def apply(inline o: CFuncPtr2[GLuint, GLenum, GLboolean]): PFNGLISVERTEXATTRIBENABLEDAPPLEPROC = o
    extension (v: PFNGLISVERTEXATTRIBENABLEDAPPLEPROC)
      inline def value: CFuncPtr2[GLuint, GLenum, GLboolean] = v
      inline def toPtr: Ptr[?] = CFuncPtr.toPtr(v)

  opaque type PFNGLLABELOBJECTEXTPROC = CFuncPtr4[GLenum, GLuint, GLsizei, Ptr[GLchar], Unit]
  object PFNGLLABELOBJECTEXTPROC:
    given _tag: Tag[PFNGLLABELOBJECTEXTPROC] = Tag.materializeCFuncPtr4[GLenum, GLuint, GLsizei, Ptr[GLchar], Unit]
    inline def fromPtr(ptr: Ptr[Byte] | Ptr[?]): PFNGLLABELOBJECTEXTPROC = CFuncPtr.fromPtr(ptr.asInstanceOf[Ptr[Byte]])
    inline def apply(inline o: CFuncPtr4[GLenum, GLuint, GLsizei, Ptr[GLchar], Unit]): PFNGLLABELOBJECTEXTPROC = o
    extension (v: PFNGLLABELOBJECTEXTPROC)
      inline def value: CFuncPtr4[GLenum, GLuint, GLsizei, Ptr[GLchar], Unit] = v
      inline def toPtr: Ptr[?] = CFuncPtr.toPtr(v)

  opaque type PFNGLLGPUCOPYIMAGESUBDATANVXPROC = CFuncPtr17[GLuint, GLbitfield, GLuint, GLenum, GLint, GLint, GLint, GLint, GLuint, GLenum, GLint, GLint, GLint, GLint, GLsizei, GLsizei, GLsizei, Unit]
  object PFNGLLGPUCOPYIMAGESUBDATANVXPROC:
    given _tag: Tag[PFNGLLGPUCOPYIMAGESUBDATANVXPROC] = Tag.materializeCFuncPtr17[GLuint, GLbitfield, GLuint, GLenum, GLint, GLint, GLint, GLint, GLuint, GLenum, GLint, GLint, GLint, GLint, GLsizei, GLsizei, GLsizei, Unit]
    inline def fromPtr(ptr: Ptr[Byte] | Ptr[?]): PFNGLLGPUCOPYIMAGESUBDATANVXPROC = CFuncPtr.fromPtr(ptr.asInstanceOf[Ptr[Byte]])
    inline def apply(inline o: CFuncPtr17[GLuint, GLbitfield, GLuint, GLenum, GLint, GLint, GLint, GLint, GLuint, GLenum, GLint, GLint, GLint, GLint, GLsizei, GLsizei, GLsizei, Unit]): PFNGLLGPUCOPYIMAGESUBDATANVXPROC = o
    extension (v: PFNGLLGPUCOPYIMAGESUBDATANVXPROC)
      inline def value: CFuncPtr17[GLuint, GLbitfield, GLuint, GLenum, GLint, GLint, GLint, GLint, GLuint, GLenum, GLint, GLint, GLint, GLint, GLsizei, GLsizei, GLsizei, Unit] = v
      inline def toPtr: Ptr[?] = CFuncPtr.toPtr(v)

  opaque type PFNGLLGPUINTERLOCKNVXPROC = CFuncPtr0[Unit]
  object PFNGLLGPUINTERLOCKNVXPROC:
    given _tag: Tag[PFNGLLGPUINTERLOCKNVXPROC] = Tag.materializeCFuncPtr0[Unit]
    inline def fromPtr(ptr: Ptr[Byte] | Ptr[?]): PFNGLLGPUINTERLOCKNVXPROC = CFuncPtr.fromPtr(ptr.asInstanceOf[Ptr[Byte]])
    inline def apply(inline o: CFuncPtr0[Unit]): PFNGLLGPUINTERLOCKNVXPROC = o
    extension (v: PFNGLLGPUINTERLOCKNVXPROC)
      inline def value: CFuncPtr0[Unit] = v
      inline def toPtr: Ptr[?] = CFuncPtr.toPtr(v)

  opaque type PFNGLLGPUNAMEDBUFFERSUBDATANVXPROC = CFuncPtr5[GLbitfield, GLuint, GLintptr, GLsizeiptr, Ptr[Byte], Unit]
  object PFNGLLGPUNAMEDBUFFERSUBDATANVXPROC:
    given _tag: Tag[PFNGLLGPUNAMEDBUFFERSUBDATANVXPROC] = Tag.materializeCFuncPtr5[GLbitfield, GLuint, GLintptr, GLsizeiptr, Ptr[Byte], Unit]
    inline def fromPtr(ptr: Ptr[Byte] | Ptr[?]): PFNGLLGPUNAMEDBUFFERSUBDATANVXPROC = CFuncPtr.fromPtr(ptr.asInstanceOf[Ptr[Byte]])
    inline def apply(inline o: CFuncPtr5[GLbitfield, GLuint, GLintptr, GLsizeiptr, Ptr[Byte], Unit]): PFNGLLGPUNAMEDBUFFERSUBDATANVXPROC = o
    extension (v: PFNGLLGPUNAMEDBUFFERSUBDATANVXPROC)
      inline def value: CFuncPtr5[GLbitfield, GLuint, GLintptr, GLsizeiptr, Ptr[Byte], Unit] = v
      inline def toPtr: Ptr[?] = CFuncPtr.toPtr(v)

  opaque type PFNGLLIGHTENVIEXTPROC = CFuncPtr2[GLenum, GLint, Unit]
  object PFNGLLIGHTENVIEXTPROC:
    given _tag: Tag[PFNGLLIGHTENVIEXTPROC] = Tag.materializeCFuncPtr2[GLenum, GLint, Unit]
    inline def fromPtr(ptr: Ptr[Byte] | Ptr[?]): PFNGLLIGHTENVIEXTPROC = CFuncPtr.fromPtr(ptr.asInstanceOf[Ptr[Byte]])
    inline def apply(inline o: CFuncPtr2[GLenum, GLint, Unit]): PFNGLLIGHTENVIEXTPROC = o
    extension (v: PFNGLLIGHTENVIEXTPROC)
      inline def value: CFuncPtr2[GLenum, GLint, Unit] = v
      inline def toPtr: Ptr[?] = CFuncPtr.toPtr(v)

  opaque type PFNGLLIGHTMODELXPROC = CFuncPtr2[GLenum, GLfixed, Unit]
  object PFNGLLIGHTMODELXPROC:
    given _tag: Tag[PFNGLLIGHTMODELXPROC] = Tag.materializeCFuncPtr2[GLenum, GLfixed, Unit]
    inline def fromPtr(ptr: Ptr[Byte] | Ptr[?]): PFNGLLIGHTMODELXPROC = CFuncPtr.fromPtr(ptr.asInstanceOf[Ptr[Byte]])
    inline def apply(inline o: CFuncPtr2[GLenum, GLfixed, Unit]): PFNGLLIGHTMODELXPROC = o
    extension (v: PFNGLLIGHTMODELXPROC)
      inline def value: CFuncPtr2[GLenum, GLfixed, Unit] = v
      inline def toPtr: Ptr[?] = CFuncPtr.toPtr(v)

  opaque type PFNGLLIGHTMODELXVPROC = CFuncPtr2[GLenum, Ptr[GLfixed], Unit]
  object PFNGLLIGHTMODELXVPROC:
    given _tag: Tag[PFNGLLIGHTMODELXVPROC] = Tag.materializeCFuncPtr2[GLenum, Ptr[GLfixed], Unit]
    inline def fromPtr(ptr: Ptr[Byte] | Ptr[?]): PFNGLLIGHTMODELXVPROC = CFuncPtr.fromPtr(ptr.asInstanceOf[Ptr[Byte]])
    inline def apply(inline o: CFuncPtr2[GLenum, Ptr[GLfixed], Unit]): PFNGLLIGHTMODELXVPROC = o
    extension (v: PFNGLLIGHTMODELXVPROC)
      inline def value: CFuncPtr2[GLenum, Ptr[GLfixed], Unit] = v
      inline def toPtr: Ptr[?] = CFuncPtr.toPtr(v)

  opaque type PFNGLLIGHTXPROC = CFuncPtr3[GLenum, GLenum, GLfixed, Unit]
  object PFNGLLIGHTXPROC:
    given _tag: Tag[PFNGLLIGHTXPROC] = Tag.materializeCFuncPtr3[GLenum, GLenum, GLfixed, Unit]
    inline def fromPtr(ptr: Ptr[Byte] | Ptr[?]): PFNGLLIGHTXPROC = CFuncPtr.fromPtr(ptr.asInstanceOf[Ptr[Byte]])
    inline def apply(inline o: CFuncPtr3[GLenum, GLenum, GLfixed, Unit]): PFNGLLIGHTXPROC = o
    extension (v: PFNGLLIGHTXPROC)
      inline def value: CFuncPtr3[GLenum, GLenum, GLfixed, Unit] = v
      inline def toPtr: Ptr[?] = CFuncPtr.toPtr(v)

  opaque type PFNGLLIGHTXVPROC = CFuncPtr3[GLenum, GLenum, Ptr[GLfixed], Unit]
  object PFNGLLIGHTXVPROC:
    given _tag: Tag[PFNGLLIGHTXVPROC] = Tag.materializeCFuncPtr3[GLenum, GLenum, Ptr[GLfixed], Unit]
    inline def fromPtr(ptr: Ptr[Byte] | Ptr[?]): PFNGLLIGHTXVPROC = CFuncPtr.fromPtr(ptr.asInstanceOf[Ptr[Byte]])
    inline def apply(inline o: CFuncPtr3[GLenum, GLenum, Ptr[GLfixed], Unit]): PFNGLLIGHTXVPROC = o
    extension (v: PFNGLLIGHTXVPROC)
      inline def value: CFuncPtr3[GLenum, GLenum, Ptr[GLfixed], Unit] = v
      inline def toPtr: Ptr[?] = CFuncPtr.toPtr(v)

  opaque type PFNGLLINEWIDTHXPROC = CFuncPtr1[GLfixed, Unit]
  object PFNGLLINEWIDTHXPROC:
    given _tag: Tag[PFNGLLINEWIDTHXPROC] = Tag.materializeCFuncPtr1[GLfixed, Unit]
    inline def fromPtr(ptr: Ptr[Byte] | Ptr[?]): PFNGLLINEWIDTHXPROC = CFuncPtr.fromPtr(ptr.asInstanceOf[Ptr[Byte]])
    inline def apply(inline o: CFuncPtr1[GLfixed, Unit]): PFNGLLINEWIDTHXPROC = o
    extension (v: PFNGLLINEWIDTHXPROC)
      inline def value: CFuncPtr1[GLfixed, Unit] = v
      inline def toPtr: Ptr[?] = CFuncPtr.toPtr(v)

  opaque type PFNGLLINKPROGRAMARBPROC = CFuncPtr1[GLhandleARB, Unit]
  object PFNGLLINKPROGRAMARBPROC:
    given _tag: Tag[PFNGLLINKPROGRAMARBPROC] = Tag.materializeCFuncPtr1[GLhandleARB, Unit]
    inline def fromPtr(ptr: Ptr[Byte] | Ptr[?]): PFNGLLINKPROGRAMARBPROC = CFuncPtr.fromPtr(ptr.asInstanceOf[Ptr[Byte]])
    inline def apply(inline o: CFuncPtr1[GLhandleARB, Unit]): PFNGLLINKPROGRAMARBPROC = o
    extension (v: PFNGLLINKPROGRAMARBPROC)
      inline def value: CFuncPtr1[GLhandleARB, Unit] = v
      inline def toPtr: Ptr[?] = CFuncPtr.toPtr(v)

  opaque type PFNGLLINKPROGRAMPROC = CFuncPtr1[GLuint, Unit]
  object PFNGLLINKPROGRAMPROC:
    given _tag: Tag[PFNGLLINKPROGRAMPROC] = Tag.materializeCFuncPtr1[GLuint, Unit]
    inline def fromPtr(ptr: Ptr[Byte] | Ptr[?]): PFNGLLINKPROGRAMPROC = CFuncPtr.fromPtr(ptr.asInstanceOf[Ptr[Byte]])
    inline def apply(inline o: CFuncPtr1[GLuint, Unit]): PFNGLLINKPROGRAMPROC = o
    extension (v: PFNGLLINKPROGRAMPROC)
      inline def value: CFuncPtr1[GLuint, Unit] = v
      inline def toPtr: Ptr[?] = CFuncPtr.toPtr(v)

  opaque type PFNGLLISTDRAWCOMMANDSSTATESCLIENTNVPROC = CFuncPtr7[GLuint, GLuint, Ptr[Ptr[Byte]], Ptr[GLsizei], Ptr[GLuint], Ptr[GLuint], GLuint, Unit]
  object PFNGLLISTDRAWCOMMANDSSTATESCLIENTNVPROC:
    given _tag: Tag[PFNGLLISTDRAWCOMMANDSSTATESCLIENTNVPROC] = Tag.materializeCFuncPtr7[GLuint, GLuint, Ptr[Ptr[Byte]], Ptr[GLsizei], Ptr[GLuint], Ptr[GLuint], GLuint, Unit]
    inline def fromPtr(ptr: Ptr[Byte] | Ptr[?]): PFNGLLISTDRAWCOMMANDSSTATESCLIENTNVPROC = CFuncPtr.fromPtr(ptr.asInstanceOf[Ptr[Byte]])
    inline def apply(inline o: CFuncPtr7[GLuint, GLuint, Ptr[Ptr[Byte]], Ptr[GLsizei], Ptr[GLuint], Ptr[GLuint], GLuint, Unit]): PFNGLLISTDRAWCOMMANDSSTATESCLIENTNVPROC = o
    extension (v: PFNGLLISTDRAWCOMMANDSSTATESCLIENTNVPROC)
      inline def value: CFuncPtr7[GLuint, GLuint, Ptr[Ptr[Byte]], Ptr[GLsizei], Ptr[GLuint], Ptr[GLuint], GLuint, Unit] = v
      inline def toPtr: Ptr[?] = CFuncPtr.toPtr(v)

  opaque type PFNGLLOADIDENTITYDEFORMATIONMAPSGIXPROC = CFuncPtr1[GLbitfield, Unit]
  object PFNGLLOADIDENTITYDEFORMATIONMAPSGIXPROC:
    given _tag: Tag[PFNGLLOADIDENTITYDEFORMATIONMAPSGIXPROC] = Tag.materializeCFuncPtr1[GLbitfield, Unit]
    inline def fromPtr(ptr: Ptr[Byte] | Ptr[?]): PFNGLLOADIDENTITYDEFORMATIONMAPSGIXPROC = CFuncPtr.fromPtr(ptr.asInstanceOf[Ptr[Byte]])
    inline def apply(inline o: CFuncPtr1[GLbitfield, Unit]): PFNGLLOADIDENTITYDEFORMATIONMAPSGIXPROC = o
    extension (v: PFNGLLOADIDENTITYDEFORMATIONMAPSGIXPROC)
      inline def value: CFuncPtr1[GLbitfield, Unit] = v
      inline def toPtr: Ptr[?] = CFuncPtr.toPtr(v)

  opaque type PFNGLLOADMATRIXXPROC = CFuncPtr1[Ptr[GLfixed], Unit]
  object PFNGLLOADMATRIXXPROC:
    given _tag: Tag[PFNGLLOADMATRIXXPROC] = Tag.materializeCFuncPtr1[Ptr[GLfixed], Unit]
    inline def fromPtr(ptr: Ptr[Byte] | Ptr[?]): PFNGLLOADMATRIXXPROC = CFuncPtr.fromPtr(ptr.asInstanceOf[Ptr[Byte]])
    inline def apply(inline o: CFuncPtr1[Ptr[GLfixed], Unit]): PFNGLLOADMATRIXXPROC = o
    extension (v: PFNGLLOADMATRIXXPROC)
      inline def value: CFuncPtr1[Ptr[GLfixed], Unit] = v
      inline def toPtr: Ptr[?] = CFuncPtr.toPtr(v)

  opaque type PFNGLLOADPROGRAMNVPROC = CFuncPtr4[GLenum, GLuint, GLsizei, Ptr[GLubyte], Unit]
  object PFNGLLOADPROGRAMNVPROC:
    given _tag: Tag[PFNGLLOADPROGRAMNVPROC] = Tag.materializeCFuncPtr4[GLenum, GLuint, GLsizei, Ptr[GLubyte], Unit]
    inline def fromPtr(ptr: Ptr[Byte] | Ptr[?]): PFNGLLOADPROGRAMNVPROC = CFuncPtr.fromPtr(ptr.asInstanceOf[Ptr[Byte]])
    inline def apply(inline o: CFuncPtr4[GLenum, GLuint, GLsizei, Ptr[GLubyte], Unit]): PFNGLLOADPROGRAMNVPROC = o
    extension (v: PFNGLLOADPROGRAMNVPROC)
      inline def value: CFuncPtr4[GLenum, GLuint, GLsizei, Ptr[GLubyte], Unit] = v
      inline def toPtr: Ptr[?] = CFuncPtr.toPtr(v)

  opaque type PFNGLLOADTRANSPOSEMATRIXDARBPROC = CFuncPtr1[CArray[GLdouble, Nat.Digit2[Nat._1, Nat._6]], Unit]
  object PFNGLLOADTRANSPOSEMATRIXDARBPROC:
    given _tag: Tag[PFNGLLOADTRANSPOSEMATRIXDARBPROC] = Tag.materializeCFuncPtr1[CArray[GLdouble, Nat.Digit2[Nat._1, Nat._6]], Unit]
    inline def fromPtr(ptr: Ptr[Byte] | Ptr[?]): PFNGLLOADTRANSPOSEMATRIXDARBPROC = CFuncPtr.fromPtr(ptr.asInstanceOf[Ptr[Byte]])
    inline def apply(inline o: CFuncPtr1[CArray[GLdouble, Nat.Digit2[Nat._1, Nat._6]], Unit]): PFNGLLOADTRANSPOSEMATRIXDARBPROC = o
    extension (v: PFNGLLOADTRANSPOSEMATRIXDARBPROC)
      inline def value: CFuncPtr1[CArray[GLdouble, Nat.Digit2[Nat._1, Nat._6]], Unit] = v
      inline def toPtr: Ptr[?] = CFuncPtr.toPtr(v)

  opaque type PFNGLLOADTRANSPOSEMATRIXDPROC = CFuncPtr1[CArray[GLdouble, Nat.Digit2[Nat._1, Nat._6]], Unit]
  object PFNGLLOADTRANSPOSEMATRIXDPROC:
    given _tag: Tag[PFNGLLOADTRANSPOSEMATRIXDPROC] = Tag.materializeCFuncPtr1[CArray[GLdouble, Nat.Digit2[Nat._1, Nat._6]], Unit]
    inline def fromPtr(ptr: Ptr[Byte] | Ptr[?]): PFNGLLOADTRANSPOSEMATRIXDPROC = CFuncPtr.fromPtr(ptr.asInstanceOf[Ptr[Byte]])
    inline def apply(inline o: CFuncPtr1[CArray[GLdouble, Nat.Digit2[Nat._1, Nat._6]], Unit]): PFNGLLOADTRANSPOSEMATRIXDPROC = o
    extension (v: PFNGLLOADTRANSPOSEMATRIXDPROC)
      inline def value: CFuncPtr1[CArray[GLdouble, Nat.Digit2[Nat._1, Nat._6]], Unit] = v
      inline def toPtr: Ptr[?] = CFuncPtr.toPtr(v)

  opaque type PFNGLLOADTRANSPOSEMATRIXFARBPROC = CFuncPtr1[CArray[GLfloat, Nat.Digit2[Nat._1, Nat._6]], Unit]
  object PFNGLLOADTRANSPOSEMATRIXFARBPROC:
    given _tag: Tag[PFNGLLOADTRANSPOSEMATRIXFARBPROC] = Tag.materializeCFuncPtr1[CArray[GLfloat, Nat.Digit2[Nat._1, Nat._6]], Unit]
    inline def fromPtr(ptr: Ptr[Byte] | Ptr[?]): PFNGLLOADTRANSPOSEMATRIXFARBPROC = CFuncPtr.fromPtr(ptr.asInstanceOf[Ptr[Byte]])
    inline def apply(inline o: CFuncPtr1[CArray[GLfloat, Nat.Digit2[Nat._1, Nat._6]], Unit]): PFNGLLOADTRANSPOSEMATRIXFARBPROC = o
    extension (v: PFNGLLOADTRANSPOSEMATRIXFARBPROC)
      inline def value: CFuncPtr1[CArray[GLfloat, Nat.Digit2[Nat._1, Nat._6]], Unit] = v
      inline def toPtr: Ptr[?] = CFuncPtr.toPtr(v)

  opaque type PFNGLLOADTRANSPOSEMATRIXFPROC = CFuncPtr1[CArray[GLfloat, Nat.Digit2[Nat._1, Nat._6]], Unit]
  object PFNGLLOADTRANSPOSEMATRIXFPROC:
    given _tag: Tag[PFNGLLOADTRANSPOSEMATRIXFPROC] = Tag.materializeCFuncPtr1[CArray[GLfloat, Nat.Digit2[Nat._1, Nat._6]], Unit]
    inline def fromPtr(ptr: Ptr[Byte] | Ptr[?]): PFNGLLOADTRANSPOSEMATRIXFPROC = CFuncPtr.fromPtr(ptr.asInstanceOf[Ptr[Byte]])
    inline def apply(inline o: CFuncPtr1[CArray[GLfloat, Nat.Digit2[Nat._1, Nat._6]], Unit]): PFNGLLOADTRANSPOSEMATRIXFPROC = o
    extension (v: PFNGLLOADTRANSPOSEMATRIXFPROC)
      inline def value: CFuncPtr1[CArray[GLfloat, Nat.Digit2[Nat._1, Nat._6]], Unit] = v
      inline def toPtr: Ptr[?] = CFuncPtr.toPtr(v)

  opaque type PFNGLLOCKARRAYSEXTPROC = CFuncPtr2[GLint, GLsizei, Unit]
  object PFNGLLOCKARRAYSEXTPROC:
    given _tag: Tag[PFNGLLOCKARRAYSEXTPROC] = Tag.materializeCFuncPtr2[GLint, GLsizei, Unit]
    inline def fromPtr(ptr: Ptr[Byte] | Ptr[?]): PFNGLLOCKARRAYSEXTPROC = CFuncPtr.fromPtr(ptr.asInstanceOf[Ptr[Byte]])
    inline def apply(inline o: CFuncPtr2[GLint, GLsizei, Unit]): PFNGLLOCKARRAYSEXTPROC = o
    extension (v: PFNGLLOCKARRAYSEXTPROC)
      inline def value: CFuncPtr2[GLint, GLsizei, Unit] = v
      inline def toPtr: Ptr[?] = CFuncPtr.toPtr(v)

  opaque type PFNGLLOGMESSAGECALLBACKREGALPROC = CFuncPtr1[GLLOGPROCREGAL, Unit]
  object PFNGLLOGMESSAGECALLBACKREGALPROC:
    given _tag: Tag[PFNGLLOGMESSAGECALLBACKREGALPROC] = Tag.materializeCFuncPtr1[GLLOGPROCREGAL, Unit]
    inline def fromPtr(ptr: Ptr[Byte] | Ptr[?]): PFNGLLOGMESSAGECALLBACKREGALPROC = CFuncPtr.fromPtr(ptr.asInstanceOf[Ptr[Byte]])
    inline def apply(inline o: CFuncPtr1[GLLOGPROCREGAL, Unit]): PFNGLLOGMESSAGECALLBACKREGALPROC = o
    extension (v: PFNGLLOGMESSAGECALLBACKREGALPROC)
      inline def value: CFuncPtr1[GLLOGPROCREGAL, Unit] = v
      inline def toPtr: Ptr[?] = CFuncPtr.toPtr(v)

  opaque type PFNGLMAKEBUFFERNONRESIDENTNVPROC = CFuncPtr1[GLenum, Unit]
  object PFNGLMAKEBUFFERNONRESIDENTNVPROC:
    given _tag: Tag[PFNGLMAKEBUFFERNONRESIDENTNVPROC] = Tag.materializeCFuncPtr1[GLenum, Unit]
    inline def fromPtr(ptr: Ptr[Byte] | Ptr[?]): PFNGLMAKEBUFFERNONRESIDENTNVPROC = CFuncPtr.fromPtr(ptr.asInstanceOf[Ptr[Byte]])
    inline def apply(inline o: CFuncPtr1[GLenum, Unit]): PFNGLMAKEBUFFERNONRESIDENTNVPROC = o
    extension (v: PFNGLMAKEBUFFERNONRESIDENTNVPROC)
      inline def value: CFuncPtr1[GLenum, Unit] = v
      inline def toPtr: Ptr[?] = CFuncPtr.toPtr(v)

  opaque type PFNGLMAKEBUFFERRESIDENTNVPROC = CFuncPtr2[GLenum, GLenum, Unit]
  object PFNGLMAKEBUFFERRESIDENTNVPROC:
    given _tag: Tag[PFNGLMAKEBUFFERRESIDENTNVPROC] = Tag.materializeCFuncPtr2[GLenum, GLenum, Unit]
    inline def fromPtr(ptr: Ptr[Byte] | Ptr[?]): PFNGLMAKEBUFFERRESIDENTNVPROC = CFuncPtr.fromPtr(ptr.asInstanceOf[Ptr[Byte]])
    inline def apply(inline o: CFuncPtr2[GLenum, GLenum, Unit]): PFNGLMAKEBUFFERRESIDENTNVPROC = o
    extension (v: PFNGLMAKEBUFFERRESIDENTNVPROC)
      inline def value: CFuncPtr2[GLenum, GLenum, Unit] = v
      inline def toPtr: Ptr[?] = CFuncPtr.toPtr(v)

  opaque type PFNGLMAKEIMAGEHANDLENONRESIDENTARBPROC = CFuncPtr1[GLuint64, Unit]
  object PFNGLMAKEIMAGEHANDLENONRESIDENTARBPROC:
    given _tag: Tag[PFNGLMAKEIMAGEHANDLENONRESIDENTARBPROC] = Tag.materializeCFuncPtr1[GLuint64, Unit]
    inline def fromPtr(ptr: Ptr[Byte] | Ptr[?]): PFNGLMAKEIMAGEHANDLENONRESIDENTARBPROC = CFuncPtr.fromPtr(ptr.asInstanceOf[Ptr[Byte]])
    inline def apply(inline o: CFuncPtr1[GLuint64, Unit]): PFNGLMAKEIMAGEHANDLENONRESIDENTARBPROC = o
    extension (v: PFNGLMAKEIMAGEHANDLENONRESIDENTARBPROC)
      inline def value: CFuncPtr1[GLuint64, Unit] = v
      inline def toPtr: Ptr[?] = CFuncPtr.toPtr(v)

  opaque type PFNGLMAKEIMAGEHANDLENONRESIDENTNVPROC = CFuncPtr1[GLuint64, Unit]
  object PFNGLMAKEIMAGEHANDLENONRESIDENTNVPROC:
    given _tag: Tag[PFNGLMAKEIMAGEHANDLENONRESIDENTNVPROC] = Tag.materializeCFuncPtr1[GLuint64, Unit]
    inline def fromPtr(ptr: Ptr[Byte] | Ptr[?]): PFNGLMAKEIMAGEHANDLENONRESIDENTNVPROC = CFuncPtr.fromPtr(ptr.asInstanceOf[Ptr[Byte]])
    inline def apply(inline o: CFuncPtr1[GLuint64, Unit]): PFNGLMAKEIMAGEHANDLENONRESIDENTNVPROC = o
    extension (v: PFNGLMAKEIMAGEHANDLENONRESIDENTNVPROC)
      inline def value: CFuncPtr1[GLuint64, Unit] = v
      inline def toPtr: Ptr[?] = CFuncPtr.toPtr(v)

  opaque type PFNGLMAKEIMAGEHANDLERESIDENTARBPROC = CFuncPtr2[GLuint64, GLenum, Unit]
  object PFNGLMAKEIMAGEHANDLERESIDENTARBPROC:
    given _tag: Tag[PFNGLMAKEIMAGEHANDLERESIDENTARBPROC] = Tag.materializeCFuncPtr2[GLuint64, GLenum, Unit]
    inline def fromPtr(ptr: Ptr[Byte] | Ptr[?]): PFNGLMAKEIMAGEHANDLERESIDENTARBPROC = CFuncPtr.fromPtr(ptr.asInstanceOf[Ptr[Byte]])
    inline def apply(inline o: CFuncPtr2[GLuint64, GLenum, Unit]): PFNGLMAKEIMAGEHANDLERESIDENTARBPROC = o
    extension (v: PFNGLMAKEIMAGEHANDLERESIDENTARBPROC)
      inline def value: CFuncPtr2[GLuint64, GLenum, Unit] = v
      inline def toPtr: Ptr[?] = CFuncPtr.toPtr(v)

  opaque type PFNGLMAKEIMAGEHANDLERESIDENTNVPROC = CFuncPtr2[GLuint64, GLenum, Unit]
  object PFNGLMAKEIMAGEHANDLERESIDENTNVPROC:
    given _tag: Tag[PFNGLMAKEIMAGEHANDLERESIDENTNVPROC] = Tag.materializeCFuncPtr2[GLuint64, GLenum, Unit]
    inline def fromPtr(ptr: Ptr[Byte] | Ptr[?]): PFNGLMAKEIMAGEHANDLERESIDENTNVPROC = CFuncPtr.fromPtr(ptr.asInstanceOf[Ptr[Byte]])
    inline def apply(inline o: CFuncPtr2[GLuint64, GLenum, Unit]): PFNGLMAKEIMAGEHANDLERESIDENTNVPROC = o
    extension (v: PFNGLMAKEIMAGEHANDLERESIDENTNVPROC)
      inline def value: CFuncPtr2[GLuint64, GLenum, Unit] = v
      inline def toPtr: Ptr[?] = CFuncPtr.toPtr(v)

  opaque type PFNGLMAKENAMEDBUFFERNONRESIDENTNVPROC = CFuncPtr1[GLuint, Unit]
  object PFNGLMAKENAMEDBUFFERNONRESIDENTNVPROC:
    given _tag: Tag[PFNGLMAKENAMEDBUFFERNONRESIDENTNVPROC] = Tag.materializeCFuncPtr1[GLuint, Unit]
    inline def fromPtr(ptr: Ptr[Byte] | Ptr[?]): PFNGLMAKENAMEDBUFFERNONRESIDENTNVPROC = CFuncPtr.fromPtr(ptr.asInstanceOf[Ptr[Byte]])
    inline def apply(inline o: CFuncPtr1[GLuint, Unit]): PFNGLMAKENAMEDBUFFERNONRESIDENTNVPROC = o
    extension (v: PFNGLMAKENAMEDBUFFERNONRESIDENTNVPROC)
      inline def value: CFuncPtr1[GLuint, Unit] = v
      inline def toPtr: Ptr[?] = CFuncPtr.toPtr(v)

  opaque type PFNGLMAKENAMEDBUFFERRESIDENTNVPROC = CFuncPtr2[GLuint, GLenum, Unit]
  object PFNGLMAKENAMEDBUFFERRESIDENTNVPROC:
    given _tag: Tag[PFNGLMAKENAMEDBUFFERRESIDENTNVPROC] = Tag.materializeCFuncPtr2[GLuint, GLenum, Unit]
    inline def fromPtr(ptr: Ptr[Byte] | Ptr[?]): PFNGLMAKENAMEDBUFFERRESIDENTNVPROC = CFuncPtr.fromPtr(ptr.asInstanceOf[Ptr[Byte]])
    inline def apply(inline o: CFuncPtr2[GLuint, GLenum, Unit]): PFNGLMAKENAMEDBUFFERRESIDENTNVPROC = o
    extension (v: PFNGLMAKENAMEDBUFFERRESIDENTNVPROC)
      inline def value: CFuncPtr2[GLuint, GLenum, Unit] = v
      inline def toPtr: Ptr[?] = CFuncPtr.toPtr(v)

  opaque type PFNGLMAKETEXTUREHANDLENONRESIDENTARBPROC = CFuncPtr1[GLuint64, Unit]
  object PFNGLMAKETEXTUREHANDLENONRESIDENTARBPROC:
    given _tag: Tag[PFNGLMAKETEXTUREHANDLENONRESIDENTARBPROC] = Tag.materializeCFuncPtr1[GLuint64, Unit]
    inline def fromPtr(ptr: Ptr[Byte] | Ptr[?]): PFNGLMAKETEXTUREHANDLENONRESIDENTARBPROC = CFuncPtr.fromPtr(ptr.asInstanceOf[Ptr[Byte]])
    inline def apply(inline o: CFuncPtr1[GLuint64, Unit]): PFNGLMAKETEXTUREHANDLENONRESIDENTARBPROC = o
    extension (v: PFNGLMAKETEXTUREHANDLENONRESIDENTARBPROC)
      inline def value: CFuncPtr1[GLuint64, Unit] = v
      inline def toPtr: Ptr[?] = CFuncPtr.toPtr(v)

  opaque type PFNGLMAKETEXTUREHANDLENONRESIDENTNVPROC = CFuncPtr1[GLuint64, Unit]
  object PFNGLMAKETEXTUREHANDLENONRESIDENTNVPROC:
    given _tag: Tag[PFNGLMAKETEXTUREHANDLENONRESIDENTNVPROC] = Tag.materializeCFuncPtr1[GLuint64, Unit]
    inline def fromPtr(ptr: Ptr[Byte] | Ptr[?]): PFNGLMAKETEXTUREHANDLENONRESIDENTNVPROC = CFuncPtr.fromPtr(ptr.asInstanceOf[Ptr[Byte]])
    inline def apply(inline o: CFuncPtr1[GLuint64, Unit]): PFNGLMAKETEXTUREHANDLENONRESIDENTNVPROC = o
    extension (v: PFNGLMAKETEXTUREHANDLENONRESIDENTNVPROC)
      inline def value: CFuncPtr1[GLuint64, Unit] = v
      inline def toPtr: Ptr[?] = CFuncPtr.toPtr(v)

  opaque type PFNGLMAKETEXTUREHANDLERESIDENTARBPROC = CFuncPtr1[GLuint64, Unit]
  object PFNGLMAKETEXTUREHANDLERESIDENTARBPROC:
    given _tag: Tag[PFNGLMAKETEXTUREHANDLERESIDENTARBPROC] = Tag.materializeCFuncPtr1[GLuint64, Unit]
    inline def fromPtr(ptr: Ptr[Byte] | Ptr[?]): PFNGLMAKETEXTUREHANDLERESIDENTARBPROC = CFuncPtr.fromPtr(ptr.asInstanceOf[Ptr[Byte]])
    inline def apply(inline o: CFuncPtr1[GLuint64, Unit]): PFNGLMAKETEXTUREHANDLERESIDENTARBPROC = o
    extension (v: PFNGLMAKETEXTUREHANDLERESIDENTARBPROC)
      inline def value: CFuncPtr1[GLuint64, Unit] = v
      inline def toPtr: Ptr[?] = CFuncPtr.toPtr(v)

  opaque type PFNGLMAKETEXTUREHANDLERESIDENTNVPROC = CFuncPtr1[GLuint64, Unit]
  object PFNGLMAKETEXTUREHANDLERESIDENTNVPROC:
    given _tag: Tag[PFNGLMAKETEXTUREHANDLERESIDENTNVPROC] = Tag.materializeCFuncPtr1[GLuint64, Unit]
    inline def fromPtr(ptr: Ptr[Byte] | Ptr[?]): PFNGLMAKETEXTUREHANDLERESIDENTNVPROC = CFuncPtr.fromPtr(ptr.asInstanceOf[Ptr[Byte]])
    inline def apply(inline o: CFuncPtr1[GLuint64, Unit]): PFNGLMAKETEXTUREHANDLERESIDENTNVPROC = o
    extension (v: PFNGLMAKETEXTUREHANDLERESIDENTNVPROC)
      inline def value: CFuncPtr1[GLuint64, Unit] = v
      inline def toPtr: Ptr[?] = CFuncPtr.toPtr(v)

  opaque type PFNGLMAPBUFFERARBPROC = CFuncPtr2[GLenum, GLenum, Ptr[Byte]]
  object PFNGLMAPBUFFERARBPROC:
    given _tag: Tag[PFNGLMAPBUFFERARBPROC] = Tag.materializeCFuncPtr2[GLenum, GLenum, Ptr[Byte]]
    inline def fromPtr(ptr: Ptr[Byte] | Ptr[?]): PFNGLMAPBUFFERARBPROC = CFuncPtr.fromPtr(ptr.asInstanceOf[Ptr[Byte]])
    inline def apply(inline o: CFuncPtr2[GLenum, GLenum, Ptr[Byte]]): PFNGLMAPBUFFERARBPROC = o
    extension (v: PFNGLMAPBUFFERARBPROC)
      inline def value: CFuncPtr2[GLenum, GLenum, Ptr[Byte]] = v
      inline def toPtr: Ptr[?] = CFuncPtr.toPtr(v)

  opaque type PFNGLMAPBUFFEROESPROC = CFuncPtr2[GLenum, GLenum, Ptr[Byte]]
  object PFNGLMAPBUFFEROESPROC:
    given _tag: Tag[PFNGLMAPBUFFEROESPROC] = Tag.materializeCFuncPtr2[GLenum, GLenum, Ptr[Byte]]
    inline def fromPtr(ptr: Ptr[Byte] | Ptr[?]): PFNGLMAPBUFFEROESPROC = CFuncPtr.fromPtr(ptr.asInstanceOf[Ptr[Byte]])
    inline def apply(inline o: CFuncPtr2[GLenum, GLenum, Ptr[Byte]]): PFNGLMAPBUFFEROESPROC = o
    extension (v: PFNGLMAPBUFFEROESPROC)
      inline def value: CFuncPtr2[GLenum, GLenum, Ptr[Byte]] = v
      inline def toPtr: Ptr[?] = CFuncPtr.toPtr(v)

  opaque type PFNGLMAPBUFFERPROC = CFuncPtr2[GLenum, GLenum, Ptr[Byte]]
  object PFNGLMAPBUFFERPROC:
    given _tag: Tag[PFNGLMAPBUFFERPROC] = Tag.materializeCFuncPtr2[GLenum, GLenum, Ptr[Byte]]
    inline def fromPtr(ptr: Ptr[Byte] | Ptr[?]): PFNGLMAPBUFFERPROC = CFuncPtr.fromPtr(ptr.asInstanceOf[Ptr[Byte]])
    inline def apply(inline o: CFuncPtr2[GLenum, GLenum, Ptr[Byte]]): PFNGLMAPBUFFERPROC = o
    extension (v: PFNGLMAPBUFFERPROC)
      inline def value: CFuncPtr2[GLenum, GLenum, Ptr[Byte]] = v
      inline def toPtr: Ptr[?] = CFuncPtr.toPtr(v)

  opaque type PFNGLMAPBUFFERRANGEEXTPROC = CFuncPtr4[GLenum, GLintptr, GLsizeiptr, GLbitfield, Ptr[Byte]]
  object PFNGLMAPBUFFERRANGEEXTPROC:
    given _tag: Tag[PFNGLMAPBUFFERRANGEEXTPROC] = Tag.materializeCFuncPtr4[GLenum, GLintptr, GLsizeiptr, GLbitfield, Ptr[Byte]]
    inline def fromPtr(ptr: Ptr[Byte] | Ptr[?]): PFNGLMAPBUFFERRANGEEXTPROC = CFuncPtr.fromPtr(ptr.asInstanceOf[Ptr[Byte]])
    inline def apply(inline o: CFuncPtr4[GLenum, GLintptr, GLsizeiptr, GLbitfield, Ptr[Byte]]): PFNGLMAPBUFFERRANGEEXTPROC = o
    extension (v: PFNGLMAPBUFFERRANGEEXTPROC)
      inline def value: CFuncPtr4[GLenum, GLintptr, GLsizeiptr, GLbitfield, Ptr[Byte]] = v
      inline def toPtr: Ptr[?] = CFuncPtr.toPtr(v)

  opaque type PFNGLMAPBUFFERRANGEPROC = CFuncPtr4[GLenum, GLintptr, GLsizeiptr, GLbitfield, Ptr[Byte]]
  object PFNGLMAPBUFFERRANGEPROC:
    given _tag: Tag[PFNGLMAPBUFFERRANGEPROC] = Tag.materializeCFuncPtr4[GLenum, GLintptr, GLsizeiptr, GLbitfield, Ptr[Byte]]
    inline def fromPtr(ptr: Ptr[Byte] | Ptr[?]): PFNGLMAPBUFFERRANGEPROC = CFuncPtr.fromPtr(ptr.asInstanceOf[Ptr[Byte]])
    inline def apply(inline o: CFuncPtr4[GLenum, GLintptr, GLsizeiptr, GLbitfield, Ptr[Byte]]): PFNGLMAPBUFFERRANGEPROC = o
    extension (v: PFNGLMAPBUFFERRANGEPROC)
      inline def value: CFuncPtr4[GLenum, GLintptr, GLsizeiptr, GLbitfield, Ptr[Byte]] = v
      inline def toPtr: Ptr[?] = CFuncPtr.toPtr(v)

  opaque type PFNGLMAPCONTROLPOINTSNVPROC = CFuncPtr9[GLenum, GLuint, GLenum, GLsizei, GLsizei, GLint, GLint, GLboolean, Ptr[Byte], Unit]
  object PFNGLMAPCONTROLPOINTSNVPROC:
    given _tag: Tag[PFNGLMAPCONTROLPOINTSNVPROC] = Tag.materializeCFuncPtr9[GLenum, GLuint, GLenum, GLsizei, GLsizei, GLint, GLint, GLboolean, Ptr[Byte], Unit]
    inline def fromPtr(ptr: Ptr[Byte] | Ptr[?]): PFNGLMAPCONTROLPOINTSNVPROC = CFuncPtr.fromPtr(ptr.asInstanceOf[Ptr[Byte]])
    inline def apply(inline o: CFuncPtr9[GLenum, GLuint, GLenum, GLsizei, GLsizei, GLint, GLint, GLboolean, Ptr[Byte], Unit]): PFNGLMAPCONTROLPOINTSNVPROC = o
    extension (v: PFNGLMAPCONTROLPOINTSNVPROC)
      inline def value: CFuncPtr9[GLenum, GLuint, GLenum, GLsizei, GLsizei, GLint, GLint, GLboolean, Ptr[Byte], Unit] = v
      inline def toPtr: Ptr[?] = CFuncPtr.toPtr(v)

  opaque type PFNGLMAPNAMEDBUFFEREXTPROC = CFuncPtr2[GLuint, GLenum, Ptr[Byte]]
  object PFNGLMAPNAMEDBUFFEREXTPROC:
    given _tag: Tag[PFNGLMAPNAMEDBUFFEREXTPROC] = Tag.materializeCFuncPtr2[GLuint, GLenum, Ptr[Byte]]
    inline def fromPtr(ptr: Ptr[Byte] | Ptr[?]): PFNGLMAPNAMEDBUFFEREXTPROC = CFuncPtr.fromPtr(ptr.asInstanceOf[Ptr[Byte]])
    inline def apply(inline o: CFuncPtr2[GLuint, GLenum, Ptr[Byte]]): PFNGLMAPNAMEDBUFFEREXTPROC = o
    extension (v: PFNGLMAPNAMEDBUFFEREXTPROC)
      inline def value: CFuncPtr2[GLuint, GLenum, Ptr[Byte]] = v
      inline def toPtr: Ptr[?] = CFuncPtr.toPtr(v)

  opaque type PFNGLMAPNAMEDBUFFERPROC = CFuncPtr2[GLuint, GLenum, Ptr[Byte]]
  object PFNGLMAPNAMEDBUFFERPROC:
    given _tag: Tag[PFNGLMAPNAMEDBUFFERPROC] = Tag.materializeCFuncPtr2[GLuint, GLenum, Ptr[Byte]]
    inline def fromPtr(ptr: Ptr[Byte] | Ptr[?]): PFNGLMAPNAMEDBUFFERPROC = CFuncPtr.fromPtr(ptr.asInstanceOf[Ptr[Byte]])
    inline def apply(inline o: CFuncPtr2[GLuint, GLenum, Ptr[Byte]]): PFNGLMAPNAMEDBUFFERPROC = o
    extension (v: PFNGLMAPNAMEDBUFFERPROC)
      inline def value: CFuncPtr2[GLuint, GLenum, Ptr[Byte]] = v
      inline def toPtr: Ptr[?] = CFuncPtr.toPtr(v)

  opaque type PFNGLMAPNAMEDBUFFERRANGEEXTPROC = CFuncPtr4[GLuint, GLintptr, GLsizeiptr, GLbitfield, Ptr[Byte]]
  object PFNGLMAPNAMEDBUFFERRANGEEXTPROC:
    given _tag: Tag[PFNGLMAPNAMEDBUFFERRANGEEXTPROC] = Tag.materializeCFuncPtr4[GLuint, GLintptr, GLsizeiptr, GLbitfield, Ptr[Byte]]
    inline def fromPtr(ptr: Ptr[Byte] | Ptr[?]): PFNGLMAPNAMEDBUFFERRANGEEXTPROC = CFuncPtr.fromPtr(ptr.asInstanceOf[Ptr[Byte]])
    inline def apply(inline o: CFuncPtr4[GLuint, GLintptr, GLsizeiptr, GLbitfield, Ptr[Byte]]): PFNGLMAPNAMEDBUFFERRANGEEXTPROC = o
    extension (v: PFNGLMAPNAMEDBUFFERRANGEEXTPROC)
      inline def value: CFuncPtr4[GLuint, GLintptr, GLsizeiptr, GLbitfield, Ptr[Byte]] = v
      inline def toPtr: Ptr[?] = CFuncPtr.toPtr(v)

  opaque type PFNGLMAPNAMEDBUFFERRANGEPROC = CFuncPtr4[GLuint, GLintptr, GLsizeiptr, GLbitfield, Ptr[Byte]]
  object PFNGLMAPNAMEDBUFFERRANGEPROC:
    given _tag: Tag[PFNGLMAPNAMEDBUFFERRANGEPROC] = Tag.materializeCFuncPtr4[GLuint, GLintptr, GLsizeiptr, GLbitfield, Ptr[Byte]]
    inline def fromPtr(ptr: Ptr[Byte] | Ptr[?]): PFNGLMAPNAMEDBUFFERRANGEPROC = CFuncPtr.fromPtr(ptr.asInstanceOf[Ptr[Byte]])
    inline def apply(inline o: CFuncPtr4[GLuint, GLintptr, GLsizeiptr, GLbitfield, Ptr[Byte]]): PFNGLMAPNAMEDBUFFERRANGEPROC = o
    extension (v: PFNGLMAPNAMEDBUFFERRANGEPROC)
      inline def value: CFuncPtr4[GLuint, GLintptr, GLsizeiptr, GLbitfield, Ptr[Byte]] = v
      inline def toPtr: Ptr[?] = CFuncPtr.toPtr(v)

  opaque type PFNGLMAPOBJECTBUFFERATIPROC = CFuncPtr1[GLuint, Ptr[Byte]]
  object PFNGLMAPOBJECTBUFFERATIPROC:
    given _tag: Tag[PFNGLMAPOBJECTBUFFERATIPROC] = Tag.materializeCFuncPtr1[GLuint, Ptr[Byte]]
    inline def fromPtr(ptr: Ptr[Byte] | Ptr[?]): PFNGLMAPOBJECTBUFFERATIPROC = CFuncPtr.fromPtr(ptr.asInstanceOf[Ptr[Byte]])
    inline def apply(inline o: CFuncPtr1[GLuint, Ptr[Byte]]): PFNGLMAPOBJECTBUFFERATIPROC = o
    extension (v: PFNGLMAPOBJECTBUFFERATIPROC)
      inline def value: CFuncPtr1[GLuint, Ptr[Byte]] = v
      inline def toPtr: Ptr[?] = CFuncPtr.toPtr(v)

  opaque type PFNGLMAPPARAMETERFVNVPROC = CFuncPtr3[GLenum, GLenum, Ptr[GLfloat], Unit]
  object PFNGLMAPPARAMETERFVNVPROC:
    given _tag: Tag[PFNGLMAPPARAMETERFVNVPROC] = Tag.materializeCFuncPtr3[GLenum, GLenum, Ptr[GLfloat], Unit]
    inline def fromPtr(ptr: Ptr[Byte] | Ptr[?]): PFNGLMAPPARAMETERFVNVPROC = CFuncPtr.fromPtr(ptr.asInstanceOf[Ptr[Byte]])
    inline def apply(inline o: CFuncPtr3[GLenum, GLenum, Ptr[GLfloat], Unit]): PFNGLMAPPARAMETERFVNVPROC = o
    extension (v: PFNGLMAPPARAMETERFVNVPROC)
      inline def value: CFuncPtr3[GLenum, GLenum, Ptr[GLfloat], Unit] = v
      inline def toPtr: Ptr[?] = CFuncPtr.toPtr(v)

  opaque type PFNGLMAPPARAMETERIVNVPROC = CFuncPtr3[GLenum, GLenum, Ptr[GLint], Unit]
  object PFNGLMAPPARAMETERIVNVPROC:
    given _tag: Tag[PFNGLMAPPARAMETERIVNVPROC] = Tag.materializeCFuncPtr3[GLenum, GLenum, Ptr[GLint], Unit]
    inline def fromPtr(ptr: Ptr[Byte] | Ptr[?]): PFNGLMAPPARAMETERIVNVPROC = CFuncPtr.fromPtr(ptr.asInstanceOf[Ptr[Byte]])
    inline def apply(inline o: CFuncPtr3[GLenum, GLenum, Ptr[GLint], Unit]): PFNGLMAPPARAMETERIVNVPROC = o
    extension (v: PFNGLMAPPARAMETERIVNVPROC)
      inline def value: CFuncPtr3[GLenum, GLenum, Ptr[GLint], Unit] = v
      inline def toPtr: Ptr[?] = CFuncPtr.toPtr(v)

  opaque type PFNGLMAPTEXTURE2DINTELPROC = CFuncPtr5[GLuint, GLint, GLbitfield, Ptr[GLint], Ptr[GLenum], Ptr[Byte]]
  object PFNGLMAPTEXTURE2DINTELPROC:
    given _tag: Tag[PFNGLMAPTEXTURE2DINTELPROC] = Tag.materializeCFuncPtr5[GLuint, GLint, GLbitfield, Ptr[GLint], Ptr[GLenum], Ptr[Byte]]
    inline def fromPtr(ptr: Ptr[Byte] | Ptr[?]): PFNGLMAPTEXTURE2DINTELPROC = CFuncPtr.fromPtr(ptr.asInstanceOf[Ptr[Byte]])
    inline def apply(inline o: CFuncPtr5[GLuint, GLint, GLbitfield, Ptr[GLint], Ptr[GLenum], Ptr[Byte]]): PFNGLMAPTEXTURE2DINTELPROC = o
    extension (v: PFNGLMAPTEXTURE2DINTELPROC)
      inline def value: CFuncPtr5[GLuint, GLint, GLbitfield, Ptr[GLint], Ptr[GLenum], Ptr[Byte]] = v
      inline def toPtr: Ptr[?] = CFuncPtr.toPtr(v)

  opaque type PFNGLMAPVERTEXATTRIB1DAPPLEPROC = CFuncPtr7[GLuint, GLuint, GLdouble, GLdouble, GLint, GLint, Ptr[GLdouble], Unit]
  object PFNGLMAPVERTEXATTRIB1DAPPLEPROC:
    given _tag: Tag[PFNGLMAPVERTEXATTRIB1DAPPLEPROC] = Tag.materializeCFuncPtr7[GLuint, GLuint, GLdouble, GLdouble, GLint, GLint, Ptr[GLdouble], Unit]
    inline def fromPtr(ptr: Ptr[Byte] | Ptr[?]): PFNGLMAPVERTEXATTRIB1DAPPLEPROC = CFuncPtr.fromPtr(ptr.asInstanceOf[Ptr[Byte]])
    inline def apply(inline o: CFuncPtr7[GLuint, GLuint, GLdouble, GLdouble, GLint, GLint, Ptr[GLdouble], Unit]): PFNGLMAPVERTEXATTRIB1DAPPLEPROC = o
    extension (v: PFNGLMAPVERTEXATTRIB1DAPPLEPROC)
      inline def value: CFuncPtr7[GLuint, GLuint, GLdouble, GLdouble, GLint, GLint, Ptr[GLdouble], Unit] = v
      inline def toPtr: Ptr[?] = CFuncPtr.toPtr(v)

  opaque type PFNGLMAPVERTEXATTRIB1FAPPLEPROC = CFuncPtr7[GLuint, GLuint, GLfloat, GLfloat, GLint, GLint, Ptr[GLfloat], Unit]
  object PFNGLMAPVERTEXATTRIB1FAPPLEPROC:
    given _tag: Tag[PFNGLMAPVERTEXATTRIB1FAPPLEPROC] = Tag.materializeCFuncPtr7[GLuint, GLuint, GLfloat, GLfloat, GLint, GLint, Ptr[GLfloat], Unit]
    inline def fromPtr(ptr: Ptr[Byte] | Ptr[?]): PFNGLMAPVERTEXATTRIB1FAPPLEPROC = CFuncPtr.fromPtr(ptr.asInstanceOf[Ptr[Byte]])
    inline def apply(inline o: CFuncPtr7[GLuint, GLuint, GLfloat, GLfloat, GLint, GLint, Ptr[GLfloat], Unit]): PFNGLMAPVERTEXATTRIB1FAPPLEPROC = o
    extension (v: PFNGLMAPVERTEXATTRIB1FAPPLEPROC)
      inline def value: CFuncPtr7[GLuint, GLuint, GLfloat, GLfloat, GLint, GLint, Ptr[GLfloat], Unit] = v
      inline def toPtr: Ptr[?] = CFuncPtr.toPtr(v)

  opaque type PFNGLMAPVERTEXATTRIB2DAPPLEPROC = CFuncPtr11[GLuint, GLuint, GLdouble, GLdouble, GLint, GLint, GLdouble, GLdouble, GLint, GLint, Ptr[GLdouble], Unit]
  object PFNGLMAPVERTEXATTRIB2DAPPLEPROC:
    given _tag: Tag[PFNGLMAPVERTEXATTRIB2DAPPLEPROC] = Tag.materializeCFuncPtr11[GLuint, GLuint, GLdouble, GLdouble, GLint, GLint, GLdouble, GLdouble, GLint, GLint, Ptr[GLdouble], Unit]
    inline def fromPtr(ptr: Ptr[Byte] | Ptr[?]): PFNGLMAPVERTEXATTRIB2DAPPLEPROC = CFuncPtr.fromPtr(ptr.asInstanceOf[Ptr[Byte]])
    inline def apply(inline o: CFuncPtr11[GLuint, GLuint, GLdouble, GLdouble, GLint, GLint, GLdouble, GLdouble, GLint, GLint, Ptr[GLdouble], Unit]): PFNGLMAPVERTEXATTRIB2DAPPLEPROC = o
    extension (v: PFNGLMAPVERTEXATTRIB2DAPPLEPROC)
      inline def value: CFuncPtr11[GLuint, GLuint, GLdouble, GLdouble, GLint, GLint, GLdouble, GLdouble, GLint, GLint, Ptr[GLdouble], Unit] = v
      inline def toPtr: Ptr[?] = CFuncPtr.toPtr(v)

  opaque type PFNGLMAPVERTEXATTRIB2FAPPLEPROC = CFuncPtr11[GLuint, GLuint, GLfloat, GLfloat, GLint, GLint, GLfloat, GLfloat, GLint, GLint, Ptr[GLfloat], Unit]
  object PFNGLMAPVERTEXATTRIB2FAPPLEPROC:
    given _tag: Tag[PFNGLMAPVERTEXATTRIB2FAPPLEPROC] = Tag.materializeCFuncPtr11[GLuint, GLuint, GLfloat, GLfloat, GLint, GLint, GLfloat, GLfloat, GLint, GLint, Ptr[GLfloat], Unit]
    inline def fromPtr(ptr: Ptr[Byte] | Ptr[?]): PFNGLMAPVERTEXATTRIB2FAPPLEPROC = CFuncPtr.fromPtr(ptr.asInstanceOf[Ptr[Byte]])
    inline def apply(inline o: CFuncPtr11[GLuint, GLuint, GLfloat, GLfloat, GLint, GLint, GLfloat, GLfloat, GLint, GLint, Ptr[GLfloat], Unit]): PFNGLMAPVERTEXATTRIB2FAPPLEPROC = o
    extension (v: PFNGLMAPVERTEXATTRIB2FAPPLEPROC)
      inline def value: CFuncPtr11[GLuint, GLuint, GLfloat, GLfloat, GLint, GLint, GLfloat, GLfloat, GLint, GLint, Ptr[GLfloat], Unit] = v
      inline def toPtr: Ptr[?] = CFuncPtr.toPtr(v)

  opaque type PFNGLMATERIALXPROC = CFuncPtr3[GLenum, GLenum, GLfixed, Unit]
  object PFNGLMATERIALXPROC:
    given _tag: Tag[PFNGLMATERIALXPROC] = Tag.materializeCFuncPtr3[GLenum, GLenum, GLfixed, Unit]
    inline def fromPtr(ptr: Ptr[Byte] | Ptr[?]): PFNGLMATERIALXPROC = CFuncPtr.fromPtr(ptr.asInstanceOf[Ptr[Byte]])
    inline def apply(inline o: CFuncPtr3[GLenum, GLenum, GLfixed, Unit]): PFNGLMATERIALXPROC = o
    extension (v: PFNGLMATERIALXPROC)
      inline def value: CFuncPtr3[GLenum, GLenum, GLfixed, Unit] = v
      inline def toPtr: Ptr[?] = CFuncPtr.toPtr(v)

  opaque type PFNGLMATERIALXVPROC = CFuncPtr3[GLenum, GLenum, Ptr[GLfixed], Unit]
  object PFNGLMATERIALXVPROC:
    given _tag: Tag[PFNGLMATERIALXVPROC] = Tag.materializeCFuncPtr3[GLenum, GLenum, Ptr[GLfixed], Unit]
    inline def fromPtr(ptr: Ptr[Byte] | Ptr[?]): PFNGLMATERIALXVPROC = CFuncPtr.fromPtr(ptr.asInstanceOf[Ptr[Byte]])
    inline def apply(inline o: CFuncPtr3[GLenum, GLenum, Ptr[GLfixed], Unit]): PFNGLMATERIALXVPROC = o
    extension (v: PFNGLMATERIALXVPROC)
      inline def value: CFuncPtr3[GLenum, GLenum, Ptr[GLfixed], Unit] = v
      inline def toPtr: Ptr[?] = CFuncPtr.toPtr(v)

  opaque type PFNGLMATRIXFRUSTUMEXTPROC = CFuncPtr7[GLenum, GLdouble, GLdouble, GLdouble, GLdouble, GLdouble, GLdouble, Unit]
  object PFNGLMATRIXFRUSTUMEXTPROC:
    given _tag: Tag[PFNGLMATRIXFRUSTUMEXTPROC] = Tag.materializeCFuncPtr7[GLenum, GLdouble, GLdouble, GLdouble, GLdouble, GLdouble, GLdouble, Unit]
    inline def fromPtr(ptr: Ptr[Byte] | Ptr[?]): PFNGLMATRIXFRUSTUMEXTPROC = CFuncPtr.fromPtr(ptr.asInstanceOf[Ptr[Byte]])
    inline def apply(inline o: CFuncPtr7[GLenum, GLdouble, GLdouble, GLdouble, GLdouble, GLdouble, GLdouble, Unit]): PFNGLMATRIXFRUSTUMEXTPROC = o
    extension (v: PFNGLMATRIXFRUSTUMEXTPROC)
      inline def value: CFuncPtr7[GLenum, GLdouble, GLdouble, GLdouble, GLdouble, GLdouble, GLdouble, Unit] = v
      inline def toPtr: Ptr[?] = CFuncPtr.toPtr(v)

  opaque type PFNGLMATRIXINDEXPOINTERARBPROC = CFuncPtr4[GLint, GLenum, GLsizei, Ptr[Byte], Unit]
  object PFNGLMATRIXINDEXPOINTERARBPROC:
    given _tag: Tag[PFNGLMATRIXINDEXPOINTERARBPROC] = Tag.materializeCFuncPtr4[GLint, GLenum, GLsizei, Ptr[Byte], Unit]
    inline def fromPtr(ptr: Ptr[Byte] | Ptr[?]): PFNGLMATRIXINDEXPOINTERARBPROC = CFuncPtr.fromPtr(ptr.asInstanceOf[Ptr[Byte]])
    inline def apply(inline o: CFuncPtr4[GLint, GLenum, GLsizei, Ptr[Byte], Unit]): PFNGLMATRIXINDEXPOINTERARBPROC = o
    extension (v: PFNGLMATRIXINDEXPOINTERARBPROC)
      inline def value: CFuncPtr4[GLint, GLenum, GLsizei, Ptr[Byte], Unit] = v
      inline def toPtr: Ptr[?] = CFuncPtr.toPtr(v)

  opaque type PFNGLMATRIXINDEXPOINTEROESPROC = CFuncPtr4[GLint, GLenum, GLsizei, Ptr[Byte], Unit]
  object PFNGLMATRIXINDEXPOINTEROESPROC:
    given _tag: Tag[PFNGLMATRIXINDEXPOINTEROESPROC] = Tag.materializeCFuncPtr4[GLint, GLenum, GLsizei, Ptr[Byte], Unit]
    inline def fromPtr(ptr: Ptr[Byte] | Ptr[?]): PFNGLMATRIXINDEXPOINTEROESPROC = CFuncPtr.fromPtr(ptr.asInstanceOf[Ptr[Byte]])
    inline def apply(inline o: CFuncPtr4[GLint, GLenum, GLsizei, Ptr[Byte], Unit]): PFNGLMATRIXINDEXPOINTEROESPROC = o
    extension (v: PFNGLMATRIXINDEXPOINTEROESPROC)
      inline def value: CFuncPtr4[GLint, GLenum, GLsizei, Ptr[Byte], Unit] = v
      inline def toPtr: Ptr[?] = CFuncPtr.toPtr(v)

  opaque type PFNGLMATRIXINDEXUBVARBPROC = CFuncPtr2[GLint, Ptr[GLubyte], Unit]
  object PFNGLMATRIXINDEXUBVARBPROC:
    given _tag: Tag[PFNGLMATRIXINDEXUBVARBPROC] = Tag.materializeCFuncPtr2[GLint, Ptr[GLubyte], Unit]
    inline def fromPtr(ptr: Ptr[Byte] | Ptr[?]): PFNGLMATRIXINDEXUBVARBPROC = CFuncPtr.fromPtr(ptr.asInstanceOf[Ptr[Byte]])
    inline def apply(inline o: CFuncPtr2[GLint, Ptr[GLubyte], Unit]): PFNGLMATRIXINDEXUBVARBPROC = o
    extension (v: PFNGLMATRIXINDEXUBVARBPROC)
      inline def value: CFuncPtr2[GLint, Ptr[GLubyte], Unit] = v
      inline def toPtr: Ptr[?] = CFuncPtr.toPtr(v)

  opaque type PFNGLMATRIXINDEXUIVARBPROC = CFuncPtr2[GLint, Ptr[GLuint], Unit]
  object PFNGLMATRIXINDEXUIVARBPROC:
    given _tag: Tag[PFNGLMATRIXINDEXUIVARBPROC] = Tag.materializeCFuncPtr2[GLint, Ptr[GLuint], Unit]
    inline def fromPtr(ptr: Ptr[Byte] | Ptr[?]): PFNGLMATRIXINDEXUIVARBPROC = CFuncPtr.fromPtr(ptr.asInstanceOf[Ptr[Byte]])
    inline def apply(inline o: CFuncPtr2[GLint, Ptr[GLuint], Unit]): PFNGLMATRIXINDEXUIVARBPROC = o
    extension (v: PFNGLMATRIXINDEXUIVARBPROC)
      inline def value: CFuncPtr2[GLint, Ptr[GLuint], Unit] = v
      inline def toPtr: Ptr[?] = CFuncPtr.toPtr(v)

  opaque type PFNGLMATRIXINDEXUSVARBPROC = CFuncPtr2[GLint, Ptr[GLushort], Unit]
  object PFNGLMATRIXINDEXUSVARBPROC:
    given _tag: Tag[PFNGLMATRIXINDEXUSVARBPROC] = Tag.materializeCFuncPtr2[GLint, Ptr[GLushort], Unit]
    inline def fromPtr(ptr: Ptr[Byte] | Ptr[?]): PFNGLMATRIXINDEXUSVARBPROC = CFuncPtr.fromPtr(ptr.asInstanceOf[Ptr[Byte]])
    inline def apply(inline o: CFuncPtr2[GLint, Ptr[GLushort], Unit]): PFNGLMATRIXINDEXUSVARBPROC = o
    extension (v: PFNGLMATRIXINDEXUSVARBPROC)
      inline def value: CFuncPtr2[GLint, Ptr[GLushort], Unit] = v
      inline def toPtr: Ptr[?] = CFuncPtr.toPtr(v)

  opaque type PFNGLMATRIXLOAD3X2FNVPROC = CFuncPtr2[GLenum, Ptr[GLfloat], Unit]
  object PFNGLMATRIXLOAD3X2FNVPROC:
    given _tag: Tag[PFNGLMATRIXLOAD3X2FNVPROC] = Tag.materializeCFuncPtr2[GLenum, Ptr[GLfloat], Unit]
    inline def fromPtr(ptr: Ptr[Byte] | Ptr[?]): PFNGLMATRIXLOAD3X2FNVPROC = CFuncPtr.fromPtr(ptr.asInstanceOf[Ptr[Byte]])
    inline def apply(inline o: CFuncPtr2[GLenum, Ptr[GLfloat], Unit]): PFNGLMATRIXLOAD3X2FNVPROC = o
    extension (v: PFNGLMATRIXLOAD3X2FNVPROC)
      inline def value: CFuncPtr2[GLenum, Ptr[GLfloat], Unit] = v
      inline def toPtr: Ptr[?] = CFuncPtr.toPtr(v)

  opaque type PFNGLMATRIXLOAD3X3FNVPROC = CFuncPtr2[GLenum, Ptr[GLfloat], Unit]
  object PFNGLMATRIXLOAD3X3FNVPROC:
    given _tag: Tag[PFNGLMATRIXLOAD3X3FNVPROC] = Tag.materializeCFuncPtr2[GLenum, Ptr[GLfloat], Unit]
    inline def fromPtr(ptr: Ptr[Byte] | Ptr[?]): PFNGLMATRIXLOAD3X3FNVPROC = CFuncPtr.fromPtr(ptr.asInstanceOf[Ptr[Byte]])
    inline def apply(inline o: CFuncPtr2[GLenum, Ptr[GLfloat], Unit]): PFNGLMATRIXLOAD3X3FNVPROC = o
    extension (v: PFNGLMATRIXLOAD3X3FNVPROC)
      inline def value: CFuncPtr2[GLenum, Ptr[GLfloat], Unit] = v
      inline def toPtr: Ptr[?] = CFuncPtr.toPtr(v)

  opaque type PFNGLMATRIXLOADDEXTPROC = CFuncPtr2[GLenum, Ptr[GLdouble], Unit]
  object PFNGLMATRIXLOADDEXTPROC:
    given _tag: Tag[PFNGLMATRIXLOADDEXTPROC] = Tag.materializeCFuncPtr2[GLenum, Ptr[GLdouble], Unit]
    inline def fromPtr(ptr: Ptr[Byte] | Ptr[?]): PFNGLMATRIXLOADDEXTPROC = CFuncPtr.fromPtr(ptr.asInstanceOf[Ptr[Byte]])
    inline def apply(inline o: CFuncPtr2[GLenum, Ptr[GLdouble], Unit]): PFNGLMATRIXLOADDEXTPROC = o
    extension (v: PFNGLMATRIXLOADDEXTPROC)
      inline def value: CFuncPtr2[GLenum, Ptr[GLdouble], Unit] = v
      inline def toPtr: Ptr[?] = CFuncPtr.toPtr(v)

  opaque type PFNGLMATRIXLOADFEXTPROC = CFuncPtr2[GLenum, Ptr[GLfloat], Unit]
  object PFNGLMATRIXLOADFEXTPROC:
    given _tag: Tag[PFNGLMATRIXLOADFEXTPROC] = Tag.materializeCFuncPtr2[GLenum, Ptr[GLfloat], Unit]
    inline def fromPtr(ptr: Ptr[Byte] | Ptr[?]): PFNGLMATRIXLOADFEXTPROC = CFuncPtr.fromPtr(ptr.asInstanceOf[Ptr[Byte]])
    inline def apply(inline o: CFuncPtr2[GLenum, Ptr[GLfloat], Unit]): PFNGLMATRIXLOADFEXTPROC = o
    extension (v: PFNGLMATRIXLOADFEXTPROC)
      inline def value: CFuncPtr2[GLenum, Ptr[GLfloat], Unit] = v
      inline def toPtr: Ptr[?] = CFuncPtr.toPtr(v)

  opaque type PFNGLMATRIXLOADIDENTITYEXTPROC = CFuncPtr1[GLenum, Unit]
  object PFNGLMATRIXLOADIDENTITYEXTPROC:
    given _tag: Tag[PFNGLMATRIXLOADIDENTITYEXTPROC] = Tag.materializeCFuncPtr1[GLenum, Unit]
    inline def fromPtr(ptr: Ptr[Byte] | Ptr[?]): PFNGLMATRIXLOADIDENTITYEXTPROC = CFuncPtr.fromPtr(ptr.asInstanceOf[Ptr[Byte]])
    inline def apply(inline o: CFuncPtr1[GLenum, Unit]): PFNGLMATRIXLOADIDENTITYEXTPROC = o
    extension (v: PFNGLMATRIXLOADIDENTITYEXTPROC)
      inline def value: CFuncPtr1[GLenum, Unit] = v
      inline def toPtr: Ptr[?] = CFuncPtr.toPtr(v)

  opaque type PFNGLMATRIXLOADTRANSPOSE3X3FNVPROC = CFuncPtr2[GLenum, Ptr[GLfloat], Unit]
  object PFNGLMATRIXLOADTRANSPOSE3X3FNVPROC:
    given _tag: Tag[PFNGLMATRIXLOADTRANSPOSE3X3FNVPROC] = Tag.materializeCFuncPtr2[GLenum, Ptr[GLfloat], Unit]
    inline def fromPtr(ptr: Ptr[Byte] | Ptr[?]): PFNGLMATRIXLOADTRANSPOSE3X3FNVPROC = CFuncPtr.fromPtr(ptr.asInstanceOf[Ptr[Byte]])
    inline def apply(inline o: CFuncPtr2[GLenum, Ptr[GLfloat], Unit]): PFNGLMATRIXLOADTRANSPOSE3X3FNVPROC = o
    extension (v: PFNGLMATRIXLOADTRANSPOSE3X3FNVPROC)
      inline def value: CFuncPtr2[GLenum, Ptr[GLfloat], Unit] = v
      inline def toPtr: Ptr[?] = CFuncPtr.toPtr(v)

  opaque type PFNGLMATRIXLOADTRANSPOSEDEXTPROC = CFuncPtr2[GLenum, Ptr[GLdouble], Unit]
  object PFNGLMATRIXLOADTRANSPOSEDEXTPROC:
    given _tag: Tag[PFNGLMATRIXLOADTRANSPOSEDEXTPROC] = Tag.materializeCFuncPtr2[GLenum, Ptr[GLdouble], Unit]
    inline def fromPtr(ptr: Ptr[Byte] | Ptr[?]): PFNGLMATRIXLOADTRANSPOSEDEXTPROC = CFuncPtr.fromPtr(ptr.asInstanceOf[Ptr[Byte]])
    inline def apply(inline o: CFuncPtr2[GLenum, Ptr[GLdouble], Unit]): PFNGLMATRIXLOADTRANSPOSEDEXTPROC = o
    extension (v: PFNGLMATRIXLOADTRANSPOSEDEXTPROC)
      inline def value: CFuncPtr2[GLenum, Ptr[GLdouble], Unit] = v
      inline def toPtr: Ptr[?] = CFuncPtr.toPtr(v)

  opaque type PFNGLMATRIXLOADTRANSPOSEFEXTPROC = CFuncPtr2[GLenum, Ptr[GLfloat], Unit]
  object PFNGLMATRIXLOADTRANSPOSEFEXTPROC:
    given _tag: Tag[PFNGLMATRIXLOADTRANSPOSEFEXTPROC] = Tag.materializeCFuncPtr2[GLenum, Ptr[GLfloat], Unit]
    inline def fromPtr(ptr: Ptr[Byte] | Ptr[?]): PFNGLMATRIXLOADTRANSPOSEFEXTPROC = CFuncPtr.fromPtr(ptr.asInstanceOf[Ptr[Byte]])
    inline def apply(inline o: CFuncPtr2[GLenum, Ptr[GLfloat], Unit]): PFNGLMATRIXLOADTRANSPOSEFEXTPROC = o
    extension (v: PFNGLMATRIXLOADTRANSPOSEFEXTPROC)
      inline def value: CFuncPtr2[GLenum, Ptr[GLfloat], Unit] = v
      inline def toPtr: Ptr[?] = CFuncPtr.toPtr(v)

  opaque type PFNGLMATRIXMULT3X2FNVPROC = CFuncPtr2[GLenum, Ptr[GLfloat], Unit]
  object PFNGLMATRIXMULT3X2FNVPROC:
    given _tag: Tag[PFNGLMATRIXMULT3X2FNVPROC] = Tag.materializeCFuncPtr2[GLenum, Ptr[GLfloat], Unit]
    inline def fromPtr(ptr: Ptr[Byte] | Ptr[?]): PFNGLMATRIXMULT3X2FNVPROC = CFuncPtr.fromPtr(ptr.asInstanceOf[Ptr[Byte]])
    inline def apply(inline o: CFuncPtr2[GLenum, Ptr[GLfloat], Unit]): PFNGLMATRIXMULT3X2FNVPROC = o
    extension (v: PFNGLMATRIXMULT3X2FNVPROC)
      inline def value: CFuncPtr2[GLenum, Ptr[GLfloat], Unit] = v
      inline def toPtr: Ptr[?] = CFuncPtr.toPtr(v)

  opaque type PFNGLMATRIXMULT3X3FNVPROC = CFuncPtr2[GLenum, Ptr[GLfloat], Unit]
  object PFNGLMATRIXMULT3X3FNVPROC:
    given _tag: Tag[PFNGLMATRIXMULT3X3FNVPROC] = Tag.materializeCFuncPtr2[GLenum, Ptr[GLfloat], Unit]
    inline def fromPtr(ptr: Ptr[Byte] | Ptr[?]): PFNGLMATRIXMULT3X3FNVPROC = CFuncPtr.fromPtr(ptr.asInstanceOf[Ptr[Byte]])
    inline def apply(inline o: CFuncPtr2[GLenum, Ptr[GLfloat], Unit]): PFNGLMATRIXMULT3X3FNVPROC = o
    extension (v: PFNGLMATRIXMULT3X3FNVPROC)
      inline def value: CFuncPtr2[GLenum, Ptr[GLfloat], Unit] = v
      inline def toPtr: Ptr[?] = CFuncPtr.toPtr(v)

  opaque type PFNGLMATRIXMULTDEXTPROC = CFuncPtr2[GLenum, Ptr[GLdouble], Unit]
  object PFNGLMATRIXMULTDEXTPROC:
    given _tag: Tag[PFNGLMATRIXMULTDEXTPROC] = Tag.materializeCFuncPtr2[GLenum, Ptr[GLdouble], Unit]
    inline def fromPtr(ptr: Ptr[Byte] | Ptr[?]): PFNGLMATRIXMULTDEXTPROC = CFuncPtr.fromPtr(ptr.asInstanceOf[Ptr[Byte]])
    inline def apply(inline o: CFuncPtr2[GLenum, Ptr[GLdouble], Unit]): PFNGLMATRIXMULTDEXTPROC = o
    extension (v: PFNGLMATRIXMULTDEXTPROC)
      inline def value: CFuncPtr2[GLenum, Ptr[GLdouble], Unit] = v
      inline def toPtr: Ptr[?] = CFuncPtr.toPtr(v)

  opaque type PFNGLMATRIXMULTFEXTPROC = CFuncPtr2[GLenum, Ptr[GLfloat], Unit]
  object PFNGLMATRIXMULTFEXTPROC:
    given _tag: Tag[PFNGLMATRIXMULTFEXTPROC] = Tag.materializeCFuncPtr2[GLenum, Ptr[GLfloat], Unit]
    inline def fromPtr(ptr: Ptr[Byte] | Ptr[?]): PFNGLMATRIXMULTFEXTPROC = CFuncPtr.fromPtr(ptr.asInstanceOf[Ptr[Byte]])
    inline def apply(inline o: CFuncPtr2[GLenum, Ptr[GLfloat], Unit]): PFNGLMATRIXMULTFEXTPROC = o
    extension (v: PFNGLMATRIXMULTFEXTPROC)
      inline def value: CFuncPtr2[GLenum, Ptr[GLfloat], Unit] = v
      inline def toPtr: Ptr[?] = CFuncPtr.toPtr(v)

  opaque type PFNGLMATRIXMULTTRANSPOSE3X3FNVPROC = CFuncPtr2[GLenum, Ptr[GLfloat], Unit]
  object PFNGLMATRIXMULTTRANSPOSE3X3FNVPROC:
    given _tag: Tag[PFNGLMATRIXMULTTRANSPOSE3X3FNVPROC] = Tag.materializeCFuncPtr2[GLenum, Ptr[GLfloat], Unit]
    inline def fromPtr(ptr: Ptr[Byte] | Ptr[?]): PFNGLMATRIXMULTTRANSPOSE3X3FNVPROC = CFuncPtr.fromPtr(ptr.asInstanceOf[Ptr[Byte]])
    inline def apply(inline o: CFuncPtr2[GLenum, Ptr[GLfloat], Unit]): PFNGLMATRIXMULTTRANSPOSE3X3FNVPROC = o
    extension (v: PFNGLMATRIXMULTTRANSPOSE3X3FNVPROC)
      inline def value: CFuncPtr2[GLenum, Ptr[GLfloat], Unit] = v
      inline def toPtr: Ptr[?] = CFuncPtr.toPtr(v)

  opaque type PFNGLMATRIXMULTTRANSPOSEDEXTPROC = CFuncPtr2[GLenum, Ptr[GLdouble], Unit]
  object PFNGLMATRIXMULTTRANSPOSEDEXTPROC:
    given _tag: Tag[PFNGLMATRIXMULTTRANSPOSEDEXTPROC] = Tag.materializeCFuncPtr2[GLenum, Ptr[GLdouble], Unit]
    inline def fromPtr(ptr: Ptr[Byte] | Ptr[?]): PFNGLMATRIXMULTTRANSPOSEDEXTPROC = CFuncPtr.fromPtr(ptr.asInstanceOf[Ptr[Byte]])
    inline def apply(inline o: CFuncPtr2[GLenum, Ptr[GLdouble], Unit]): PFNGLMATRIXMULTTRANSPOSEDEXTPROC = o
    extension (v: PFNGLMATRIXMULTTRANSPOSEDEXTPROC)
      inline def value: CFuncPtr2[GLenum, Ptr[GLdouble], Unit] = v
      inline def toPtr: Ptr[?] = CFuncPtr.toPtr(v)

  opaque type PFNGLMATRIXMULTTRANSPOSEFEXTPROC = CFuncPtr2[GLenum, Ptr[GLfloat], Unit]
  object PFNGLMATRIXMULTTRANSPOSEFEXTPROC:
    given _tag: Tag[PFNGLMATRIXMULTTRANSPOSEFEXTPROC] = Tag.materializeCFuncPtr2[GLenum, Ptr[GLfloat], Unit]
    inline def fromPtr(ptr: Ptr[Byte] | Ptr[?]): PFNGLMATRIXMULTTRANSPOSEFEXTPROC = CFuncPtr.fromPtr(ptr.asInstanceOf[Ptr[Byte]])
    inline def apply(inline o: CFuncPtr2[GLenum, Ptr[GLfloat], Unit]): PFNGLMATRIXMULTTRANSPOSEFEXTPROC = o
    extension (v: PFNGLMATRIXMULTTRANSPOSEFEXTPROC)
      inline def value: CFuncPtr2[GLenum, Ptr[GLfloat], Unit] = v
      inline def toPtr: Ptr[?] = CFuncPtr.toPtr(v)

  opaque type PFNGLMATRIXORTHOEXTPROC = CFuncPtr7[GLenum, GLdouble, GLdouble, GLdouble, GLdouble, GLdouble, GLdouble, Unit]
  object PFNGLMATRIXORTHOEXTPROC:
    given _tag: Tag[PFNGLMATRIXORTHOEXTPROC] = Tag.materializeCFuncPtr7[GLenum, GLdouble, GLdouble, GLdouble, GLdouble, GLdouble, GLdouble, Unit]
    inline def fromPtr(ptr: Ptr[Byte] | Ptr[?]): PFNGLMATRIXORTHOEXTPROC = CFuncPtr.fromPtr(ptr.asInstanceOf[Ptr[Byte]])
    inline def apply(inline o: CFuncPtr7[GLenum, GLdouble, GLdouble, GLdouble, GLdouble, GLdouble, GLdouble, Unit]): PFNGLMATRIXORTHOEXTPROC = o
    extension (v: PFNGLMATRIXORTHOEXTPROC)
      inline def value: CFuncPtr7[GLenum, GLdouble, GLdouble, GLdouble, GLdouble, GLdouble, GLdouble, Unit] = v
      inline def toPtr: Ptr[?] = CFuncPtr.toPtr(v)

  opaque type PFNGLMATRIXPOPEXTPROC = CFuncPtr1[GLenum, Unit]
  object PFNGLMATRIXPOPEXTPROC:
    given _tag: Tag[PFNGLMATRIXPOPEXTPROC] = Tag.materializeCFuncPtr1[GLenum, Unit]
    inline def fromPtr(ptr: Ptr[Byte] | Ptr[?]): PFNGLMATRIXPOPEXTPROC = CFuncPtr.fromPtr(ptr.asInstanceOf[Ptr[Byte]])
    inline def apply(inline o: CFuncPtr1[GLenum, Unit]): PFNGLMATRIXPOPEXTPROC = o
    extension (v: PFNGLMATRIXPOPEXTPROC)
      inline def value: CFuncPtr1[GLenum, Unit] = v
      inline def toPtr: Ptr[?] = CFuncPtr.toPtr(v)

  opaque type PFNGLMATRIXPUSHEXTPROC = CFuncPtr1[GLenum, Unit]
  object PFNGLMATRIXPUSHEXTPROC:
    given _tag: Tag[PFNGLMATRIXPUSHEXTPROC] = Tag.materializeCFuncPtr1[GLenum, Unit]
    inline def fromPtr(ptr: Ptr[Byte] | Ptr[?]): PFNGLMATRIXPUSHEXTPROC = CFuncPtr.fromPtr(ptr.asInstanceOf[Ptr[Byte]])
    inline def apply(inline o: CFuncPtr1[GLenum, Unit]): PFNGLMATRIXPUSHEXTPROC = o
    extension (v: PFNGLMATRIXPUSHEXTPROC)
      inline def value: CFuncPtr1[GLenum, Unit] = v
      inline def toPtr: Ptr[?] = CFuncPtr.toPtr(v)

  opaque type PFNGLMATRIXROTATEDEXTPROC = CFuncPtr5[GLenum, GLdouble, GLdouble, GLdouble, GLdouble, Unit]
  object PFNGLMATRIXROTATEDEXTPROC:
    given _tag: Tag[PFNGLMATRIXROTATEDEXTPROC] = Tag.materializeCFuncPtr5[GLenum, GLdouble, GLdouble, GLdouble, GLdouble, Unit]
    inline def fromPtr(ptr: Ptr[Byte] | Ptr[?]): PFNGLMATRIXROTATEDEXTPROC = CFuncPtr.fromPtr(ptr.asInstanceOf[Ptr[Byte]])
    inline def apply(inline o: CFuncPtr5[GLenum, GLdouble, GLdouble, GLdouble, GLdouble, Unit]): PFNGLMATRIXROTATEDEXTPROC = o
    extension (v: PFNGLMATRIXROTATEDEXTPROC)
      inline def value: CFuncPtr5[GLenum, GLdouble, GLdouble, GLdouble, GLdouble, Unit] = v
      inline def toPtr: Ptr[?] = CFuncPtr.toPtr(v)

  opaque type PFNGLMATRIXROTATEFEXTPROC = CFuncPtr5[GLenum, GLfloat, GLfloat, GLfloat, GLfloat, Unit]
  object PFNGLMATRIXROTATEFEXTPROC:
    given _tag: Tag[PFNGLMATRIXROTATEFEXTPROC] = Tag.materializeCFuncPtr5[GLenum, GLfloat, GLfloat, GLfloat, GLfloat, Unit]
    inline def fromPtr(ptr: Ptr[Byte] | Ptr[?]): PFNGLMATRIXROTATEFEXTPROC = CFuncPtr.fromPtr(ptr.asInstanceOf[Ptr[Byte]])
    inline def apply(inline o: CFuncPtr5[GLenum, GLfloat, GLfloat, GLfloat, GLfloat, Unit]): PFNGLMATRIXROTATEFEXTPROC = o
    extension (v: PFNGLMATRIXROTATEFEXTPROC)
      inline def value: CFuncPtr5[GLenum, GLfloat, GLfloat, GLfloat, GLfloat, Unit] = v
      inline def toPtr: Ptr[?] = CFuncPtr.toPtr(v)

  opaque type PFNGLMATRIXSCALEDEXTPROC = CFuncPtr4[GLenum, GLdouble, GLdouble, GLdouble, Unit]
  object PFNGLMATRIXSCALEDEXTPROC:
    given _tag: Tag[PFNGLMATRIXSCALEDEXTPROC] = Tag.materializeCFuncPtr4[GLenum, GLdouble, GLdouble, GLdouble, Unit]
    inline def fromPtr(ptr: Ptr[Byte] | Ptr[?]): PFNGLMATRIXSCALEDEXTPROC = CFuncPtr.fromPtr(ptr.asInstanceOf[Ptr[Byte]])
    inline def apply(inline o: CFuncPtr4[GLenum, GLdouble, GLdouble, GLdouble, Unit]): PFNGLMATRIXSCALEDEXTPROC = o
    extension (v: PFNGLMATRIXSCALEDEXTPROC)
      inline def value: CFuncPtr4[GLenum, GLdouble, GLdouble, GLdouble, Unit] = v
      inline def toPtr: Ptr[?] = CFuncPtr.toPtr(v)

  opaque type PFNGLMATRIXSCALEFEXTPROC = CFuncPtr4[GLenum, GLfloat, GLfloat, GLfloat, Unit]
  object PFNGLMATRIXSCALEFEXTPROC:
    given _tag: Tag[PFNGLMATRIXSCALEFEXTPROC] = Tag.materializeCFuncPtr4[GLenum, GLfloat, GLfloat, GLfloat, Unit]
    inline def fromPtr(ptr: Ptr[Byte] | Ptr[?]): PFNGLMATRIXSCALEFEXTPROC = CFuncPtr.fromPtr(ptr.asInstanceOf[Ptr[Byte]])
    inline def apply(inline o: CFuncPtr4[GLenum, GLfloat, GLfloat, GLfloat, Unit]): PFNGLMATRIXSCALEFEXTPROC = o
    extension (v: PFNGLMATRIXSCALEFEXTPROC)
      inline def value: CFuncPtr4[GLenum, GLfloat, GLfloat, GLfloat, Unit] = v
      inline def toPtr: Ptr[?] = CFuncPtr.toPtr(v)

  opaque type PFNGLMATRIXTRANSLATEDEXTPROC = CFuncPtr4[GLenum, GLdouble, GLdouble, GLdouble, Unit]
  object PFNGLMATRIXTRANSLATEDEXTPROC:
    given _tag: Tag[PFNGLMATRIXTRANSLATEDEXTPROC] = Tag.materializeCFuncPtr4[GLenum, GLdouble, GLdouble, GLdouble, Unit]
    inline def fromPtr(ptr: Ptr[Byte] | Ptr[?]): PFNGLMATRIXTRANSLATEDEXTPROC = CFuncPtr.fromPtr(ptr.asInstanceOf[Ptr[Byte]])
    inline def apply(inline o: CFuncPtr4[GLenum, GLdouble, GLdouble, GLdouble, Unit]): PFNGLMATRIXTRANSLATEDEXTPROC = o
    extension (v: PFNGLMATRIXTRANSLATEDEXTPROC)
      inline def value: CFuncPtr4[GLenum, GLdouble, GLdouble, GLdouble, Unit] = v
      inline def toPtr: Ptr[?] = CFuncPtr.toPtr(v)

  opaque type PFNGLMATRIXTRANSLATEFEXTPROC = CFuncPtr4[GLenum, GLfloat, GLfloat, GLfloat, Unit]
  object PFNGLMATRIXTRANSLATEFEXTPROC:
    given _tag: Tag[PFNGLMATRIXTRANSLATEFEXTPROC] = Tag.materializeCFuncPtr4[GLenum, GLfloat, GLfloat, GLfloat, Unit]
    inline def fromPtr(ptr: Ptr[Byte] | Ptr[?]): PFNGLMATRIXTRANSLATEFEXTPROC = CFuncPtr.fromPtr(ptr.asInstanceOf[Ptr[Byte]])
    inline def apply(inline o: CFuncPtr4[GLenum, GLfloat, GLfloat, GLfloat, Unit]): PFNGLMATRIXTRANSLATEFEXTPROC = o
    extension (v: PFNGLMATRIXTRANSLATEFEXTPROC)
      inline def value: CFuncPtr4[GLenum, GLfloat, GLfloat, GLfloat, Unit] = v
      inline def toPtr: Ptr[?] = CFuncPtr.toPtr(v)

  opaque type PFNGLMAXSHADERCOMPILERTHREADSARBPROC = CFuncPtr1[GLuint, Unit]
  object PFNGLMAXSHADERCOMPILERTHREADSARBPROC:
    given _tag: Tag[PFNGLMAXSHADERCOMPILERTHREADSARBPROC] = Tag.materializeCFuncPtr1[GLuint, Unit]
    inline def fromPtr(ptr: Ptr[Byte] | Ptr[?]): PFNGLMAXSHADERCOMPILERTHREADSARBPROC = CFuncPtr.fromPtr(ptr.asInstanceOf[Ptr[Byte]])
    inline def apply(inline o: CFuncPtr1[GLuint, Unit]): PFNGLMAXSHADERCOMPILERTHREADSARBPROC = o
    extension (v: PFNGLMAXSHADERCOMPILERTHREADSARBPROC)
      inline def value: CFuncPtr1[GLuint, Unit] = v
      inline def toPtr: Ptr[?] = CFuncPtr.toPtr(v)

  opaque type PFNGLMAXSHADERCOMPILERTHREADSKHRPROC = CFuncPtr1[GLuint, Unit]
  object PFNGLMAXSHADERCOMPILERTHREADSKHRPROC:
    given _tag: Tag[PFNGLMAXSHADERCOMPILERTHREADSKHRPROC] = Tag.materializeCFuncPtr1[GLuint, Unit]
    inline def fromPtr(ptr: Ptr[Byte] | Ptr[?]): PFNGLMAXSHADERCOMPILERTHREADSKHRPROC = CFuncPtr.fromPtr(ptr.asInstanceOf[Ptr[Byte]])
    inline def apply(inline o: CFuncPtr1[GLuint, Unit]): PFNGLMAXSHADERCOMPILERTHREADSKHRPROC = o
    extension (v: PFNGLMAXSHADERCOMPILERTHREADSKHRPROC)
      inline def value: CFuncPtr1[GLuint, Unit] = v
      inline def toPtr: Ptr[?] = CFuncPtr.toPtr(v)

  opaque type PFNGLMEMORYBARRIERBYREGIONPROC = CFuncPtr1[GLbitfield, Unit]
  object PFNGLMEMORYBARRIERBYREGIONPROC:
    given _tag: Tag[PFNGLMEMORYBARRIERBYREGIONPROC] = Tag.materializeCFuncPtr1[GLbitfield, Unit]
    inline def fromPtr(ptr: Ptr[Byte] | Ptr[?]): PFNGLMEMORYBARRIERBYREGIONPROC = CFuncPtr.fromPtr(ptr.asInstanceOf[Ptr[Byte]])
    inline def apply(inline o: CFuncPtr1[GLbitfield, Unit]): PFNGLMEMORYBARRIERBYREGIONPROC = o
    extension (v: PFNGLMEMORYBARRIERBYREGIONPROC)
      inline def value: CFuncPtr1[GLbitfield, Unit] = v
      inline def toPtr: Ptr[?] = CFuncPtr.toPtr(v)

  opaque type PFNGLMEMORYBARRIEREXTPROC = CFuncPtr1[GLbitfield, Unit]
  object PFNGLMEMORYBARRIEREXTPROC:
    given _tag: Tag[PFNGLMEMORYBARRIEREXTPROC] = Tag.materializeCFuncPtr1[GLbitfield, Unit]
    inline def fromPtr(ptr: Ptr[Byte] | Ptr[?]): PFNGLMEMORYBARRIEREXTPROC = CFuncPtr.fromPtr(ptr.asInstanceOf[Ptr[Byte]])
    inline def apply(inline o: CFuncPtr1[GLbitfield, Unit]): PFNGLMEMORYBARRIEREXTPROC = o
    extension (v: PFNGLMEMORYBARRIEREXTPROC)
      inline def value: CFuncPtr1[GLbitfield, Unit] = v
      inline def toPtr: Ptr[?] = CFuncPtr.toPtr(v)

  opaque type PFNGLMEMORYBARRIERPROC = CFuncPtr1[GLbitfield, Unit]
  object PFNGLMEMORYBARRIERPROC:
    given _tag: Tag[PFNGLMEMORYBARRIERPROC] = Tag.materializeCFuncPtr1[GLbitfield, Unit]
    inline def fromPtr(ptr: Ptr[Byte] | Ptr[?]): PFNGLMEMORYBARRIERPROC = CFuncPtr.fromPtr(ptr.asInstanceOf[Ptr[Byte]])
    inline def apply(inline o: CFuncPtr1[GLbitfield, Unit]): PFNGLMEMORYBARRIERPROC = o
    extension (v: PFNGLMEMORYBARRIERPROC)
      inline def value: CFuncPtr1[GLbitfield, Unit] = v
      inline def toPtr: Ptr[?] = CFuncPtr.toPtr(v)

  opaque type PFNGLMEMORYOBJECTPARAMETERIVEXTPROC = CFuncPtr3[GLuint, GLenum, Ptr[GLint], Unit]
  object PFNGLMEMORYOBJECTPARAMETERIVEXTPROC:
    given _tag: Tag[PFNGLMEMORYOBJECTPARAMETERIVEXTPROC] = Tag.materializeCFuncPtr3[GLuint, GLenum, Ptr[GLint], Unit]
    inline def fromPtr(ptr: Ptr[Byte] | Ptr[?]): PFNGLMEMORYOBJECTPARAMETERIVEXTPROC = CFuncPtr.fromPtr(ptr.asInstanceOf[Ptr[Byte]])
    inline def apply(inline o: CFuncPtr3[GLuint, GLenum, Ptr[GLint], Unit]): PFNGLMEMORYOBJECTPARAMETERIVEXTPROC = o
    extension (v: PFNGLMEMORYOBJECTPARAMETERIVEXTPROC)
      inline def value: CFuncPtr3[GLuint, GLenum, Ptr[GLint], Unit] = v
      inline def toPtr: Ptr[?] = CFuncPtr.toPtr(v)

  opaque type PFNGLMESHBREADTHSGIXPROC = CFuncPtr1[GLint, Unit]
  object PFNGLMESHBREADTHSGIXPROC:
    given _tag: Tag[PFNGLMESHBREADTHSGIXPROC] = Tag.materializeCFuncPtr1[GLint, Unit]
    inline def fromPtr(ptr: Ptr[Byte] | Ptr[?]): PFNGLMESHBREADTHSGIXPROC = CFuncPtr.fromPtr(ptr.asInstanceOf[Ptr[Byte]])
    inline def apply(inline o: CFuncPtr1[GLint, Unit]): PFNGLMESHBREADTHSGIXPROC = o
    extension (v: PFNGLMESHBREADTHSGIXPROC)
      inline def value: CFuncPtr1[GLint, Unit] = v
      inline def toPtr: Ptr[?] = CFuncPtr.toPtr(v)

  opaque type PFNGLMESHSTRIDESGIXPROC = CFuncPtr1[GLint, Unit]
  object PFNGLMESHSTRIDESGIXPROC:
    given _tag: Tag[PFNGLMESHSTRIDESGIXPROC] = Tag.materializeCFuncPtr1[GLint, Unit]
    inline def fromPtr(ptr: Ptr[Byte] | Ptr[?]): PFNGLMESHSTRIDESGIXPROC = CFuncPtr.fromPtr(ptr.asInstanceOf[Ptr[Byte]])
    inline def apply(inline o: CFuncPtr1[GLint, Unit]): PFNGLMESHSTRIDESGIXPROC = o
    extension (v: PFNGLMESHSTRIDESGIXPROC)
      inline def value: CFuncPtr1[GLint, Unit] = v
      inline def toPtr: Ptr[?] = CFuncPtr.toPtr(v)

  opaque type PFNGLMINMAXEXTPROC = CFuncPtr3[GLenum, GLenum, GLboolean, Unit]
  object PFNGLMINMAXEXTPROC:
    given _tag: Tag[PFNGLMINMAXEXTPROC] = Tag.materializeCFuncPtr3[GLenum, GLenum, GLboolean, Unit]
    inline def fromPtr(ptr: Ptr[Byte] | Ptr[?]): PFNGLMINMAXEXTPROC = CFuncPtr.fromPtr(ptr.asInstanceOf[Ptr[Byte]])
    inline def apply(inline o: CFuncPtr3[GLenum, GLenum, GLboolean, Unit]): PFNGLMINMAXEXTPROC = o
    extension (v: PFNGLMINMAXEXTPROC)
      inline def value: CFuncPtr3[GLenum, GLenum, GLboolean, Unit] = v
      inline def toPtr: Ptr[?] = CFuncPtr.toPtr(v)

  opaque type PFNGLMINMAXPROC = CFuncPtr3[GLenum, GLenum, GLboolean, Unit]
  object PFNGLMINMAXPROC:
    given _tag: Tag[PFNGLMINMAXPROC] = Tag.materializeCFuncPtr3[GLenum, GLenum, GLboolean, Unit]
    inline def fromPtr(ptr: Ptr[Byte] | Ptr[?]): PFNGLMINMAXPROC = CFuncPtr.fromPtr(ptr.asInstanceOf[Ptr[Byte]])
    inline def apply(inline o: CFuncPtr3[GLenum, GLenum, GLboolean, Unit]): PFNGLMINMAXPROC = o
    extension (v: PFNGLMINMAXPROC)
      inline def value: CFuncPtr3[GLenum, GLenum, GLboolean, Unit] = v
      inline def toPtr: Ptr[?] = CFuncPtr.toPtr(v)

  opaque type PFNGLMINSAMPLESHADINGARBPROC = CFuncPtr1[GLclampf, Unit]
  object PFNGLMINSAMPLESHADINGARBPROC:
    given _tag: Tag[PFNGLMINSAMPLESHADINGARBPROC] = Tag.materializeCFuncPtr1[GLclampf, Unit]
    inline def fromPtr(ptr: Ptr[Byte] | Ptr[?]): PFNGLMINSAMPLESHADINGARBPROC = CFuncPtr.fromPtr(ptr.asInstanceOf[Ptr[Byte]])
    inline def apply(inline o: CFuncPtr1[GLclampf, Unit]): PFNGLMINSAMPLESHADINGARBPROC = o
    extension (v: PFNGLMINSAMPLESHADINGARBPROC)
      inline def value: CFuncPtr1[GLclampf, Unit] = v
      inline def toPtr: Ptr[?] = CFuncPtr.toPtr(v)

  opaque type PFNGLMINSAMPLESHADINGOESPROC = CFuncPtr1[GLfloat, Unit]
  object PFNGLMINSAMPLESHADINGOESPROC:
    given _tag: Tag[PFNGLMINSAMPLESHADINGOESPROC] = Tag.materializeCFuncPtr1[GLfloat, Unit]
    inline def fromPtr(ptr: Ptr[Byte] | Ptr[?]): PFNGLMINSAMPLESHADINGOESPROC = CFuncPtr.fromPtr(ptr.asInstanceOf[Ptr[Byte]])
    inline def apply(inline o: CFuncPtr1[GLfloat, Unit]): PFNGLMINSAMPLESHADINGOESPROC = o
    extension (v: PFNGLMINSAMPLESHADINGOESPROC)
      inline def value: CFuncPtr1[GLfloat, Unit] = v
      inline def toPtr: Ptr[?] = CFuncPtr.toPtr(v)

  opaque type PFNGLMINSAMPLESHADINGPROC = CFuncPtr1[GLclampf, Unit]
  object PFNGLMINSAMPLESHADINGPROC:
    given _tag: Tag[PFNGLMINSAMPLESHADINGPROC] = Tag.materializeCFuncPtr1[GLclampf, Unit]
    inline def fromPtr(ptr: Ptr[Byte] | Ptr[?]): PFNGLMINSAMPLESHADINGPROC = CFuncPtr.fromPtr(ptr.asInstanceOf[Ptr[Byte]])
    inline def apply(inline o: CFuncPtr1[GLclampf, Unit]): PFNGLMINSAMPLESHADINGPROC = o
    extension (v: PFNGLMINSAMPLESHADINGPROC)
      inline def value: CFuncPtr1[GLclampf, Unit] = v
      inline def toPtr: Ptr[?] = CFuncPtr.toPtr(v)

  opaque type PFNGLMPEGPREDICTORSGIXPROC = CFuncPtr4[GLenum, GLenum, GLenum, Ptr[Byte], Unit]
  object PFNGLMPEGPREDICTORSGIXPROC:
    given _tag: Tag[PFNGLMPEGPREDICTORSGIXPROC] = Tag.materializeCFuncPtr4[GLenum, GLenum, GLenum, Ptr[Byte], Unit]
    inline def fromPtr(ptr: Ptr[Byte] | Ptr[?]): PFNGLMPEGPREDICTORSGIXPROC = CFuncPtr.fromPtr(ptr.asInstanceOf[Ptr[Byte]])
    inline def apply(inline o: CFuncPtr4[GLenum, GLenum, GLenum, Ptr[Byte], Unit]): PFNGLMPEGPREDICTORSGIXPROC = o
    extension (v: PFNGLMPEGPREDICTORSGIXPROC)
      inline def value: CFuncPtr4[GLenum, GLenum, GLenum, Ptr[Byte], Unit] = v
      inline def toPtr: Ptr[?] = CFuncPtr.toPtr(v)

  opaque type PFNGLMPEGQUANTTABLEUBVPROC = CFuncPtr2[GLenum, Ptr[GLubyte], Unit]
  object PFNGLMPEGQUANTTABLEUBVPROC:
    given _tag: Tag[PFNGLMPEGQUANTTABLEUBVPROC] = Tag.materializeCFuncPtr2[GLenum, Ptr[GLubyte], Unit]
    inline def fromPtr(ptr: Ptr[Byte] | Ptr[?]): PFNGLMPEGQUANTTABLEUBVPROC = CFuncPtr.fromPtr(ptr.asInstanceOf[Ptr[Byte]])
    inline def apply(inline o: CFuncPtr2[GLenum, Ptr[GLubyte], Unit]): PFNGLMPEGQUANTTABLEUBVPROC = o
    extension (v: PFNGLMPEGQUANTTABLEUBVPROC)
      inline def value: CFuncPtr2[GLenum, Ptr[GLubyte], Unit] = v
      inline def toPtr: Ptr[?] = CFuncPtr.toPtr(v)

  opaque type PFNGLMULTICASTBARRIERNVPROC = CFuncPtr0[Unit]
  object PFNGLMULTICASTBARRIERNVPROC:
    given _tag: Tag[PFNGLMULTICASTBARRIERNVPROC] = Tag.materializeCFuncPtr0[Unit]
    inline def fromPtr(ptr: Ptr[Byte] | Ptr[?]): PFNGLMULTICASTBARRIERNVPROC = CFuncPtr.fromPtr(ptr.asInstanceOf[Ptr[Byte]])
    inline def apply(inline o: CFuncPtr0[Unit]): PFNGLMULTICASTBARRIERNVPROC = o
    extension (v: PFNGLMULTICASTBARRIERNVPROC)
      inline def value: CFuncPtr0[Unit] = v
      inline def toPtr: Ptr[?] = CFuncPtr.toPtr(v)

  opaque type PFNGLMULTICASTBLITFRAMEBUFFERNVPROC = CFuncPtr12[GLuint, GLuint, GLint, GLint, GLint, GLint, GLint, GLint, GLint, GLint, GLbitfield, GLenum, Unit]
  object PFNGLMULTICASTBLITFRAMEBUFFERNVPROC:
    given _tag: Tag[PFNGLMULTICASTBLITFRAMEBUFFERNVPROC] = Tag.materializeCFuncPtr12[GLuint, GLuint, GLint, GLint, GLint, GLint, GLint, GLint, GLint, GLint, GLbitfield, GLenum, Unit]
    inline def fromPtr(ptr: Ptr[Byte] | Ptr[?]): PFNGLMULTICASTBLITFRAMEBUFFERNVPROC = CFuncPtr.fromPtr(ptr.asInstanceOf[Ptr[Byte]])
    inline def apply(inline o: CFuncPtr12[GLuint, GLuint, GLint, GLint, GLint, GLint, GLint, GLint, GLint, GLint, GLbitfield, GLenum, Unit]): PFNGLMULTICASTBLITFRAMEBUFFERNVPROC = o
    extension (v: PFNGLMULTICASTBLITFRAMEBUFFERNVPROC)
      inline def value: CFuncPtr12[GLuint, GLuint, GLint, GLint, GLint, GLint, GLint, GLint, GLint, GLint, GLbitfield, GLenum, Unit] = v
      inline def toPtr: Ptr[?] = CFuncPtr.toPtr(v)

  opaque type PFNGLMULTICASTBUFFERSUBDATANVPROC = CFuncPtr5[GLbitfield, GLuint, GLintptr, GLsizeiptr, Ptr[Byte], Unit]
  object PFNGLMULTICASTBUFFERSUBDATANVPROC:
    given _tag: Tag[PFNGLMULTICASTBUFFERSUBDATANVPROC] = Tag.materializeCFuncPtr5[GLbitfield, GLuint, GLintptr, GLsizeiptr, Ptr[Byte], Unit]
    inline def fromPtr(ptr: Ptr[Byte] | Ptr[?]): PFNGLMULTICASTBUFFERSUBDATANVPROC = CFuncPtr.fromPtr(ptr.asInstanceOf[Ptr[Byte]])
    inline def apply(inline o: CFuncPtr5[GLbitfield, GLuint, GLintptr, GLsizeiptr, Ptr[Byte], Unit]): PFNGLMULTICASTBUFFERSUBDATANVPROC = o
    extension (v: PFNGLMULTICASTBUFFERSUBDATANVPROC)
      inline def value: CFuncPtr5[GLbitfield, GLuint, GLintptr, GLsizeiptr, Ptr[Byte], Unit] = v
      inline def toPtr: Ptr[?] = CFuncPtr.toPtr(v)

  opaque type PFNGLMULTICASTCOPYBUFFERSUBDATANVPROC = CFuncPtr7[GLuint, GLbitfield, GLuint, GLuint, GLintptr, GLintptr, GLsizeiptr, Unit]
  object PFNGLMULTICASTCOPYBUFFERSUBDATANVPROC:
    given _tag: Tag[PFNGLMULTICASTCOPYBUFFERSUBDATANVPROC] = Tag.materializeCFuncPtr7[GLuint, GLbitfield, GLuint, GLuint, GLintptr, GLintptr, GLsizeiptr, Unit]
    inline def fromPtr(ptr: Ptr[Byte] | Ptr[?]): PFNGLMULTICASTCOPYBUFFERSUBDATANVPROC = CFuncPtr.fromPtr(ptr.asInstanceOf[Ptr[Byte]])
    inline def apply(inline o: CFuncPtr7[GLuint, GLbitfield, GLuint, GLuint, GLintptr, GLintptr, GLsizeiptr, Unit]): PFNGLMULTICASTCOPYBUFFERSUBDATANVPROC = o
    extension (v: PFNGLMULTICASTCOPYBUFFERSUBDATANVPROC)
      inline def value: CFuncPtr7[GLuint, GLbitfield, GLuint, GLuint, GLintptr, GLintptr, GLsizeiptr, Unit] = v
      inline def toPtr: Ptr[?] = CFuncPtr.toPtr(v)

  opaque type PFNGLMULTICASTCOPYIMAGESUBDATANVPROC = CFuncPtr17[GLuint, GLbitfield, GLuint, GLenum, GLint, GLint, GLint, GLint, GLuint, GLenum, GLint, GLint, GLint, GLint, GLsizei, GLsizei, GLsizei, Unit]
  object PFNGLMULTICASTCOPYIMAGESUBDATANVPROC:
    given _tag: Tag[PFNGLMULTICASTCOPYIMAGESUBDATANVPROC] = Tag.materializeCFuncPtr17[GLuint, GLbitfield, GLuint, GLenum, GLint, GLint, GLint, GLint, GLuint, GLenum, GLint, GLint, GLint, GLint, GLsizei, GLsizei, GLsizei, Unit]
    inline def fromPtr(ptr: Ptr[Byte] | Ptr[?]): PFNGLMULTICASTCOPYIMAGESUBDATANVPROC = CFuncPtr.fromPtr(ptr.asInstanceOf[Ptr[Byte]])
    inline def apply(inline o: CFuncPtr17[GLuint, GLbitfield, GLuint, GLenum, GLint, GLint, GLint, GLint, GLuint, GLenum, GLint, GLint, GLint, GLint, GLsizei, GLsizei, GLsizei, Unit]): PFNGLMULTICASTCOPYIMAGESUBDATANVPROC = o
    extension (v: PFNGLMULTICASTCOPYIMAGESUBDATANVPROC)
      inline def value: CFuncPtr17[GLuint, GLbitfield, GLuint, GLenum, GLint, GLint, GLint, GLint, GLuint, GLenum, GLint, GLint, GLint, GLint, GLsizei, GLsizei, GLsizei, Unit] = v
      inline def toPtr: Ptr[?] = CFuncPtr.toPtr(v)

  opaque type PFNGLMULTICASTFRAMEBUFFERSAMPLELOCATIONSFVNVPROC = CFuncPtr5[GLuint, GLuint, GLuint, GLsizei, Ptr[GLfloat], Unit]
  object PFNGLMULTICASTFRAMEBUFFERSAMPLELOCATIONSFVNVPROC:
    given _tag: Tag[PFNGLMULTICASTFRAMEBUFFERSAMPLELOCATIONSFVNVPROC] = Tag.materializeCFuncPtr5[GLuint, GLuint, GLuint, GLsizei, Ptr[GLfloat], Unit]
    inline def fromPtr(ptr: Ptr[Byte] | Ptr[?]): PFNGLMULTICASTFRAMEBUFFERSAMPLELOCATIONSFVNVPROC = CFuncPtr.fromPtr(ptr.asInstanceOf[Ptr[Byte]])
    inline def apply(inline o: CFuncPtr5[GLuint, GLuint, GLuint, GLsizei, Ptr[GLfloat], Unit]): PFNGLMULTICASTFRAMEBUFFERSAMPLELOCATIONSFVNVPROC = o
    extension (v: PFNGLMULTICASTFRAMEBUFFERSAMPLELOCATIONSFVNVPROC)
      inline def value: CFuncPtr5[GLuint, GLuint, GLuint, GLsizei, Ptr[GLfloat], Unit] = v
      inline def toPtr: Ptr[?] = CFuncPtr.toPtr(v)

  opaque type PFNGLMULTICASTGETQUERYOBJECTI64VNVPROC = CFuncPtr4[GLuint, GLuint, GLenum, Ptr[GLint64], Unit]
  object PFNGLMULTICASTGETQUERYOBJECTI64VNVPROC:
    given _tag: Tag[PFNGLMULTICASTGETQUERYOBJECTI64VNVPROC] = Tag.materializeCFuncPtr4[GLuint, GLuint, GLenum, Ptr[GLint64], Unit]
    inline def fromPtr(ptr: Ptr[Byte] | Ptr[?]): PFNGLMULTICASTGETQUERYOBJECTI64VNVPROC = CFuncPtr.fromPtr(ptr.asInstanceOf[Ptr[Byte]])
    inline def apply(inline o: CFuncPtr4[GLuint, GLuint, GLenum, Ptr[GLint64], Unit]): PFNGLMULTICASTGETQUERYOBJECTI64VNVPROC = o
    extension (v: PFNGLMULTICASTGETQUERYOBJECTI64VNVPROC)
      inline def value: CFuncPtr4[GLuint, GLuint, GLenum, Ptr[GLint64], Unit] = v
      inline def toPtr: Ptr[?] = CFuncPtr.toPtr(v)

  opaque type PFNGLMULTICASTGETQUERYOBJECTIVNVPROC = CFuncPtr4[GLuint, GLuint, GLenum, Ptr[GLint], Unit]
  object PFNGLMULTICASTGETQUERYOBJECTIVNVPROC:
    given _tag: Tag[PFNGLMULTICASTGETQUERYOBJECTIVNVPROC] = Tag.materializeCFuncPtr4[GLuint, GLuint, GLenum, Ptr[GLint], Unit]
    inline def fromPtr(ptr: Ptr[Byte] | Ptr[?]): PFNGLMULTICASTGETQUERYOBJECTIVNVPROC = CFuncPtr.fromPtr(ptr.asInstanceOf[Ptr[Byte]])
    inline def apply(inline o: CFuncPtr4[GLuint, GLuint, GLenum, Ptr[GLint], Unit]): PFNGLMULTICASTGETQUERYOBJECTIVNVPROC = o
    extension (v: PFNGLMULTICASTGETQUERYOBJECTIVNVPROC)
      inline def value: CFuncPtr4[GLuint, GLuint, GLenum, Ptr[GLint], Unit] = v
      inline def toPtr: Ptr[?] = CFuncPtr.toPtr(v)

  opaque type PFNGLMULTICASTGETQUERYOBJECTUI64VNVPROC = CFuncPtr4[GLuint, GLuint, GLenum, Ptr[GLuint64], Unit]
  object PFNGLMULTICASTGETQUERYOBJECTUI64VNVPROC:
    given _tag: Tag[PFNGLMULTICASTGETQUERYOBJECTUI64VNVPROC] = Tag.materializeCFuncPtr4[GLuint, GLuint, GLenum, Ptr[GLuint64], Unit]
    inline def fromPtr(ptr: Ptr[Byte] | Ptr[?]): PFNGLMULTICASTGETQUERYOBJECTUI64VNVPROC = CFuncPtr.fromPtr(ptr.asInstanceOf[Ptr[Byte]])
    inline def apply(inline o: CFuncPtr4[GLuint, GLuint, GLenum, Ptr[GLuint64], Unit]): PFNGLMULTICASTGETQUERYOBJECTUI64VNVPROC = o
    extension (v: PFNGLMULTICASTGETQUERYOBJECTUI64VNVPROC)
      inline def value: CFuncPtr4[GLuint, GLuint, GLenum, Ptr[GLuint64], Unit] = v
      inline def toPtr: Ptr[?] = CFuncPtr.toPtr(v)

  opaque type PFNGLMULTICASTGETQUERYOBJECTUIVNVPROC = CFuncPtr4[GLuint, GLuint, GLenum, Ptr[GLuint], Unit]
  object PFNGLMULTICASTGETQUERYOBJECTUIVNVPROC:
    given _tag: Tag[PFNGLMULTICASTGETQUERYOBJECTUIVNVPROC] = Tag.materializeCFuncPtr4[GLuint, GLuint, GLenum, Ptr[GLuint], Unit]