From 6a101e69a26c09d6a0c8c5ebd6ed27a8ab89d5ee Mon Sep 17 00:00:00 2001
From: gingerBill <bill@gingerbill.org>
Date: Tue, 16 Nov 2021 14:04:49 +0000
Subject: [PATCH 01/38] Implement `ldexp` and `frexp` in native Odin

---
 core/math/big/rat.odin    |   2 +-
 core/math/math.odin       | 174 +++++++++++++++++++++++++++++++-------
 core/math/math_basic.odin |   7 --
 core/math/math_js.odin    |   6 +-
 4 files changed, 144 insertions(+), 45 deletions(-)

diff --git a/core/math/big/rat.odin b/core/math/big/rat.odin
index 8acd8c2c6..121f0ab50 100644
--- a/core/math/big/rat.odin
+++ b/core/math/big/rat.odin
@@ -436,7 +436,7 @@ internal_rat_to_float :: proc($T: typeid, z: ^Rat, allocator := context.allocato
 	
 	mantissa >>= 1
 	
-	f = T(math.ldexp(f64(mantissa), i32(exp-MSIZE1)))
+	f = T(math.ldexp(f64(mantissa), exp-MSIZE1))
 	if math.is_inf(f, 0) {
 		exact = false
 	}
diff --git a/core/math/math.odin b/core/math/math.odin
index 512577906..f966ed11f 100644
--- a/core/math/math.odin
+++ b/core/math/math.odin
@@ -120,13 +120,60 @@ exp       :: proc{
 	exp_f64, exp_f64le, exp_f64be,
 }
 
-ldexp_f16le :: proc "contextless" (val: f16le, exp: i32) -> f16le { return #force_inline f16le(ldexp_f16(f16(val), exp)) }
-ldexp_f16be :: proc "contextless" (val: f16be, exp: i32) -> f16be { return #force_inline f16be(ldexp_f16(f16(val), exp)) }
-ldexp_f32le :: proc "contextless" (val: f32le, exp: i32) -> f32le { return #force_inline f32le(ldexp_f32(f32(val), exp)) }
-ldexp_f32be :: proc "contextless" (val: f32be, exp: i32) -> f32be { return #force_inline f32be(ldexp_f32(f32(val), exp)) }
-ldexp_f64le :: proc "contextless" (val: f64le, exp: i32) -> f64le { return #force_inline f64le(ldexp_f64(f64(val), exp)) }
-ldexp_f64be :: proc "contextless" (val: f64be, exp: i32) -> f64be { return #force_inline f64be(ldexp_f64(f64(val), exp)) }
-ldexp       :: proc{
+
+
+ldexp_f64 :: proc "contextless" (val: f64, exp: int) -> f64 {
+	mask  :: F64_MASK
+	shift :: F64_SHIFT
+	bias  :: F64_BIAS
+	
+	switch {
+	case val == 0:
+		return val
+	case is_inf(val) || is_nan(val):
+		return val
+	}
+	exp := exp
+	frac, e := normalize_f64(val)
+	exp += e
+	x := transmute(u64)frac
+	exp += int(x>>shift)&mask - bias
+	if exp < -1075 { // underflow
+		return copy_sign(0, frac) 
+	} else if exp > 1023 { // overflow
+		if frac < 0 {
+			return inf_f64(-1)
+		}
+		return inf_f64(+1)
+	}
+	
+	m: f64 = 1
+	if exp < -1022 { // denormal
+		exp += 53
+		m = 1.0 / (1<<53)
+	}
+	x &~= mask << shift
+	x |= u64(exp+bias) << shift
+	return m * transmute(f64)x	
+}
+ldexp_f16   :: proc "contextless" (val: f16, exp: int) -> f16 { return f16(ldexp_f64(f64(val), exp)) }
+ldexp_f32   :: proc "contextless" (val: f32, exp: int) -> f32 { return f32(ldexp_f64(f64(val), exp)) }
+ldexp_f16le :: proc "contextless" (val: f16le, exp: int) -> f16le { return #force_inline f16le(ldexp_f16(f16(val), exp)) }
+ldexp_f16be :: proc "contextless" (val: f16be, exp: int) -> f16be { return #force_inline f16be(ldexp_f16(f16(val), exp)) }
+ldexp_f32le :: proc "contextless" (val: f32le, exp: int) -> f32le { return #force_inline f32le(ldexp_f32(f32(val), exp)) }
+ldexp_f32be :: proc "contextless" (val: f32be, exp: int) -> f32be { return #force_inline f32be(ldexp_f32(f32(val), exp)) }
+ldexp_f64le :: proc "contextless" (val: f64le, exp: int) -> f64le { return #force_inline f64le(ldexp_f64(f64(val), exp)) }
+ldexp_f64be :: proc "contextless" (val: f64be, exp: int) -> f64be { return #force_inline f64be(ldexp_f64(f64(val), exp)) }
+// ldexp is the inverse of frexp
+// it returns val * 2**exp.
+// 
+// Special cases:
+// 	ldexp(+0,   exp) = +0
+// 	ldexp(-0,   exp) = -0
+// 	ldexp(+inf, exp) = +inf
+// 	ldexp(-inf, exp) = -inf
+// 	ldexp(NaN,  exp) = NaN
+ldexp :: proc{
 	ldexp_f16, ldexp_f16le, ldexp_f16be,
 	ldexp_f32, ldexp_f32le, ldexp_f32be,
 	ldexp_f64, ldexp_f64le, ldexp_f64be,
@@ -351,9 +398,9 @@ to_degrees       :: proc{
 
 trunc_f16   :: proc "contextless" (x: f16) -> f16 {
 	trunc_internal :: proc "contextless" (f: f16) -> f16 {
-		mask :: 0x1f
-		shift :: 16 - 6
-		bias :: 0xf
+		mask  :: F16_MASK
+		shift :: F16_SHIFT
+		bias  :: F16_BIAS
 
 		if f < 1 {
 			switch {
@@ -383,9 +430,9 @@ trunc_f16be :: proc "contextless" (x: f16be) -> f16be { return #force_inline f16
 
 trunc_f32   :: proc "contextless" (x: f32) -> f32 {
 	trunc_internal :: proc "contextless" (f: f32) -> f32 {
-		mask :: 0xff
-		shift :: 32 - 9
-		bias :: 0x7f
+		mask  :: F32_MASK
+		shift :: F32_SHIFT
+		bias  :: F32_BIAS
 
 		if f < 1 {
 			switch {
@@ -415,9 +462,9 @@ trunc_f32be :: proc "contextless" (x: f32be) -> f32be { return #force_inline f32
 
 trunc_f64   :: proc "contextless" (x: f64) -> f64 {
 	trunc_internal :: proc "contextless" (f: f64) -> f64 {
-		mask :: 0x7ff
-		shift :: 64 - 12
-		bias :: 0x3ff
+		mask  :: F64_MASK
+		shift :: F64_SHIFT
+		bias  :: F64_BIAS
 
 		if f < 1 {
 			switch {
@@ -752,6 +799,44 @@ lcm :: proc "contextless" (x, y: $T) -> T
 	return x / gcd(x, y) * y
 }
 
+normalize_f16 :: proc "contextless" (x: f16) -> (y: f16, exponent: int) {
+	if abs(x) < F16_MIN {
+		return x * (1<<F16_SHIFT), -F16_SHIFT
+	}
+	return x, 0
+}
+normalize_f32 :: proc "contextless" (x: f32) -> (y: f32, exponent: int) {
+	if abs(x) < F32_MIN {
+		return x * (1<<F32_SHIFT), -F32_SHIFT
+	}
+	return x, 0
+}
+normalize_f64 :: proc "contextless" (x: f64) -> (y: f64, exponent: int) {
+	if abs(x) < F64_MIN {
+		return x * (1<<F64_SHIFT), -F64_SHIFT
+	}
+	return x, 0
+}
+
+normalize_f16le :: proc "contextless" (x: f16le) -> (y: f16le, exponent: int) { y0, e := normalize_f16(f16(x)); return f16le(y0), e }
+normalize_f16be :: proc "contextless" (x: f16be) -> (y: f16be, exponent: int) { y0, e := normalize_f16(f16(x)); return f16be(y0), e }
+normalize_f32le :: proc "contextless" (x: f32le) -> (y: f32le, exponent: int) { y0, e := normalize_f32(f32(x)); return f32le(y0), e }
+normalize_f32be :: proc "contextless" (x: f32be) -> (y: f32be, exponent: int) { y0, e := normalize_f32(f32(x)); return f32be(y0), e }
+normalize_f64le :: proc "contextless" (x: f64le) -> (y: f64le, exponent: int) { y0, e := normalize_f64(f64(x)); return f64le(y0), e }
+normalize_f64be :: proc "contextless" (x: f64be) -> (y: f64be, exponent: int) { y0, e := normalize_f64(f64(x)); return f64be(y0), e }
+
+normalize :: proc{
+	normalize_f16,
+	normalize_f32,
+	normalize_f64,
+	normalize_f16le,
+	normalize_f16be,
+	normalize_f32le,
+	normalize_f32be,
+	normalize_f64le,
+	normalize_f64be,
+}
+
 frexp_f16   :: proc "contextless" (x: f16)   -> (significand: f16,   exponent: int) {
 	f, e := frexp_f64(f64(x))
 	return f16(f), e
@@ -776,24 +861,25 @@ frexp_f32be :: proc "contextless" (x: f32be) -> (significand: f32be, exponent: i
 	f, e := frexp_f64(f64(x))
 	return f32be(f), e
 }
-frexp_f64 :: proc "contextless" (x: f64) -> (significand: f64, exponent: int) {
+frexp_f64 :: proc "contextless" (f: f64) -> (significand: f64, exponent: int) {
+	mask  :: F64_MASK
+	shift :: F64_SHIFT
+	bias  :: F64_BIAS
+	
 	switch {
-	case x == 0:
+	case f == 0:
 		return 0, 0
-	case x < 0:
-		significand, exponent = frexp(-x)
-		return -significand, exponent
-	}
-	ex := trunc(log2(x))
-	exponent = int(ex)
-	significand = x / pow(2.0, ex)
-	if abs(significand) >= 1 {
-		exponent += 1
-		significand /= 2
-	}
-	if exponent == 1024 && significand == 0 {
-		significand = 0.99999999999999988898
+	case is_inf(f) || is_nan(f):
+		return f, 0
 	}
+	f := f
+	
+	f, exponent = normalize_f64(f)
+	x := transmute(u64)f
+	exponent += int((x>>shift)&mask) - bias + 1
+	x &~= mask << shift
+	x |= (-1 + bias) << shift
+	significand = transmute(f64)x
 	return
 }
 frexp_f64le :: proc "contextless" (x: f64le) -> (significand: f64le, exponent: int) {
@@ -804,7 +890,18 @@ frexp_f64be :: proc "contextless" (x: f64be) -> (significand: f64be, exponent: i
 	f, e := frexp_f64(f64(x))
 	return f64be(f), e
 }
-frexp       :: proc{
+
+// frexp breaks the value into a normalized fraction, and an integral power of two
+// It returns a significand and exponent satisfying x == significand * 2**exponent
+// with the absolute value of significand in the intervalue of [0.5, 1).
+//
+// Special cases: 
+// 	frexp(+0)   = +0,   0
+// 	frexp(-0)   = -0,   0
+// 	frexp(+inf) = +inf, 0
+// 	frexp(-inf) = -inf, 0
+// 	frexp(NaN)  = NaN,  0
+frexp :: proc{
 	frexp_f16, frexp_f16le, frexp_f16be,
 	frexp_f32, frexp_f32le, frexp_f32be,
 	frexp_f64, frexp_f64le, frexp_f64be, 
@@ -1349,3 +1446,16 @@ F64_MIN_10_EXP :: -307                     // min decimal exponent
 F64_MIN_EXP    :: -1021                    // min binary exponent
 F64_RADIX      :: 2                        // exponent radix
 F64_ROUNDS     :: 1                        // addition rounding: near
+
+
+F16_MASK  :: 0x1f
+F16_SHIFT :: 16 - 6
+F16_BIAS  :: 0xf
+
+F32_MASK  :: 0xff
+F32_SHIFT :: 32 - 9
+F32_BIAS  :: 0x7f
+
+F64_MASK  :: 0x7ff
+F64_SHIFT :: 64 - 12
+F64_BIAS  :: 0x3ff
\ No newline at end of file
diff --git a/core/math/math_basic.odin b/core/math/math_basic.odin
index 26bf4691d..4995ac9e3 100644
--- a/core/math/math_basic.odin
+++ b/core/math/math_basic.odin
@@ -51,11 +51,4 @@ foreign _ {
 	exp_f32 :: proc(x: f32) -> f32 ---
 	@(link_name="llvm.exp.f64")
 	exp_f64 :: proc(x: f64) -> f64 ---
-
-	@(link_name="llvm.ldexp.f16")
-	ldexp_f16 :: proc(val: f16, exp: i32) -> f16 ---
-	@(link_name="llvm.ldexp.f32")
-	ldexp_f32 :: proc(val: f32, exp: i32) -> f32 ---
-	@(link_name="llvm.ldexp.f64")
-	ldexp_f64 :: proc(val: f64, exp: i32) -> f64 ---
 }
diff --git a/core/math/math_js.odin b/core/math/math_js.odin
index c2ac1bedf..4d91b440c 100644
--- a/core/math/math_js.odin
+++ b/core/math/math_js.odin
@@ -19,8 +19,6 @@ foreign odin_env {
 	ln_f64 :: proc(x: f64) -> f64 ---
 	@(link_name="exp")
 	exp_f64 :: proc(x: f64) -> f64 ---
-	@(link_name="ldexp")
-	ldexp_f64 :: proc(val: f64, exp: i32) -> f64 ---
 }
 
 
@@ -31,7 +29,6 @@ pow_f16     :: proc "c" (x, power: f16) -> f16      { return f16(pow_f64(f64(x),
 fmuladd_f16 :: proc "c" (a, b, c: f16) -> f16       { return f16(fmuladd_f64(f64(a), f64(a), f64(c))) }
 ln_f16      :: proc "c" (x: f16) -> f16             { return f16(ln_f64(f64(x)))                      }
 exp_f16     :: proc "c" (x: f16) -> f16             { return f16(exp_f64(f64(x)))                     }
-ldexp_f16   :: proc "c" (val: f16, exp: i32) -> f16 { return f16(ldexp_f64(f64(val), exp) )           }
 
 sqrt_f32    :: proc "c" (x: f32) -> f32             { return f32(sqrt_f64(f64(x)))                    }
 sin_f32     :: proc "c" (θ: f32) -> f32             { return f32(sin_f64(f64(θ)))                     }
@@ -39,5 +36,4 @@ cos_f32     :: proc "c" (θ: f32) -> f32             { return f32(cos_f64(f64(θ
 pow_f32     :: proc "c" (x, power: f32) -> f32      { return f32(pow_f64(f64(x), f64(power)))         }
 fmuladd_f32 :: proc "c" (a, b, c: f32) -> f32       { return f32(fmuladd_f64(f64(a), f64(a), f64(c))) }
 ln_f32      :: proc "c" (x: f32) -> f32             { return f32(ln_f64(f64(x)))                      }
-exp_f32     :: proc "c" (x: f32) -> f32             { return f32(exp_f64(f64(x)))                     }
-ldexp_f32   :: proc "c" (val: f32, exp: i32) -> f32 { return f32(ldexp_f64(f64(val), exp) )           }
\ No newline at end of file
+exp_f32     :: proc "c" (x: f32) -> f32             { return f32(exp_f64(f64(x)))                     }
\ No newline at end of file

From 91949b09929707ee969a5be778973e044d22d85c Mon Sep 17 00:00:00 2001
From: gingerBill <bill@gingerbill.org>
Date: Tue, 16 Nov 2021 14:11:20 +0000
Subject: [PATCH 02/38] Implement `math.sqrt` with `intrinsics.sqrt`

---
 core/math/math_basic.odin | 19 ++++++++++++-------
 core/math/math_js.odin    |  7 +++++--
 2 files changed, 17 insertions(+), 9 deletions(-)

diff --git a/core/math/math_basic.odin b/core/math/math_basic.odin
index 4995ac9e3..fe7b07d98 100644
--- a/core/math/math_basic.odin
+++ b/core/math/math_basic.odin
@@ -1,15 +1,10 @@
 //+build !js
 package math
 
+import "core:intrinsics"
+
 @(default_calling_convention="none")
 foreign _ {
-	@(link_name="llvm.sqrt.f16")
-	sqrt_f16 :: proc(x: f16) -> f16 ---
-	@(link_name="llvm.sqrt.f32")
-	sqrt_f32 :: proc(x: f32) -> f32 ---
-	@(link_name="llvm.sqrt.f64")
-	sqrt_f64 :: proc(x: f64) -> f64 ---
-
 	@(link_name="llvm.sin.f16")
 	sin_f16 :: proc(θ: f16) -> f16 ---
 	@(link_name="llvm.sin.f32")
@@ -52,3 +47,13 @@ foreign _ {
 	@(link_name="llvm.exp.f64")
 	exp_f64 :: proc(x: f64) -> f64 ---
 }
+
+sqrt_f16 :: proc "contextless" (x: f16) -> f16 {
+	return intrinsics.sqrt(x)
+}
+sqrt_f32 :: proc "contextless" (x: f32) -> f32 {
+	return intrinsics.sqrt(x)
+}
+sqrt_f64 :: proc "contextless" (x: f64) -> f64 {
+	return intrinsics.sqrt(x)
+}
diff --git a/core/math/math_js.odin b/core/math/math_js.odin
index 4d91b440c..06c8b636d 100644
--- a/core/math/math_js.odin
+++ b/core/math/math_js.odin
@@ -1,12 +1,12 @@
 //+build js
 package math
 
+import "core:intrinsics"
+
 foreign import "odin_env"
 
 @(default_calling_convention="c")
 foreign odin_env {
-	@(link_name="sqrt")
-	sqrt_f64 :: proc(x: f64) -> f64 ---
 	@(link_name="sin")
 	sin_f64 :: proc(θ: f64) -> f64 ---
 	@(link_name="cos")
@@ -21,6 +21,9 @@ foreign odin_env {
 	exp_f64 :: proc(x: f64) -> f64 ---
 }
 
+sqrt_f64 :: proc "contextless" (x: f64) -> f64 {
+	return intrinsics.sqrt(x)
+}
 
 sqrt_f16    :: proc "c" (x: f16) -> f16             { return f16(sqrt_f64(f64(x)))                    }
 sin_f16     :: proc "c" (θ: f16) -> f16             { return f16(sin_f64(f64(θ)))                     }

From 880af47ae72078ee894772b13477902aeb4e132b Mon Sep 17 00:00:00 2001
From: gingerBill <bill@gingerbill.org>
Date: Tue, 16 Nov 2021 14:26:04 +0000
Subject: [PATCH 03/38] Rename math_js.odin to math_basic_js.odin

---
 core/math/{math_js.odin => math_basic_js.odin} | 0
 1 file changed, 0 insertions(+), 0 deletions(-)
 rename core/math/{math_js.odin => math_basic_js.odin} (100%)

diff --git a/core/math/math_js.odin b/core/math/math_basic_js.odin
similarity index 100%
rename from core/math/math_js.odin
rename to core/math/math_basic_js.odin

From eb8b0d7a03ab2fb3a066c9135c429b97e7bad346 Mon Sep 17 00:00:00 2001
From: gingerBill <bill@gingerbill.org>
Date: Tue, 16 Nov 2021 14:26:43 +0000
Subject: [PATCH 04/38] Add `log1p`, `erf`, `erfc`, `ilogb` `logb` (implemented
 based of FreeBSD's)

---
 core/math/math.odin       | 190 ++++++++++++++++--
 core/math/math_erf.odin   | 410 ++++++++++++++++++++++++++++++++++++++
 core/math/math_log1p.odin | 198 ++++++++++++++++++
 3 files changed, 778 insertions(+), 20 deletions(-)
 create mode 100644 core/math/math_erf.odin
 create mode 100644 core/math/math_log1p.odin

diff --git a/core/math/math.odin b/core/math/math.odin
index f966ed11f..97fd4bd16 100644
--- a/core/math/math.odin
+++ b/core/math/math.odin
@@ -197,22 +197,16 @@ log       :: proc{
 	log_f64, log_f64le, log_f64be,
 }
 
-log2_f16   :: proc "contextless" (x: f16)   -> f16   { return ln(x)/LN2 }
-log2_f16le :: proc "contextless" (x: f16le) -> f16le { return f16le(log2_f16(f16(x))) }
-log2_f16be :: proc "contextless" (x: f16be) -> f16be { return f16be(log2_f16(f16(x))) }
-
-log2_f32   :: proc "contextless" (x: f32)   -> f32   { return ln(x)/LN2 }
-log2_f32le :: proc "contextless" (x: f32le) -> f32le { return f32le(log2_f32(f32(x))) }
-log2_f32be :: proc "contextless" (x: f32be) -> f32be { return f32be(log2_f32(f32(x))) }
-
-log2_f64   :: proc "contextless" (x: f64)   -> f64   { return ln(x)/LN2 }
-log2_f64le :: proc "contextless" (x: f64le) -> f64le { return f64le(log2_f64(f64(x))) }
-log2_f64be :: proc "contextless" (x: f64be) -> f64be { return f64be(log2_f64(f64(x))) }
-log2       :: proc{
-	log2_f16, log2_f16le, log2_f16be,
-	log2_f32, log2_f32le, log2_f32be,
-	log2_f64, log2_f64le, log2_f64be,
-}
+log2_f16   :: logb_f16
+log2_f16le :: logb_f16le
+log2_f16be :: logb_f16be
+log2_f32   :: logb_f32
+log2_f32le :: logb_f32le
+log2_f32be :: logb_f32be
+log2_f64   :: logb_f64
+log2_f64le :: logb_f64le
+log2_f64be :: logb_f64be
+log2       :: logb
 
 log10_f16   :: proc "contextless" (x: f16)   -> f16   { return ln(x)/LN10 }
 log10_f16le :: proc "contextless" (x: f16le) -> f16le { return f16le(log10_f16(f16(x))) }
@@ -1394,18 +1388,174 @@ tanh :: proc "contextless" (x: $T) -> T where intrinsics.type_is_float(T) {
 	return (t - 1) / (t + 1)
 }
 
-asinh :: proc "contextless" (x: $T) -> T where intrinsics.type_is_float(T) {
-	return ln(x + sqrt(x*x + 1))
+asinh :: proc "contextless" (y: $T) -> T where intrinsics.type_is_float(T) {
+	// The original C code, the long comment, and the constants
+	// below are from FreeBSD's /usr/src/lib/msun/src/s_asinh.c
+	// and came with this notice. 
+	//
+	// ====================================================
+	// Copyright (C) 1993 by Sun Microsystems, Inc. All rights reserved.
+	//
+	// Developed at SunPro, a Sun Microsystems, Inc. business.
+	// Permission to use, copy, modify, and distribute this
+	// software is freely granted, provided that this notice
+	// is preserved.
+	// ====================================================
+	
+	LN2       :: 0h3FE62E42FEFA39EF
+	NEAR_ZERO :: 1.0 / (1 << 28)
+	LARGE     :: 1 << 28
+	
+	x := f64(y)
+	
+	if is_nan(x) || is_inf(x) {
+		return T(x)
+	}
+	sign := false
+	if x < 0 {
+		x = -x
+		sign = true
+	}
+	temp: f64
+	switch {
+	case x > LARGE:
+		temp = ln(x) + LN2
+	case x > 2:
+		temp = ln(2*x + 1/(sqrt(x*x + 1) + x))
+	case x < NEAR_ZERO:
+		temp = x
+	case:
+		temp = log1p(x + x*x/(1 + sqrt(1 + x*x)))
+	}
+	
+	if sign {
+		temp = -temp
+	}
+	return T(temp)
 }
 
-acosh :: proc "contextless" (x: $T) -> T where intrinsics.type_is_float(T) {
-	return ln(x + sqrt(x*x - 1))
+acosh :: proc "contextless" (y: $T) -> T where intrinsics.type_is_float(T) {
+	// The original C code, the long comment, and the constants
+	// below are from FreeBSD's /usr/src/lib/msun/src/e_acosh.c
+	// and came with this notice. 
+	//
+	// ====================================================
+	// Copyright (C) 1993 by Sun Microsystems, Inc. All rights reserved.
+	//
+	// Developed at SunPro, a Sun Microsystems, Inc. business.
+	// Permission to use, copy, modify, and distribute this
+	// software is freely granted, provided that this notice
+	// is preserved.
+	// ====================================================
+	
+	LARGE :: 1<<28
+	LN2 :: 0h3FE62E42FEFA39EF
+	x := f64(y)
+	switch {
+	case x < 1 || is_nan(x):
+		return T(nan_f64())
+	case x == 1:
+		return 0
+	case x >= LARGE:
+		return T(ln(x) + LN2)
+	case x > 2:
+		return T(ln(2*x - 1/(x+sqrt(x*x-1))))
+	}
+	t := x-1
+	return T(log1p(t + sqrt(2*t + t*t)))
 }
 
 atanh :: proc "contextless" (x: $T) -> T where intrinsics.type_is_float(T) {
 	return 0.5*ln((1+x)/(1-x))
 }
 
+ilogb_f16 :: proc "contextless" (val: f16) -> int {
+	switch {
+	case val == 0:    return int(min(i32))
+	case is_nan(val): return int(max(i32))
+	case is_inf(val): return int(max(i32))
+	}
+	x, exp := normalize_f16(val)
+	return int(((transmute(u16)x)>>F16_SHIFT)&F16_MASK) - F16_BIAS + exp
+}
+ilogb_f32 :: proc "contextless" (val: f32) -> int {
+	switch {
+	case val == 0:    return int(min(i32))
+	case is_nan(val): return int(max(i32))
+	case is_inf(val): return int(max(i32))
+	}
+	x, exp := normalize_f32(val)
+	return int(((transmute(u32)x)>>F32_SHIFT)&F32_MASK) - F32_BIAS + exp
+}
+ilogb_f64 :: proc "contextless" (val: f64) -> int {
+	switch {
+	case val == 0:    return int(min(i32))
+	case is_nan(val): return int(max(i32))
+	case is_inf(val): return int(max(i32))
+	}
+	x, exp := normalize_f64(val)
+	return int(((transmute(u64)x)>>F64_SHIFT)&F64_MASK) - F64_BIAS + exp
+}
+ilogb_f16le :: proc "contextless" (value: f16le) -> int { return ilogb_f16(f16(value)) }
+ilogb_f16be :: proc "contextless" (value: f16be) -> int { return ilogb_f16(f16(value)) }
+ilogb_f32le :: proc "contextless" (value: f32le) -> int { return ilogb_f32(f32(value)) }
+ilogb_f32be :: proc "contextless" (value: f32be) -> int { return ilogb_f32(f32(value)) }
+ilogb_f64le :: proc "contextless" (value: f64le) -> int { return ilogb_f64(f64(value)) }
+ilogb_f64be :: proc "contextless" (value: f64be) -> int { return ilogb_f64(f64(value)) }
+ilogb :: proc {
+	ilogb_f16,
+	ilogb_f32,
+	ilogb_f64,
+	ilogb_f16le,
+	ilogb_f16be,
+	ilogb_f32le,
+	ilogb_f32be,
+	ilogb_f64le,
+	ilogb_f64be,
+}
+
+logb_f16 :: proc "contextless" (val: f16) -> f16 {
+	switch {
+	case val == 0:    return inf_f16(-1)
+	case is_inf(val): return inf_f16(+1)
+	case is_nan(val): return val
+	}
+	return f16(ilogb(val))
+}
+logb_f32 :: proc "contextless" (val: f32) -> f32 {
+	switch {
+	case val == 0:    return inf_f32(-1)
+	case is_inf(val): return inf_f32(+1)
+	case is_nan(val): return val
+	}
+	return f32(ilogb(val))
+}
+logb_f64 :: proc "contextless" (val: f64) -> f64 {
+	switch {
+	case val == 0:    return inf_f64(-1)
+	case is_inf(val): return inf_f64(+1)
+	case is_nan(val): return val
+	}
+	return f64(ilogb(val))
+}
+logb_f16le :: proc "contextless" (value: f16le) -> f16le { return f16le(logb_f16(f16(value))) }
+logb_f16be :: proc "contextless" (value: f16be) -> f16be { return f16be(logb_f16(f16(value))) }
+logb_f32le :: proc "contextless" (value: f32le) -> f32le { return f32le(logb_f32(f32(value))) }
+logb_f32be :: proc "contextless" (value: f32be) -> f32be { return f32be(logb_f32(f32(value))) }
+logb_f64le :: proc "contextless" (value: f64le) -> f64le { return f64le(logb_f64(f64(value))) }
+logb_f64be :: proc "contextless" (value: f64be) -> f64be { return f64be(logb_f64(f64(value))) }
+logb :: proc {
+	logb_f16,
+	logb_f32,
+	logb_f64,
+	logb_f16le,
+	logb_f16be,
+	logb_f32le,
+	logb_f32be,
+	logb_f64le,
+	logb_f64be,
+}
+
 F16_DIG        :: 3
 F16_EPSILON    :: 0.00097656
 F16_GUARD      :: 0
diff --git a/core/math/math_erf.odin b/core/math/math_erf.odin
new file mode 100644
index 000000000..cdade59c5
--- /dev/null
+++ b/core/math/math_erf.odin
@@ -0,0 +1,410 @@
+package math
+
+// The original C code and the long comment below are
+// from FreeBSD's /usr/src/lib/msun/src/s_erf.c and
+// came with this notice. 
+//
+// ====================================================
+// Copyright (C) 1993 by Sun Microsystems, Inc. All rights reserved.
+//
+// Developed at SunPro, a Sun Microsystems, Inc. business.
+// Permission to use, copy, modify, and distribute this
+// software is freely granted, provided that this notice
+// is preserved.
+// ====================================================
+//
+//
+// double erf(double x)
+// double erfc(double x)
+//                           x
+//                    2      |\
+//     erf(x)  =  ---------  | exp(-t*t)dt
+//                 sqrt(pi) \|
+//                           0
+//
+//     erfc(x) =  1-erf(x)
+//  Note that
+//              erf(-x) = -erf(x)
+//              erfc(-x) = 2 - erfc(x)
+//
+// Method:
+//      1. For |x| in [0, 0.84375]
+//          erf(x)  = x + x*R(x**2)
+//          erfc(x) = 1 - erf(x)           if x in [-.84375,0.25]
+//                  = 0.5 + ((0.5-x)-x*R)  if x in [0.25,0.84375]
+//         where R = P/Q where P is an odd poly of degree 8 and
+//         Q is an odd poly of degree 10.
+//                                               -57.90
+//                      | R - (erf(x)-x)/x | <= 2
+//
+//
+//         Remark. The formula is derived by noting
+//          erf(x) = (2/sqrt(pi))*(x - x**3/3 + x**5/10 - x**7/42 + ....)
+//         and that
+//          2/sqrt(pi) = 1.128379167095512573896158903121545171688
+//         is close to one. The interval is chosen because the fix
+//         point of erf(x) is near 0.6174 (i.e., erf(x)=x when x is
+//         near 0.6174), and by some experiment, 0.84375 is chosen to
+//         guarantee the error is less than one ulp for erf.
+//
+//      2. For |x| in [0.84375,1.25], let s = |x| - 1, and
+//         c = 0.84506291151 rounded to single (24 bits)
+//              erf(x)  = sign(x) * (c  + P1(s)/Q1(s))
+//              erfc(x) = (1-c)  - P1(s)/Q1(s) if x > 0
+//                        1+(c+P1(s)/Q1(s))    if x < 0
+//              |P1/Q1 - (erf(|x|)-c)| <= 2**-59.06
+//         Remark: here we use the taylor series expansion at x=1.
+//              erf(1+s) = erf(1) + s*Poly(s)
+//                       = 0.845.. + P1(s)/Q1(s)
+//         That is, we use rational approximation to approximate
+//                      erf(1+s) - (c = (single)0.84506291151)
+//         Note that |P1/Q1|< 0.078 for x in [0.84375,1.25]
+//         where
+//              P1(s) = degree 6 poly in s
+//              Q1(s) = degree 6 poly in s
+//
+//      3. For x in [1.25,1/0.35(~2.857143)],
+//              erfc(x) = (1/x)*exp(-x*x-0.5625+R1/S1)
+//              erf(x)  = 1 - erfc(x)
+//         where
+//              R1(z) = degree 7 poly in z, (z=1/x**2)
+//              S1(z) = degree 8 poly in z
+//
+//      4. For x in [1/0.35,28]
+//              erfc(x) = (1/x)*exp(-x*x-0.5625+R2/S2) if x > 0
+//                      = 2.0 - (1/x)*exp(-x*x-0.5625+R2/S2) if -6<x<0
+//                      = 2.0 - tiny            (if x <= -6)
+//              erf(x)  = sign(x)*(1.0 - erfc(x)) if x < 6, else
+//              erf(x)  = sign(x)*(1.0 - tiny)
+//         where
+//              R2(z) = degree 6 poly in z, (z=1/x**2)
+//              S2(z) = degree 7 poly in z
+//
+//      Note1:
+//         To compute exp(-x*x-0.5625+R/S), let s be a single
+//         precision number and s := x; then
+//              -x*x = -s*s + (s-x)*(s+x)
+//              exp(-x*x-0.5626+R/S) =
+//                      exp(-s*s-0.5625)*exp((s-x)*(s+x)+R/S);
+//      Note2:
+//         Here 4 and 5 make use of the asymptotic series
+//                        exp(-x*x)
+//              erfc(x) ~ ---------- * ( 1 + Poly(1/x**2) )
+//                        x*sqrt(pi)
+//         We use rational approximation to approximate
+//              g(s)=f(1/x**2) = log(erfc(x)*x) - x*x + 0.5625
+//         Here is the error bound for R1/S1 and R2/S2
+//              |R1/S1 - f(x)|  < 2**(-62.57)
+//              |R2/S2 - f(x)|  < 2**(-61.52)
+//
+//      5. For inf > x >= 28
+//              erf(x)  = sign(x) *(1 - tiny)  (raise inexact)
+//              erfc(x) = tiny*tiny (raise underflow) if x > 0
+//                      = 2 - tiny if x<0
+//
+//      7. Special case:
+//              erf(0)  = 0, erf(inf)  = 1, erf(-inf) = -1,
+//              erfc(0) = 1, erfc(inf) = 0, erfc(-inf) = 2,
+//              erfc/erf(NaN) is NaN
+
+erf :: proc{
+	erf_f16,
+	erf_f16le,
+	erf_f16be,
+	erf_f32,
+	erf_f32le,
+	erf_f32be,
+	erf_f64,
+}
+
+erf_f16   :: proc "contextless" (x: f16)   -> f16   { return f16(erf_f64(f64(x))) }
+erf_f16le :: proc "contextless" (x: f16le) -> f16le { return f16le(erf_f64(f64(x))) }
+erf_f16be :: proc "contextless" (x: f16be) -> f16be { return f16be(erf_f64(f64(x))) }
+erf_f32   :: proc "contextless" (x: f32)   -> f32   { return f32(erf_f64(f64(x))) }
+erf_f32le :: proc "contextless" (x: f32le) -> f32le { return f32le(erf_f64(f64(x))) }
+erf_f32be :: proc "contextless" (x: f32be) -> f32be { return f32be(erf_f64(f64(x))) }
+
+erf_f64 :: proc "contextless" (x: f64) -> f64 {
+	erx :: 0h3FEB0AC160000000
+	// Coefficients for approximation to  erf in [0, 0.84375]
+	efx  :: 0h3FC06EBA8214DB69
+	efx8 :: 0h3FF06EBA8214DB69
+	pp0  :: 0h3FC06EBA8214DB68
+	pp1  :: 0hBFD4CD7D691CB913
+	pp2  :: 0hBF9D2A51DBD7194F
+	pp3  :: 0hBF77A291236668E4
+	pp4  :: 0hBEF8EAD6120016AC
+	qq1  :: 0h3FD97779CDDADC09
+	qq2  :: 0h3FB0A54C5536CEBA
+	qq3  :: 0h3F74D022C4D36B0F
+	qq4  :: 0h3F215DC9221C1A10
+	qq5  :: 0hBED09C4342A26120
+	// Coefficients for approximation to  erf  in [0.84375, 1.25]
+	pa0 :: 0hBF6359B8BEF77538
+	pa1 :: 0h3FDA8D00AD92B34D
+	pa2 :: 0hBFD7D240FBB8C3F1
+	pa3 :: 0h3FD45FCA805120E4
+	pa4 :: 0hBFBC63983D3E28EC
+	pa5 :: 0h3FA22A36599795EB
+	pa6 :: 0hBF61BF380A96073F
+	qa1 :: 0h3FBB3E6618EEE323
+	qa2 :: 0h3FE14AF092EB6F33
+	qa3 :: 0h3FB2635CD99FE9A7
+	qa4 :: 0h3FC02660E763351F
+	qa5 :: 0h3F8BEDC26B51DD1C
+	qa6 :: 0h3F888B545735151D
+	// Coefficients for approximation to  erfc in [1.25, 1/0.35]
+	ra0 :: 0hBF843412600D6435
+	ra1 :: 0hBFE63416E4BA7360
+	ra2 :: 0hC0251E0441B0E726
+	ra3 :: 0hC04F300AE4CBA38D
+	ra4 :: 0hC0644CB184282266
+	ra5 :: 0hC067135CEBCCABB2
+	ra6 :: 0hC054526557E4D2F2
+	ra7 :: 0hC023A0EFC69AC25C
+	sa1 :: 0h4033A6B9BD707687
+	sa2 :: 0h4061350C526AE721
+	sa3 :: 0h407B290DD58A1A71
+	sa4 :: 0h40842B1921EC2868
+	sa5 :: 0h407AD02157700314
+	sa6 :: 0h405B28A3EE48AE2C
+	sa7 :: 0h401A47EF8E484A93
+	sa8 :: 0hBFAEEFF2EE749A62
+	// Coefficients for approximation to  erfc in [1/.35, 28]
+	rb0 :: 0hBF84341239E86F4A
+	rb1 :: 0hBFE993BA70C285DE
+	rb2 :: 0hC031C209555F995A
+	rb3 :: 0hC064145D43C5ED98
+	rb4 :: 0hC083EC881375F228
+	rb5 :: 0hC09004616A2E5992
+	rb6 :: 0hC07E384E9BDC383F
+	sb1 :: 0h403E568B261D5190
+	sb2 :: 0h40745CAE221B9F0A
+	sb3 :: 0h409802EB189D5118
+	sb4 :: 0h40A8FFB7688C246A
+	sb5 :: 0h40A3F219CEDF3BE6
+	sb6 :: 0h407DA874E79FE763
+	sb7 :: 0hC03670E242712D62
+	
+	
+	VERY_TINY :: 0h0080000000000000
+	SMALL     :: 1.0 / (1 << 28)        // 2**-28
+
+	// special cases
+	switch {
+	case is_nan(x):
+		return nan_f64()
+	case is_inf(x, 1):
+		return 1
+	case is_inf(x, -1):
+		return -1
+	}
+	x := x
+	sign := false
+	if x < 0 {
+		x = -x
+		sign = true
+	}
+	if x < 0.84375 { // |x| < 0.84375
+		temp: f64
+		if x < SMALL { // |x| < 2**-28
+			if x < VERY_TINY {
+				temp = 0.125 * (8.0*x + efx8*x) // avoid underflow
+			} else {
+				temp = x + efx*x
+			}
+		} else {
+			z := x * x
+			r := pp0 + z*(pp1+z*(pp2+z*(pp3+z*pp4)))
+			s := 1 + z*(qq1+z*(qq2+z*(qq3+z*(qq4+z*qq5))))
+			y := r / s
+			temp = x + x*y
+		}
+		if sign {
+			return -temp
+		}
+		return temp
+	}
+	if x < 1.25 { // 0.84375 <= |x| < 1.25
+		s := x - 1
+		P := pa0 + s*(pa1+s*(pa2+s*(pa3+s*(pa4+s*(pa5+s*pa6)))))
+		Q := 1 + s*(qa1+s*(qa2+s*(qa3+s*(qa4+s*(qa5+s*qa6)))))
+		if sign {
+			return -erx - P/Q
+		}
+		return erx + P/Q
+	}
+	if x >= 6 { // inf > |x| >= 6
+		if sign {
+			return -1
+		}
+		return 1
+	}
+	s := 1 / (x * x)
+	R, S: f64
+	if x < 1/0.35 { // |x| < 1 / 0.35  ~ 2.857143
+		R = ra0 + s*(ra1+s*(ra2+s*(ra3+s*(ra4+s*(ra5+s*(ra6+s*ra7))))))
+		S = 1 + s*(sa1+s*(sa2+s*(sa3+s*(sa4+s*(sa5+s*(sa6+s*(sa7+s*sa8)))))))
+	} else { // |x| >= 1 / 0.35  ~ 2.857143
+		R = rb0 + s*(rb1+s*(rb2+s*(rb3+s*(rb4+s*(rb5+s*rb6)))))
+		S = 1 + s*(sb1+s*(sb2+s*(sb3+s*(sb4+s*(sb5+s*(sb6+s*sb7))))))
+	}
+	z := transmute(f64)(0xffffffff00000000 & transmute(u64)x) // pseudo-single (20-bit) precision x
+	r := exp(-z*z-0.5625) * exp((z-x)*(z+x)+R/S)
+	if sign {
+		return r/x - 1
+	}
+	return 1 - r/x
+}
+
+
+erfc :: proc{
+	erfc_f16,
+	erfc_f16le,
+	erfc_f16be,
+	erfc_f32,
+	erfc_f32le,
+	erfc_f32be,
+	erfc_f64,
+}
+
+erfc_f16   :: proc "contextless" (x: f16)   -> f16   { return f16(erfc_f64(f64(x))) }
+erfc_f16le :: proc "contextless" (x: f16le) -> f16le { return f16le(erfc_f64(f64(x))) }
+erfc_f16be :: proc "contextless" (x: f16be) -> f16be { return f16be(erfc_f64(f64(x))) }
+erfc_f32   :: proc "contextless" (x: f32)   -> f32   { return f32(erfc_f64(f64(x))) }
+erfc_f32le :: proc "contextless" (x: f32le) -> f32le { return f32le(erfc_f64(f64(x))) }
+erfc_f32be :: proc "contextless" (x: f32be) -> f32be { return f32be(erfc_f64(f64(x))) }
+
+erfc_f64 :: proc "contextless" (x: f64) -> f64 {
+	erx :: 0h3FEB0AC160000000
+	// Coefficients for approximation to  erf in [0, 0.84375]
+	efx  :: 0h3FC06EBA8214DB69
+	efx8 :: 0h3FF06EBA8214DB69
+	pp0  :: 0h3FC06EBA8214DB68
+	pp1  :: 0hBFD4CD7D691CB913
+	pp2  :: 0hBF9D2A51DBD7194F
+	pp3  :: 0hBF77A291236668E4
+	pp4  :: 0hBEF8EAD6120016AC
+	qq1  :: 0h3FD97779CDDADC09
+	qq2  :: 0h3FB0A54C5536CEBA
+	qq3  :: 0h3F74D022C4D36B0F
+	qq4  :: 0h3F215DC9221C1A10
+	qq5  :: 0hBED09C4342A26120
+	// Coefficients for approximation to  erf  in [0.84375, 1.25]
+	pa0 :: 0hBF6359B8BEF77538
+	pa1 :: 0h3FDA8D00AD92B34D
+	pa2 :: 0hBFD7D240FBB8C3F1
+	pa3 :: 0h3FD45FCA805120E4
+	pa4 :: 0hBFBC63983D3E28EC
+	pa5 :: 0h3FA22A36599795EB
+	pa6 :: 0hBF61BF380A96073F
+	qa1 :: 0h3FBB3E6618EEE323
+	qa2 :: 0h3FE14AF092EB6F33
+	qa3 :: 0h3FB2635CD99FE9A7
+	qa4 :: 0h3FC02660E763351F
+	qa5 :: 0h3F8BEDC26B51DD1C
+	qa6 :: 0h3F888B545735151D
+	// Coefficients for approximation to  erfc in [1.25, 1/0.35]
+	ra0 :: 0hBF843412600D6435
+	ra1 :: 0hBFE63416E4BA7360
+	ra2 :: 0hC0251E0441B0E726
+	ra3 :: 0hC04F300AE4CBA38D
+	ra4 :: 0hC0644CB184282266
+	ra5 :: 0hC067135CEBCCABB2
+	ra6 :: 0hC054526557E4D2F2
+	ra7 :: 0hC023A0EFC69AC25C
+	sa1 :: 0h4033A6B9BD707687
+	sa2 :: 0h4061350C526AE721
+	sa3 :: 0h407B290DD58A1A71
+	sa4 :: 0h40842B1921EC2868
+	sa5 :: 0h407AD02157700314
+	sa6 :: 0h405B28A3EE48AE2C
+	sa7 :: 0h401A47EF8E484A93
+	sa8 :: 0hBFAEEFF2EE749A62
+	// Coefficients for approximation to  erfc in [1/.35, 28]
+	rb0 :: 0hBF84341239E86F4A
+	rb1 :: 0hBFE993BA70C285DE
+	rb2 :: 0hC031C209555F995A
+	rb3 :: 0hC064145D43C5ED98
+	rb4 :: 0hC083EC881375F228
+	rb5 :: 0hC09004616A2E5992
+	rb6 :: 0hC07E384E9BDC383F
+	sb1 :: 0h403E568B261D5190
+	sb2 :: 0h40745CAE221B9F0A
+	sb3 :: 0h409802EB189D5118
+	sb4 :: 0h40A8FFB7688C246A
+	sb5 :: 0h40A3F219CEDF3BE6
+	sb6 :: 0h407DA874E79FE763
+	sb7 :: 0hC03670E242712D62
+	
+	TINY :: 1.0 / (1 << 56) // 2**-56
+	// special cases
+	switch {
+	case is_nan(x):
+		return nan_f64()
+	case is_inf(x, 1):
+		return 0
+	case is_inf(x, -1):
+		return 2
+	}
+	x := x
+	sign := false
+	if x < 0 {
+		x = -x
+		sign = true
+	}
+	if x < 0.84375 { // |x| < 0.84375
+		temp: f64
+		if x < TINY { // |x| < 2**-56
+			temp = x
+		} else {
+			z := x * x
+			r := pp0 + z*(pp1+z*(pp2+z*(pp3+z*pp4)))
+			s := 1 + z*(qq1+z*(qq2+z*(qq3+z*(qq4+z*qq5))))
+			y := r / s
+			if x < 0.25 { // |x| < 1/4
+				temp = x + x*y
+			} else {
+				temp = 0.5 + (x*y + (x - 0.5))
+			}
+		}
+		if sign {
+			return 1 + temp
+		}
+		return 1 - temp
+	}
+	if x < 1.25 { // 0.84375 <= |x| < 1.25
+		s := x - 1
+		P := pa0 + s*(pa1+s*(pa2+s*(pa3+s*(pa4+s*(pa5+s*pa6)))))
+		Q := 1 + s*(qa1+s*(qa2+s*(qa3+s*(qa4+s*(qa5+s*qa6)))))
+		if sign {
+			return 1 + erx + P/Q
+		}
+		return 1 - erx - P/Q
+
+	}
+	if x < 28 { // |x| < 28
+		s := 1 / (x * x)
+		R, S: f64
+		if x < 1/0.35 { // |x| < 1 / 0.35 ~ 2.857143
+			R = ra0 + s*(ra1+s*(ra2+s*(ra3+s*(ra4+s*(ra5+s*(ra6+s*ra7))))))
+			S = 1 + s*(sa1+s*(sa2+s*(sa3+s*(sa4+s*(sa5+s*(sa6+s*(sa7+s*sa8)))))))
+		} else { // |x| >= 1 / 0.35 ~ 2.857143
+			if sign && x > 6 {
+				return 2 // x < -6
+			}
+			R = rb0 + s*(rb1+s*(rb2+s*(rb3+s*(rb4+s*(rb5+s*rb6)))))
+			S = 1 + s*(sb1+s*(sb2+s*(sb3+s*(sb4+s*(sb5+s*(sb6+s*sb7))))))
+		}
+		z := transmute(f64)(0xffffffff00000000 & transmute(u64)x) // pseudo-single (20-bit) precision x
+		r := exp(-z*z-0.5625) * exp((z-x)*(z+x)+R/S)
+		if sign {
+			return 2 - r/x
+		}
+		return r / x
+	}
+	if sign {
+		return 2
+	}
+	return 0
+}
\ No newline at end of file
diff --git a/core/math/math_log1p.odin b/core/math/math_log1p.odin
new file mode 100644
index 000000000..07e790666
--- /dev/null
+++ b/core/math/math_log1p.odin
@@ -0,0 +1,198 @@
+package math
+
+// The original C code, the long comment, and the constants
+// below are from FreeBSD's /usr/src/lib/msun/src/s_log1p.c
+// and came with this notice. The go code is a simplified
+// version of the original C.
+//
+// ====================================================
+// Copyright (C) 1993 by Sun Microsystems, Inc. All rights reserved.
+//
+// Developed at SunPro, a Sun Microsystems, Inc. business.
+// Permission to use, copy, modify, and distribute this
+// software is freely granted, provided that this notice
+// is preserved.
+// ====================================================
+//
+//
+// double log1p(double x)
+//
+// Method :
+//   1. Argument Reduction: find k and f such that
+//                      1+x = 2**k * (1+f),
+//         where  sqrt(2)/2 < 1+f < sqrt(2) .
+//
+//      Note. If k=0, then f=x is exact. However, if k!=0, then f
+//      may not be representable exactly. In that case, a correction
+//      term is need. Let u=1+x rounded. Let c = (1+x)-u, then
+//      log(1+x) - log(u) ~ c/u. Thus, we proceed to compute log(u),
+//      and add back the correction term c/u.
+//      (Note: when x > 2**53, one can simply return log(x))
+//
+//   2. Approximation of log1p(f).
+//      Let s = f/(2+f) ; based on log(1+f) = log(1+s) - log(1-s)
+//               = 2s + 2/3 s**3 + 2/5 s**5 + .....,
+//               = 2s + s*R
+//      We use a special Reme algorithm on [0,0.1716] to generate
+//      a polynomial of degree 14 to approximate R The maximum error
+//      of this polynomial approximation is bounded by 2**-58.45. In
+//      other words,
+//                      2      4      6      8      10      12      14
+//          R(z) ~ Lp1*s +Lp2*s +Lp3*s +Lp4*s +Lp5*s  +Lp6*s  +Lp7*s
+//      (the values of Lp1 to Lp7 are listed in the program)
+//      and
+//          |      2          14          |     -58.45
+//          | Lp1*s +...+Lp7*s    -  R(z) | <= 2
+//          |                             |
+//      Note that 2s = f - s*f = f - hfsq + s*hfsq, where hfsq = f*f/2.
+//      In order to guarantee error in log below 1ulp, we compute log
+//      by
+//              log1p(f) = f - (hfsq - s*(hfsq+R)).
+//
+//   3. Finally, log1p(x) = k*ln2 + log1p(f).
+//                        = k*ln2_hi+(f-(hfsq-(s*(hfsq+R)+k*ln2_lo)))
+//      Here ln2 is split into two floating point number:
+//                   ln2_hi + ln2_lo,
+//      where n*ln2_hi is always exact for |n| < 2000.
+//
+// Special cases:
+//      log1p(x) is NaN with signal if x < -1 (including -INF) ;
+//      log1p(+INF) is +INF; log1p(-1) is -INF with signal;
+//      log1p(NaN) is that NaN with no signal.
+//
+// Accuracy:
+//      according to an error analysis, the error is always less than
+//      1 ulp (unit in the last place).
+//
+// Constants:
+// The hexadecimal values are the intended ones for the following
+// constants. The decimal values may be used, provided that the
+// compiler will convert from decimal to binary accurately enough
+// to produce the hexadecimal values shown.
+//
+// Note: Assuming log() return accurate answer, the following
+//       algorithm can be used to compute log1p(x) to within a few ULP:
+//
+//              u = 1+x;
+//              if(u==1.0) return x ; else
+//                         return log(u)*(x/(u-1.0));
+//
+//       See HP-15C Advanced Functions Handbook, p.193.
+
+log1p :: proc {
+	log1p_f16,
+	log1p_f32,
+	log1p_f64,
+	log1p_f16le,
+	log1p_f16be,
+	log1p_f32le,
+	log1p_f32be,
+	log1p_f64le,
+	log1p_f64be,
+}
+log1p_f16   :: proc "contextless" (x: f16)   -> f16   { return f16(log1p_f64(f64(x))) }
+log1p_f32   :: proc "contextless" (x: f32)   -> f32   { return f32(log1p_f64(f64(x))) }
+log1p_f16le :: proc "contextless" (x: f16le) -> f16le { return f16le(log1p_f64(f64(x))) }
+log1p_f16be :: proc "contextless" (x: f16be) -> f16be { return f16be(log1p_f64(f64(x))) }
+log1p_f32le :: proc "contextless" (x: f32le) -> f32le { return f32le(log1p_f64(f64(x))) }
+log1p_f32be :: proc "contextless" (x: f32be) -> f32be { return f32be(log1p_f64(f64(x))) }
+log1p_f64le :: proc "contextless" (x: f64le) -> f64le { return f64le(log1p_f64(f64(x))) }
+log1p_f64be :: proc "contextless" (x: f64be) -> f64be { return f64be(log1p_f64(f64(x))) }
+
+log1p_f64 :: proc "contextless" (x: f64) -> f64 {
+	SQRT2_M1      :: 0h3fda827999fcef34 // Sqrt(2)-1 
+	SQRT2_HALF_M1 :: 0hbfd2bec333018866 // Sqrt(2)/2-1
+	SMALL         :: 0h3e20000000000000 // 2**-29
+	TINY          :: 1.0 / (1 << 54)    // 2**-54
+	TWO53         :: 1 << 53            // 2**53
+	LN2HI         :: 0h3fe62e42fee00000
+	LN2LO         :: 0h3dea39ef35793c76
+	LP1           :: 0h3FE5555555555593
+	LP2           :: 0h3FD999999997FA04
+	LP3           :: 0h3FD2492494229359
+	LP4           :: 0h3FCC71C51D8E78AF
+	LP5           :: 0h3FC7466496CB03DE
+	LP6           :: 0h3FC39A09D078C69F
+	LP7           :: 0h3FC2F112DF3E5244
+	
+	switch {
+	case x < -1 || is_nan(x):
+		return nan_f64()
+	case x == -1:
+		return inf_f64(-1)
+	case is_inf(x, 1):
+		return inf_f64(+1)
+	}
+	absx := abs(x)
+	
+	f: f64
+	iu: u64
+	k := 1
+	if absx < SQRT2_M1 { //  |x| < Sqrt(2)-1
+		if absx < SMALL { // |x| < 2**-29
+			if absx < TINY { // |x| < 2**-54
+				return x
+			}
+			return x - x*x*0.5
+		}
+		if x > SQRT2_HALF_M1 { // Sqrt(2)/2-1 < x
+			// (Sqrt(2)/2-1) < x < (Sqrt(2)-1)
+			k = 0
+			f = x
+			iu = 1
+		}
+	}
+	c: f64
+	if k != 0 {
+		u: f64
+		if absx < TWO53 { // 1<<53
+			u = 1.0 + x
+			iu = transmute(u64)u
+			k = int((iu >> 52) - 1023)
+			// correction term
+			if k > 0 {
+				c = 1.0 - (u - x)
+			} else {
+				c = x - (u - 1.0)
+			}
+			c /= u
+		} else {
+			u = x
+			iu = transmute(u64)u
+			k = int((iu >> 52) - 1023)
+			c = 0
+		}
+		iu &= 0x000fffffffffffff
+		if iu < 0x0006a09e667f3bcd { // mantissa of Sqrt(2)
+			u = transmute(f64)(iu | 0x3ff0000000000000) // normalize u
+		} else {
+			k += 1
+			u = transmute(f64)(iu | 0x3fe0000000000000) // normalize u/2
+			iu = (0x0010000000000000 - iu) >> 2
+		}
+		f = u - 1.0 // Sqrt(2)/2 < u < Sqrt(2)
+	}
+	hfsq := 0.5 * f * f
+	s, R, z: f64
+	if iu == 0 { // |f| < 2**-20
+		if f == 0 {
+			if k == 0 {
+				return 0
+			}
+			c += f64(k) * LN2LO
+			return f64(k)*LN2HI + c
+		}
+		R = hfsq * (1.0 - 0.66666666666666666*f) // avoid division
+		if k == 0 {
+			return f - R
+		}
+		return f64(k)*LN2HI - ((R - (f64(k)*LN2LO + c)) - f)
+	}
+	s = f / (2.0 + f)
+	z = s * s
+	R = z * (LP1 + z*(LP2+z*(LP3+z*(LP4+z*(LP5+z*(LP6+z*LP7))))))
+	if k == 0 {
+		return f - (hfsq - s*(hfsq+R))
+	}
+	return f64(k)*LN2HI - ((hfsq - (s*(hfsq+R) + (f64(k)*LN2LO + c))) - f)
+}

From 91408cb21f5ad7d04f5dc63dc350f727fe93d920 Mon Sep 17 00:00:00 2001
From: gingerBill <bill@gingerbill.org>
Date: Tue, 16 Nov 2021 14:58:59 +0000
Subject: [PATCH 05/38] Implement `atanh` based on FreeBSD's
 /usr/src/lib/msun/src/e_atanh.c

---
 core/math/math.odin | 44 ++++++++++++++++++++++++++++++++++++++++++--
 1 file changed, 42 insertions(+), 2 deletions(-)

diff --git a/core/math/math.odin b/core/math/math.odin
index 97fd4bd16..f63a0644b 100644
--- a/core/math/math.odin
+++ b/core/math/math.odin
@@ -1465,8 +1465,48 @@ acosh :: proc "contextless" (y: $T) -> T where intrinsics.type_is_float(T) {
 	return T(log1p(t + sqrt(2*t + t*t)))
 }
 
-atanh :: proc "contextless" (x: $T) -> T where intrinsics.type_is_float(T) {
-	return 0.5*ln((1+x)/(1-x))
+atanh :: proc "contextless" (y: $T) -> T where intrinsics.type_is_float(T) {
+	// The original C code, the long comment, and the constants
+	// below are from FreeBSD's /usr/src/lib/msun/src/e_atanh.c
+	// and came with this notice. 
+	//
+	// ====================================================
+	// Copyright (C) 1993 by Sun Microsystems, Inc. All rights reserved.
+	//
+	// Developed at SunPro, a Sun Microsystems, Inc. business.
+	// Permission to use, copy, modify, and distribute this
+	// software is freely granted, provided that this notice
+	// is preserved.
+	// ====================================================
+	NEAR_ZERO :: 1.0 / (1 << 28)
+	x := f64(y)
+	switch {
+	case x < -1 || x > 1 || is_nan(x):
+		return T(nan_f64())
+	case x == 1:
+		return T(inf_f64(1))
+	case x == -1:
+		return T(inf_f64(-1))
+	}
+	sign := false
+	if x < 0 {
+		x = -x
+		sign = true
+	}
+	temp: f64
+	switch {
+	case x < NEAR_ZERO:
+		temp = x
+	case x < 0.5:
+		temp = x + x
+		temp = 0.5 * log1p(temp + temp*x/(1-x))
+	case:
+		temp = 0.5 * log1p((x+x)/(1-x))
+	}
+	if sign {
+		temp = -temp
+	}
+	return T(temp)
 }
 
 ilogb_f16 :: proc "contextless" (val: f16) -> int {

From e721f26a76facc8d0d9b5f2fccdb171c3857a327 Mon Sep 17 00:00:00 2001
From: gingerBill <bill@gingerbill.org>
Date: Tue, 16 Nov 2021 15:05:04 +0000
Subject: [PATCH 06/38] Implement `ln` based off FreeBSD's
 /usr/src/lib/msun/src/e_log.c

---
 core/math/math.odin       |  12 ----
 core/math/math_basic.odin | 124 +++++++++++++++++++++++++++++++++++---
 2 files changed, 117 insertions(+), 19 deletions(-)

diff --git a/core/math/math.odin b/core/math/math.odin
index f63a0644b..5dd8f3732 100644
--- a/core/math/math.odin
+++ b/core/math/math.odin
@@ -96,18 +96,6 @@ fmuladd       :: proc{
 	fmuladd_f64, fmuladd_f64le, fmuladd_f64be,
 }
 
-ln_f16le :: proc "contextless" (x: f16le) -> f16le { return #force_inline f16le(ln_f16(f16(x))) }
-ln_f16be :: proc "contextless" (x: f16be) -> f16be { return #force_inline f16be(ln_f16(f16(x))) }
-ln_f32le :: proc "contextless" (x: f32le) -> f32le { return #force_inline f32le(ln_f32(f32(x))) }
-ln_f32be :: proc "contextless" (x: f32be) -> f32be { return #force_inline f32be(ln_f32(f32(x))) }
-ln_f64le :: proc "contextless" (x: f64le) -> f64le { return #force_inline f64le(ln_f64(f64(x))) }
-ln_f64be :: proc "contextless" (x: f64be) -> f64be { return #force_inline f64be(ln_f64(f64(x))) }
-ln       :: proc{
-	ln_f16, ln_f16le, ln_f16be,
-	ln_f32, ln_f32le, ln_f32be,
-	ln_f64, ln_f64le, ln_f64be,
-}
-
 exp_f16le :: proc "contextless" (x: f16le) -> f16le { return #force_inline f16le(exp_f16(f16(x))) }
 exp_f16be :: proc "contextless" (x: f16be) -> f16be { return #force_inline f16be(exp_f16(f16(x))) }
 exp_f32le :: proc "contextless" (x: f32le) -> f32le { return #force_inline f32le(exp_f32(f32(x))) }
diff --git a/core/math/math_basic.odin b/core/math/math_basic.odin
index fe7b07d98..27c9bb366 100644
--- a/core/math/math_basic.odin
+++ b/core/math/math_basic.odin
@@ -33,13 +33,6 @@ foreign _ {
 	@(link_name="llvm.fmuladd.f64")
 	fmuladd_f64 :: proc(a, b, c: f64) -> f64 ---
 
-	@(link_name="llvm.log.f16")
-	ln_f16 :: proc(x: f16) -> f16 ---
-	@(link_name="llvm.log.f32")
-	ln_f32 :: proc(x: f32) -> f32 ---
-	@(link_name="llvm.log.f64")
-	ln_f64 :: proc(x: f64) -> f64 ---
-
 	@(link_name="llvm.exp.f16")
 	exp_f16 :: proc(x: f16) -> f16 ---
 	@(link_name="llvm.exp.f32")
@@ -57,3 +50,120 @@ sqrt_f32 :: proc "contextless" (x: f32) -> f32 {
 sqrt_f64 :: proc "contextless" (x: f64) -> f64 {
 	return intrinsics.sqrt(x)
 }
+
+
+
+ln_f64 :: proc "contextless" (x: f64) -> f64 {
+	// The original C code, the long comment, and the constants
+	// below are from FreeBSD's /usr/src/lib/msun/src/e_log.c
+	// and came with this notice.
+	//
+	// ====================================================
+	// Copyright (C) 1993 by Sun Microsystems, Inc. All rights reserved.
+	//
+	// Developed at SunPro, a Sun Microsystems, Inc. business.
+	// Permission to use, copy, modify, and distribute this
+	// software is freely granted, provided that this notice
+	// is preserved.
+	// ====================================================
+	//
+	// __ieee754_log(x)
+	// Return the logarithm of x
+	//
+	// Method :
+	//   1. Argument Reduction: find k and f such that
+	//			x = 2**k * (1+f),
+	//	   where  sqrt(2)/2 < 1+f < sqrt(2) .
+	//
+	//   2. Approximation of log(1+f).
+	//	Let s = f/(2+f) ; based on log(1+f) = log(1+s) - log(1-s)
+	//		 = 2s + 2/3 s**3 + 2/5 s**5 + .....,
+	//	     	 = 2s + s*R
+	//      We use a special Reme algorithm on [0,0.1716] to generate
+	//	a polynomial of degree 14 to approximate R.  The maximum error
+	//	of this polynomial approximation is bounded by 2**-58.45. In
+	//	other words,
+	//		        2      4      6      8      10      12      14
+	//	    R(z) ~ L1*s +L2*s +L3*s +L4*s +L5*s  +L6*s  +L7*s
+	//	(the values of L1 to L7 are listed in the program) and
+	//	    |      2          14          |     -58.45
+	//	    | L1*s +...+L7*s    -  R(z) | <= 2
+	//	    |                             |
+	//	Note that 2s = f - s*f = f - hfsq + s*hfsq, where hfsq = f*f/2.
+	//	In order to guarantee error in log below 1ulp, we compute log by
+	//		log(1+f) = f - s*(f - R)		(if f is not too large)
+	//		log(1+f) = f - (hfsq - s*(hfsq+R)).	(better accuracy)
+	//
+	//	3. Finally,  log(x) = k*Ln2 + log(1+f).
+	//			    = k*Ln2_hi+(f-(hfsq-(s*(hfsq+R)+k*Ln2_lo)))
+	//	   Here Ln2 is split into two floating point number:
+	//			Ln2_hi + Ln2_lo,
+	//	   where n*Ln2_hi is always exact for |n| < 2000.
+	//
+	// Special cases:
+	//	log(x) is NaN with signal if x < 0 (including -INF) ;
+	//	log(+INF) is +INF; log(0) is -INF with signal;
+	//	log(NaN) is that NaN with no signal.
+	//
+	// Accuracy:
+	//	according to an error analysis, the error is always less than
+	//	1 ulp (unit in the last place).
+	//
+	// Constants:
+	// The hexadecimal values are the intended ones for the following
+	// constants. The decimal values may be used, provided that the
+	// compiler will convert from decimal to binary accurately enough
+	// to produce the hexadecimal values shown.
+	
+	LN2_HI :: 0h3fe62e42_fee00000 // 6.93147180369123816490e-01
+	LN2_LO :: 0h3dea39ef_35793c76 // 1.90821492927058770002e-10
+	L1     :: 0h3fe55555_55555593 // 6.666666666666735130e-01
+	L2     :: 0h3fd99999_9997fa04 // 3.999999999940941908e-01
+	L3     :: 0h3fd24924_94229359 // 2.857142874366239149e-01
+	L4     :: 0h3fcc71c5_1d8e78af // 2.222219843214978396e-01
+	L5     :: 0h3fc74664_96cb03de // 1.818357216161805012e-01
+	L6     :: 0h3fc39a09_d078c69f // 1.531383769920937332e-01
+	L7     :: 0h3fc2f112_df3e5244 // 1.479819860511658591e-01
+	
+	switch {
+	case is_nan(x) || is_inf(x, 1):
+		return x
+	case x < 0:
+		return nan_f64()
+	case x == 0:
+		return inf_f64(-1)
+	}
+
+	// reduce
+	f1, ki := frexp(x)
+	if f1 < SQRT_TWO/2 {
+		f1 *= 2
+		ki -= 1
+	}
+	f := f1 - 1
+	k := f64(ki)
+
+	// compute
+	s := f / (2 + f)
+	s2 := s * s
+	s4 := s2 * s2
+	t1 := s2 * (L1 + s4*(L3+s4*(L5+s4*L7)))
+	t2 := s4 * (L2 + s4*(L4+s4*L6))
+	R := t1 + t2
+	hfsq := 0.5 * f * f
+	return k*Ln2Hi_ - ((hfsq - (s*(hfsq+R) + k*LN2_LO)) - f)
+}
+
+ln_f16 :: proc "contextless" (x: f16) -> f16 { return #force_inline f16(ln_f64(f64(x))) }
+ln_f32 :: proc "contextless" (x: f32) -> f32 { return #force_inline f32(ln_f64(f64(x))) }
+ln_f16le :: proc "contextless" (x: f16le) -> f16le { return #force_inline f16le(ln_f64(f64(x))) }
+ln_f16be :: proc "contextless" (x: f16be) -> f16be { return #force_inline f16be(ln_f64(f64(x))) }
+ln_f32le :: proc "contextless" (x: f32le) -> f32le { return #force_inline f32le(ln_f64(f64(x))) }
+ln_f32be :: proc "contextless" (x: f32be) -> f32be { return #force_inline f32be(ln_f64(f64(x))) }
+ln_f64le :: proc "contextless" (x: f64le) -> f64le { return #force_inline f64le(ln_f64(f64(x))) }
+ln_f64be :: proc "contextless" (x: f64be) -> f64be { return #force_inline f64be(ln_f64(f64(x))) }
+ln :: proc{
+	ln_f16, ln_f16le, ln_f16be,
+	ln_f32, ln_f32le, ln_f32be,
+	ln_f64, ln_f64le, ln_f64be,
+}
\ No newline at end of file

From d2327961495a95f1a92f8630bd9346eb748889ca Mon Sep 17 00:00:00 2001
From: gingerBill <bill@gingerbill.org>
Date: Tue, 16 Nov 2021 15:09:47 +0000
Subject: [PATCH 07/38] Fix typo

---
 core/math/math_basic.odin | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/core/math/math_basic.odin b/core/math/math_basic.odin
index 27c9bb366..c9d2e632d 100644
--- a/core/math/math_basic.odin
+++ b/core/math/math_basic.odin
@@ -151,7 +151,7 @@ ln_f64 :: proc "contextless" (x: f64) -> f64 {
 	t2 := s4 * (L2 + s4*(L4+s4*L6))
 	R := t1 + t2
 	hfsq := 0.5 * f * f
-	return k*Ln2Hi_ - ((hfsq - (s*(hfsq+R) + k*LN2_LO)) - f)
+	return k*LN2_HI - ((hfsq - (s*(hfsq+R) + k*LN2_LO)) - f)
 }
 
 ln_f16 :: proc "contextless" (x: f16) -> f16 { return #force_inline f16(ln_f64(f64(x))) }

From b530ca9a5e64643b11f5ddb67e15e8aacf0af2fa Mon Sep 17 00:00:00 2001
From: gingerBill <bill@gingerbill.org>
Date: Tue, 16 Nov 2021 15:12:01 +0000
Subject: [PATCH 08/38] Add `math.nextafter`

---
 core/math/math.odin | 59 +++++++++++++++++++++++++++++++++++++++++++++
 1 file changed, 59 insertions(+)

diff --git a/core/math/math.odin b/core/math/math.odin
index 5dd8f3732..577536972 100644
--- a/core/math/math.odin
+++ b/core/math/math.odin
@@ -1584,6 +1584,65 @@ logb :: proc {
 	logb_f64be,
 }
 
+nextafter_f16 :: proc "contextless" (x, y: f16) -> (r: f16) {
+	switch {
+	case is_nan(x) || is_nan(y):
+		r = nan_f16()
+	case x == y:
+		r = x
+	case x == 0:
+		r = copy_sign_f16(1, y)
+	case (y > x) == (x > 0):
+		r = transmute(f16)(transmute(u16)x + 1)
+	case:
+		r = transmute(f16)(transmute(u16)x - 1)
+	}
+	return
+}
+nextafter_f32 :: proc "contextless" (x, y: f32) -> (r: f32) {
+	switch {
+	case is_nan(x) || is_nan(y):
+		r = nan_f32()
+	case x == y:
+		r = x
+	case x == 0:
+		r = copy_sign_f32(1, y)
+	case (y > x) == (x > 0):
+		r = transmute(f32)(transmute(u32)x + 1)
+	case:
+		r = transmute(f32)(transmute(u32)x - 1)
+	}
+	return
+}
+nextafter_f64 :: proc "contextless" (x, y: f64) -> (r: f64) {
+	switch {
+	case is_nan(x) || is_nan(y):
+		r = nan_f64()
+	case x == y:
+		r = x
+	case x == 0:
+		r = copy_sign_f64(1, y)
+	case (y > x) == (x > 0):
+		r = transmute(f64)(transmute(u64)x + 1)
+	case:
+		r = transmute(f64)(transmute(u64)x - 1)
+	}
+	return
+}
+nextafter_f16le :: proc "contextless" (x, y: f16le) -> (r: f16le) { return f16le(nextafter_f16(f16(x), f16(y))) }
+nextafter_f16be :: proc "contextless" (x, y: f16be) -> (r: f16be) { return f16be(nextafter_f16(f16(x), f16(y))) }
+nextafter_f32le :: proc "contextless" (x, y: f32le) -> (r: f32le) { return f32le(nextafter_f32(f32(x), f32(y))) }
+nextafter_f32be :: proc "contextless" (x, y: f32be) -> (r: f32be) { return f32be(nextafter_f32(f32(x), f32(y))) }
+nextafter_f64le :: proc "contextless" (x, y: f64le) -> (r: f64le) { return f64le(nextafter_f64(f64(x), f64(y))) }
+nextafter_f64be :: proc "contextless" (x, y: f64be) -> (r: f64be) { return f64be(nextafter_f64(f64(x), f64(y))) }
+
+nextafter :: proc{
+	nextafter_f16, nextafter_f16le, nextafter_f16be,
+	nextafter_f32, nextafter_f32le, nextafter_f32be,
+	nextafter_f64, nextafter_f64le, nextafter_f64be,
+}
+
+
 F16_DIG        :: 3
 F16_EPSILON    :: 0.00097656
 F16_GUARD      :: 0

From 2b546a598c34ff1319df000af2dbc496f2fe4f3b Mon Sep 17 00:00:00 2001
From: gingerBill <bill@gingerbill.org>
Date: Tue, 16 Nov 2021 15:23:19 +0000
Subject: [PATCH 09/38] Add `math.signbit`; Add `math.gamma` based on
 http://netlib.sandia.gov/cephes/cprob/gamma.c

---
 core/math/math.odin       |  22 ++++
 core/math/math_gamma.odin | 226 ++++++++++++++++++++++++++++++++++++++
 2 files changed, 248 insertions(+)
 create mode 100644 core/math/math_gamma.odin

diff --git a/core/math/math.odin b/core/math/math.odin
index 577536972..ef89562c9 100644
--- a/core/math/math.odin
+++ b/core/math/math.odin
@@ -1642,6 +1642,28 @@ nextafter :: proc{
 	nextafter_f64, nextafter_f64le, nextafter_f64be,
 }
 
+signbit_f16 :: proc "contextless" (x: f16) -> bool {
+	return (transmute(u16)x)&(1<<15) != 0
+}
+signbit_f32 :: proc "contextless" (x: f32) -> bool {
+	return (transmute(u32)x)&(1<<31) != 0
+}
+signbit_f64 :: proc "contextless" (x: f64) -> bool {
+	return (transmute(u64)x)&(1<<63) != 0
+}
+signbit_f16le :: proc "contextless" (x: f16le) -> bool { return signbit_f16(f16(x)) }
+signbit_f32le :: proc "contextless" (x: f32le) -> bool { return signbit_f32(f32(x)) }
+signbit_f64le :: proc "contextless" (x: f64le) -> bool { return signbit_f64(f64(x)) }
+signbit_f16be :: proc "contextless" (x: f16be) -> bool { return signbit_f16(f16(x)) }
+signbit_f32be :: proc "contextless" (x: f32be) -> bool { return signbit_f32(f32(x)) }
+signbit_f64be :: proc "contextless" (x: f64be) -> bool { return signbit_f64(f64(x)) }
+
+signbit :: proc{
+	signbit_f16, signbit_f16le, signbit_f16be,
+	signbit_f32, signbit_f32le, signbit_f32be,
+	signbit_f64, signbit_f64le, signbit_f64be,
+}
+
 
 F16_DIG        :: 3
 F16_EPSILON    :: 0.00097656
diff --git a/core/math/math_gamma.odin b/core/math/math_gamma.odin
new file mode 100644
index 000000000..0a6188a9f
--- /dev/null
+++ b/core/math/math_gamma.odin
@@ -0,0 +1,226 @@
+package math
+
+// The original C code, the long comment, and the constants
+// below are from http://netlib.sandia.gov/cephes/cprob/gamma.c.
+//
+//      tgamma.c
+//
+//      Gamma function
+//
+// SYNOPSIS:
+//
+// double x, y, tgamma();
+// extern int signgam;
+//
+// y = tgamma( x );
+//
+// DESCRIPTION:
+//
+// Returns gamma function of the argument. The result is
+// correctly signed, and the sign (+1 or -1) is also
+// returned in a global (extern) variable named signgam.
+// This variable is also filled in by the logarithmic gamma
+// function lgamma().
+//
+// Arguments |x| <= 34 are reduced by recurrence and the function
+// approximated by a rational function of degree 6/7 in the
+// interval (2,3).  Large arguments are handled by Stirling's
+// formula. Large negative arguments are made positive using
+// a reflection formula.
+//
+// ACCURACY:
+//
+//                      Relative error:
+// arithmetic   domain     # trials      peak         rms
+//    DEC      -34, 34      10000       1.3e-16     2.5e-17
+//    IEEE    -170,-33      20000       2.3e-15     3.3e-16
+//    IEEE     -33,  33     20000       9.4e-16     2.2e-16
+//    IEEE      33, 171.6   20000       2.3e-15     3.2e-16
+//
+// Error for arguments outside the test range will be larger
+// owing to error amplification by the exponential function.
+//
+// Cephes Math Library Release 2.8:  June, 2000
+// Copyright 1984, 1987, 1989, 1992, 2000 by Stephen L. Moshier
+//
+// The readme file at http://netlib.sandia.gov/cephes/ says:
+//    Some software in this archive may be from the book _Methods and
+// Programs for Mathematical Functions_ (Prentice-Hall or Simon & Schuster
+// International, 1989) or from the Cephes Mathematical Library, a
+// commercial product. In either event, it is copyrighted by the author.
+// What you see here may be used freely but it comes with no support or
+// guarantee.
+//
+//   The two known misprints in the book are repaired here in the
+// source listings for the gamma function and the incomplete beta
+// integral.
+//
+//   Stephen L. Moshier
+//   moshier@na-net.ornl.gov
+
+// Gamma function computed by Stirling's formula.
+// The pair of results must be multiplied together to get the actual answer.
+// The multiplication is left to the caller so that, if careful, the caller can avoid
+// infinity for 172 <= x <= 180.
+// The polynomial is valid for 33 <= x <= 172; larger values are only used
+// in reciprocal and produce denormalized floats. The lower precision there
+// masks any imprecision in the polynomial.
+@(private="file")
+stirling :: proc "contextless" (x: f64) -> (f64, f64) {
+	@(static) gamS := [?]f64{
+		7.87311395793093628397e-04,
+		-2.29549961613378126380e-04,
+		-2.68132617805781232825e-03,
+		3.47222221605458667310e-03,
+		8.33333333333482257126e-02,
+	}
+	
+	if x > 200 {
+		return inf_f64(1), 1
+	}
+	SQRT_TWO_PI :: 2.506628274631000502417
+	MAX_STIRLING :: 143.01608
+	w := 1 / x
+	w = 1 + w*((((gamS[0]*w+gamS[1])*w+gamS[2])*w+gamS[3])*w+gamS[4])
+	y1 := exp(x)
+	y2 := 1.0
+	if x > MAX_STIRLING { // avoid pow() overflow
+		v := pow(x, 0.5*x-0.25)
+		y1, y2 = v, v/y1
+	} else {
+		y1 = pow(x, x-0.5) / y1
+	}
+	return y1, SQRT_TWO_PI * w * y2
+}
+
+gamma_f64 :: proc "contextless" (x: f64) -> f64 {
+	is_neg_int :: proc "contextless" (x: f64) -> bool {
+		if x < 0 {
+			_, xf := modf(x)
+			return xf == 0
+		}
+		return false
+	}
+	
+	@(static) gamP := [?]f64{
+		1.60119522476751861407e-04,
+		1.19135147006586384913e-03,
+		1.04213797561761569935e-02,
+		4.76367800457137231464e-02,
+		2.07448227648435975150e-01,
+		4.94214826801497100753e-01,
+		9.99999999999999996796e-01,
+	}
+	@(static) gamQ := [?]f64{
+		-2.31581873324120129819e-05,
+		5.39605580493303397842e-04,
+		-4.45641913851797240494e-03,
+		1.18139785222060435552e-02,
+		3.58236398605498653373e-02,
+		-2.34591795718243348568e-01,
+		7.14304917030273074085e-02,
+		1.00000000000000000320e+00,
+	}
+
+	
+	EULER :: 0.57721566490153286060651209008240243104215933593992 // A001620
+	
+	switch {
+	case is_neg_int(x) || is_inf(x, -1) || is_nan(x):
+		return nan_f64()
+	case is_inf(x, 1):
+		return inf_f64(1)
+	case x == 0:
+		if signbit(x) {
+			return inf_f64(-1)
+		}
+		return inf_f64(1)
+	}
+	
+	x := x
+	q := abs(x)
+	p := floor(q)
+	if q > 33 {
+		if x >= 0 {
+			y1, y2 := stirling(x)
+			return y1 * y2
+		}
+		// Note: x is negative but (checked above) not a negative integer,
+		// so x must be small enough to be in range for conversion to i64.
+		// If |x| were >= 2⁶³ it would have to be an integer.
+		signgam := 1
+		if ip := i64(p); ip&1 == 0 {
+			signgam = -1
+		}
+		z := q - p
+		if z > 0.5 {
+			p = p + 1
+			z = q - p
+		}
+		z = q * sin(PI*z)
+		if z == 0 {
+			return inf_f64(signgam)
+		}
+		sq1, sq2 := stirling(q)
+		absz := abs(z)
+		d := absz * sq1 * sq2
+		if is_inf(d, 0) {
+			z = PI / absz / sq1 / sq2
+		} else {
+			z = PI / d
+		}
+		return f64(signgam) * z
+	}
+
+	// Reduce argument
+	z := 1.0
+	for x >= 3 {
+		x = x - 1
+		z = z * x
+	}
+	for x < 0 {
+		if x > -1e-09 {
+			if x == 0 {
+				return inf_f64(1)
+			}
+			return z / ((1 + EULER*x) * x)
+		}
+		z = z / x
+		x = x + 1
+	}
+	for x < 2 {
+		if x < 1e-09 {
+			if x == 0 {
+				return inf_f64(1)
+			}
+			return z / ((1 + EULER*x) * x)
+		}
+		z = z / x
+		x = x + 1
+	}
+
+	if x == 2 {
+		return z
+	}
+
+	x = x - 2
+	p = (((((x*gamP[0]+gamP[1])*x+gamP[2])*x+gamP[3])*x+gamP[4])*x+gamP[5])*x + gamP[6]
+	q = ((((((x*gamQ[0]+gamQ[1])*x+gamQ[2])*x+gamQ[3])*x+gamQ[4])*x+gamQ[5])*x+gamQ[6])*x + gamQ[7]
+	return z * p / q
+}
+
+
+gamma_f16   :: proc "contextless" (x: f16)   -> f16   { return f16(gamma_f64(f64(x))) }
+gamma_f16le :: proc "contextless" (x: f16le) -> f16le { return f16le(gamma_f64(f64(x))) }
+gamma_f16be :: proc "contextless" (x: f16be) -> f16be { return f16be(gamma_f64(f64(x))) }
+gamma_f32   :: proc "contextless" (x: f32)   -> f32   { return f32(gamma_f64(f64(x))) }
+gamma_f32le :: proc "contextless" (x: f32le) -> f32le { return f32le(gamma_f64(f64(x))) }
+gamma_f32be :: proc "contextless" (x: f32be) -> f32be { return f32be(gamma_f64(f64(x))) }
+gamma_f64le :: proc "contextless" (x: f64le) -> f64le { return f64le(gamma_f64(f64(x))) }
+gamma_f64be :: proc "contextless" (x: f64be) -> f64be { return f64be(gamma_f64(f64(x))) }
+
+gamma :: proc{
+	gamma_f16, gamma_f16le, gamma_f16be,
+	gamma_f32, gamma_f32le, gamma_f32be,
+	gamma_f64, gamma_f64le, gamma_f64be,
+}
\ No newline at end of file

From 1b28226a6788d095c66925276c7a28041f8bb2de Mon Sep 17 00:00:00 2001
From: gingerBill <bill@gingerbill.org>
Date: Tue, 16 Nov 2021 15:32:32 +0000
Subject: [PATCH 10/38] Add `math.lgamma` based off FreeBSD's
 `/usr/src/lib/msun/src/e_lgamma_r.c`

---
 core/math/math_lgamma.odin | 361 +++++++++++++++++++++++++++++++++++++
 1 file changed, 361 insertions(+)
 create mode 100644 core/math/math_lgamma.odin

diff --git a/core/math/math_lgamma.odin b/core/math/math_lgamma.odin
new file mode 100644
index 000000000..e6cbdf6cd
--- /dev/null
+++ b/core/math/math_lgamma.odin
@@ -0,0 +1,361 @@
+package math
+
+// The original C code and the long comment below are
+// from FreeBSD's /usr/src/lib/msun/src/e_lgamma_r.c and
+// came with this notice. 
+//
+// ====================================================
+// Copyright (C) 1993 by Sun Microsystems, Inc. All rights reserved.
+//
+// Developed at SunPro, a Sun Microsystems, Inc. business.
+// Permission to use, copy, modify, and distribute this
+// software is freely granted, provided that this notice
+// is preserved.
+// ====================================================
+//
+// __ieee754_lgamma_r(x, signgamp)
+// Reentrant version of the logarithm of the Gamma function
+// with user provided pointer for the sign of Gamma(x).
+//
+// Method:
+//   1. Argument Reduction for 0 < x <= 8
+//      Since gamma(1+s)=s*gamma(s), for x in [0,8], we may
+//      reduce x to a number in [1.5,2.5] by
+//              lgamma(1+s) = log(s) + lgamma(s)
+//      for example,
+//              lgamma(7.3) = log(6.3) + lgamma(6.3)
+//                          = log(6.3*5.3) + lgamma(5.3)
+//                          = log(6.3*5.3*4.3*3.3*2.3) + lgamma(2.3)
+//   2. Polynomial approximation of lgamma around its
+//      minimum (ymin=1.461632144968362245) to maintain monotonicity.
+//      On [ymin-0.23, ymin+0.27] (i.e., [1.23164,1.73163]), use
+//              Let z = x-ymin;
+//              lgamma(x) = -1.214862905358496078218 + z**2*poly(z)
+//              poly(z) is a 14 degree polynomial.
+//   2. Rational approximation in the primary interval [2,3]
+//      We use the following approximation:
+//              s = x-2.0;
+//              lgamma(x) = 0.5*s + s*P(s)/Q(s)
+//      with accuracy
+//              |P/Q - (lgamma(x)-0.5s)| < 2**-61.71
+//      Our algorithms are based on the following observation
+//
+//                             zeta(2)-1    2    zeta(3)-1    3
+// lgamma(2+s) = s*(1-Euler) + --------- * s  -  --------- * s  + ...
+//                                 2                 3
+//
+//      where Euler = 0.5772156649... is the Euler constant, which
+//      is very close to 0.5.
+//
+//   3. For x>=8, we have
+//      lgamma(x)~(x-0.5)log(x)-x+0.5*log(2pi)+1/(12x)-1/(360x**3)+....
+//      (better formula:
+//         lgamma(x)~(x-0.5)*(log(x)-1)-.5*(log(2pi)-1) + ...)
+//      Let z = 1/x, then we approximation
+//              f(z) = lgamma(x) - (x-0.5)(log(x)-1)
+//      by
+//                                  3       5             11
+//              w = w0 + w1*z + w2*z  + w3*z  + ... + w6*z
+//      where
+//              |w - f(z)| < 2**-58.74
+//
+//   4. For negative x, since (G is gamma function)
+//              -x*G(-x)*G(x) = pi/sin(pi*x),
+//      we have
+//              G(x) = pi/(sin(pi*x)*(-x)*G(-x))
+//      since G(-x) is positive, sign(G(x)) = sign(sin(pi*x)) for x<0
+//      Hence, for x<0, signgam = sign(sin(pi*x)) and
+//              lgamma(x) = log(|Gamma(x)|)
+//                        = log(pi/(|x*sin(pi*x)|)) - lgamma(-x);
+//      Note: one should avoid computing pi*(-x) directly in the
+//            computation of sin(pi*(-x)).
+//
+//   5. Special Cases
+//              lgamma(2+s) ~ s*(1-Euler) for tiny s
+//              lgamma(1)=lgamma(2)=0
+//              lgamma(x) ~ -log(x) for tiny x
+//              lgamma(0) = lgamma(inf) = inf
+//              lgamma(-integer) = +-inf
+//
+//
+
+
+lgamma_f64 :: proc "contextless" (x: f64) -> (lgamma: f64, sign: int) {
+	sin_pi :: proc "contextless" (x: f64) -> f64 {
+		if x < 0.25 {
+			return -sin(PI * x)
+		}
+		x := x
+
+		// argument reduction
+		z := floor(x)
+		n: int
+		if z != x { // inexact
+			x = mod(x, 2)
+			n = int(x * 4)
+		} else {
+			if x >= TWO_53 { // x must be even
+				x = 0
+				n = 0
+			} else {
+				if x < TWO_52 {
+					z = x + TWO_52 // exact
+				}
+				n = int(1 & transmute(u64)z)
+				x = f64(n)
+				n <<= 2
+			}
+		}
+		switch n {
+		case 0:
+			x = sin(PI * x)
+		case 1, 2:
+			x = cos(PI * (0.5 - x))
+		case 3, 4:
+			x = sin(PI * (1 - x))
+		case 5, 6:
+			x = -cos(PI * (x - 1.5))
+		case:
+			x = sin(PI * (x - 2))
+		}
+		return -x
+	}
+	
+	@static lgamA := [?]f64{
+		0h3FB3C467E37DB0C8,
+		0h3FD4A34CC4A60FAD,
+		0h3FB13E001A5562A7,
+		0h3F951322AC92547B,
+		0h3F7E404FB68FEFE8,
+		0h3F67ADD8CCB7926B,
+		0h3F538A94116F3F5D,
+		0h3F40B6C689B99C00,
+		0h3F2CF2ECED10E54D,
+		0h3F1C5088987DFB07,
+		0h3EFA7074428CFA52,
+		0h3F07858E90A45837,
+	}
+	@static lgamR := [?]f64{
+		1.0,
+		0h3FF645A762C4AB74,
+		0h3FE71A1893D3DCDC,
+		0h3FC601EDCCFBDF27,
+		0h3F9317EA742ED475,
+		0h3F497DDACA41A95B,
+		0h3EDEBAF7A5B38140,
+	}
+	@static lgamS := [?]f64{
+		0hBFB3C467E37DB0C8,
+		0h3FCB848B36E20878,
+		0h3FD4D98F4F139F59,
+		0h3FC2BB9CBEE5F2F7,
+		0h3F9B481C7E939961,
+		0h3F5E26B67368F239,
+		0h3F00BFECDD17E945,
+	}
+	@static lgamT := [?]f64{
+		0h3FDEF72BC8EE38A2,
+		0hBFC2E4278DC6C509,
+		0h3FB08B4294D5419B,
+		0hBFA0C9A8DF35B713,
+		0h3F9266E7970AF9EC,
+		0hBF851F9FBA91EC6A,
+		0h3F78FCE0E370E344,
+		0hBF6E2EFFB3E914D7,
+		0h3F6282D32E15C915,
+		0hBF56FE8EBF2D1AF1,
+		0h3F4CDF0CEF61A8E9,
+		0hBF41A6109C73E0EC,
+		0h3F34AF6D6C0EBBF7,
+		0hBF347F24ECC38C38,
+		0h3F35FD3EE8C2D3F4,
+	}
+	@static lgamU := [?]f64{
+		0hBFB3C467E37DB0C8,
+		0h3FE4401E8B005DFF,
+		0h3FF7475CD119BD6F,
+		0h3FEF497644EA8450,
+		0h3FCD4EAEF6010924,
+		0h3F8B678BBF2BAB09,
+	}
+	@static lgamV := [?]f64{
+		1.0,
+		0h4003A5D7C2BD619C,
+		0h40010725A42B18F5,
+		0h3FE89DFBE45050AF,
+		0h3FBAAE55D6537C88,
+		0h3F6A5ABB57D0CF61,
+	}
+	@static lgamW := [?]f64{
+		0h3FDACFE390C97D69,
+		0h3FB555555555553B,
+		0hBF66C16C16B02E5C,
+		0h3F4A019F98CF38B6,
+		0hBF4380CB8C0FE741,
+		0h3F4B67BA4CDAD5D1,
+		0hBF5AB89D0B9E43E4,
+	}
+
+	
+	Y_MIN  :: 1.461632144968362245
+	TWO_52 :: 0h4330000000000000 // ~4.5036e+15
+	TWO_53  :: 0h4340000000000000 // ~9.0072e+15
+	TWO_58 :: 0h4390000000000000 // ~2.8823e+17
+	TINY   :: 0h3b90000000000000 // ~8.47033e-22
+	Tc     :: 0h3FF762D86356BE3F
+	Tf     :: 0hBFBF19B9BCC38A42
+	Tt     :: 0hBC50C7CAA48A971F
+	
+	// special cases
+	sign = 1
+	switch {
+	case is_nan(x):
+		lgamma = x
+		return
+	case is_inf(x):
+		lgamma = x
+		return
+	case x == 0:
+		lgamma = inf_f64(1)
+		return
+	}
+
+	x := x
+	neg := false
+	if x < 0 {
+		x = -x
+		neg = true
+	}
+
+	if x < TINY { // if |x| < 2**-70, return -log(|x|)
+		if neg {
+			sign = -1
+		}
+		lgamma = -ln(x)
+		return
+	}
+	nadj: f64
+	if neg {
+		if x >= TWO_52 { // |x| >= 2**52, must be -integer
+			lgamma = inf_f64(1)
+			return
+		}
+		t := sin_pi(x)
+		if t == 0 {
+			lgamma = inf_f64(1) // -integer
+			return
+		}
+		nadj = ln(PI / abs(t*x))
+		if t < 0 {
+			sign = -1
+		}
+	}
+
+	switch {
+	case x == 1 || x == 2: // purge off 1 and 2
+		lgamma = 0
+		return
+	case x < 2: // use lgamma(x) = lgamma(x+1) - log(x)
+		y: f64
+		i: int
+		if x <= 0.9 {
+			lgamma = -ln(x)
+			switch {
+			case x >= (Y_MIN - 1 + 0.27): // 0.7316 <= x <=  0.9
+				y = 1 - x
+				i = 0
+			case x >= (Y_MIN - 1 - 0.27): // 0.2316 <= x < 0.7316
+				y = x - (Tc - 1)
+				i = 1
+			case: // 0 < x < 0.2316
+				y = x
+				i = 2
+			}
+		} else {
+			lgamma = 0
+			switch {
+			case x >= (Y_MIN + 0.27): // 1.7316 <= x < 2
+				y = 2 - x
+				i = 0
+			case x >= (Y_MIN - 0.27): // 1.2316 <= x < 1.7316
+				y = x - Tc
+				i = 1
+			case: // 0.9 < x < 1.2316
+				y = x - 1
+				i = 2
+			}
+		}
+		switch i {
+		case 0:
+			z := y * y
+			p1 := lgamA[0] + z*(lgamA[2]+z*(lgamA[4]+z*(lgamA[6]+z*(lgamA[8]+z*lgamA[10]))))
+			p2 := z * (lgamA[1] + z*(+lgamA[3]+z*(lgamA[5]+z*(lgamA[7]+z*(lgamA[9]+z*lgamA[11])))))
+			p := y*p1 + p2
+			lgamma += (p - 0.5*y)
+		case 1:
+			z := y * y
+			w := z * y
+			p1 := lgamT[0] + w*(lgamT[3]+w*(lgamT[6]+w*(lgamT[9]+w*lgamT[12]))) // parallel comp
+			p2 := lgamT[1] + w*(lgamT[4]+w*(lgamT[7]+w*(lgamT[10]+w*lgamT[13])))
+			p3 := lgamT[2] + w*(lgamT[5]+w*(lgamT[8]+w*(lgamT[11]+w*lgamT[14])))
+			p := z*p1 - (Tt - w*(p2+y*p3))
+			lgamma += (Tf + p)
+		case 2:
+			p1 := y * (lgamU[0] + y*(lgamU[1]+y*(lgamU[2]+y*(lgamU[3]+y*(lgamU[4]+y*lgamU[5])))))
+			p2 := 1 + y*(lgamV[1]+y*(lgamV[2]+y*(lgamV[3]+y*(lgamV[4]+y*lgamV[5]))))
+			lgamma += (-0.5*y + p1/p2)
+		}
+	case x < 8: // 2 <= x < 8
+		i := int(x)
+		y := x - f64(i)
+		p := y * (lgamS[0] + y*(lgamS[1]+y*(lgamS[2]+y*(lgamS[3]+y*(lgamS[4]+y*(lgamS[5]+y*lgamS[6]))))))
+		q := 1 + y*(lgamR[1]+y*(lgamR[2]+y*(lgamR[3]+y*(lgamR[4]+y*(lgamR[5]+y*lgamR[6])))))
+		lgamma = 0.5*y + p/q
+		z := 1.0 // lgamma(1+s) = ln(s) + lgamma(s)
+		switch i {
+		case 7:
+			z *= (y + 6)
+			fallthrough
+		case 6:
+			z *= (y + 5)
+			fallthrough
+		case 5:
+			z *= (y + 4)
+			fallthrough
+		case 4:
+			z *= (y + 3)
+			fallthrough
+		case 3:
+			z *= (y + 2)
+			lgamma += ln(z)
+		}
+	case x < TWO_58: // 8 <= x < 2**58
+		t := ln(x)
+		z := 1 / x
+		y := z * z
+		w := lgamW[0] + z*(lgamW[1]+y*(lgamW[2]+y*(lgamW[3]+y*(lgamW[4]+y*(lgamW[5]+y*lgamW[6])))))
+		lgamma = (x-0.5)*(t-1) + w
+	case: // 2**58 <= x <= Inf
+		lgamma = x * (ln(x) - 1)
+	}
+	if neg {
+		lgamma = nadj - lgamma
+	}
+	return
+}
+
+
+lgamma_f16 :: proc "contextless" (x: f16) -> (lgamma: f16, sign: int) { r, s := lgamma_f64(f64(x)); return f16(r), s }
+lgamma_f32 :: proc "contextless" (x: f32) -> (lgamma: f32, sign: int) { r, s := lgamma_f64(f64(x)); return f32(r), s }
+lgamma_f16le :: proc "contextless" (x: f16le) -> (lgamma: f16le, sign: int) { r, s := lgamma_f64(f64(x)); return f16le(r), s }
+lgamma_f16be :: proc "contextless" (x: f16be) -> (lgamma: f16be, sign: int) { r, s := lgamma_f64(f64(x)); return f16be(r), s }
+lgamma_f32le :: proc "contextless" (x: f32le) -> (lgamma: f32le, sign: int) { r, s := lgamma_f64(f64(x)); return f32le(r), s }
+lgamma_f32be :: proc "contextless" (x: f32be) -> (lgamma: f32be, sign: int) { r, s := lgamma_f64(f64(x)); return f32be(r), s }
+lgamma_f64le :: proc "contextless" (x: f64le) -> (lgamma: f64le, sign: int) { r, s := lgamma_f64(f64(x)); return f64le(r), s }
+lgamma_f64be :: proc "contextless" (x: f64be) -> (lgamma: f64be, sign: int) { r, s := lgamma_f64(f64(x)); return f64be(r), s }
+
+lgamma :: proc{
+	lgamma_f16, lgamma_f16le, lgamma_f16be,
+	lgamma_f32, lgamma_f32le, lgamma_f32be,
+	lgamma_f64, lgamma_f64le, lgamma_f64be,
+}
\ No newline at end of file

From bb7703fcec792904621bc0fc023abbb13af888a3 Mon Sep 17 00:00:00 2001
From: gingerBill <bill@gingerbill.org>
Date: Tue, 16 Nov 2021 16:08:20 +0000
Subject: [PATCH 11/38] Improve `ptr_map_hash_key`

---
 src/ptr_map.cpp | 12 +++++++-----
 1 file changed, 7 insertions(+), 5 deletions(-)

diff --git a/src/ptr_map.cpp b/src/ptr_map.cpp
index 3d6be1d44..43e793b8a 100644
--- a/src/ptr_map.cpp
+++ b/src/ptr_map.cpp
@@ -28,11 +28,13 @@ struct PtrMap {
 
 u32 ptr_map_hash_key(uintptr key) {
 #if defined(GB_ARCH_64_BIT)
-	u64 x = (u64)key;
-	u8 count = (u8)(x >> 59);
-	x ^= x >> (5 + count);
-	x *= 12605985483714917081ull;
-	return (u32)(x ^ (x >> 43));
+	key = (~key) + (key << 21);
+	key = key ^ (key >> 24);
+	key = (key + (key << 3)) + (key << 8);
+	key = key ^ (key >> 14);
+	key = (key + (key << 2)) + (key << 4);
+	key = key ^ (key << 28);
+	return cast(u32)key;
 #elif defined(GB_ARCH_32_BIT)
 	u32 state = ((u32)key) * 747796405u + 2891336453u;
 	u32 word = ((state >> ((state >> 28u) + 4u)) ^ state) * 277803737u;

From f09638318f4e2ef0966ed4c074026ba1a7c0cee8 Mon Sep 17 00:00:00 2001
From: gingerBill <bill@gingerbill.org>
Date: Tue, 16 Nov 2021 21:19:08 +0000
Subject: [PATCH 12/38] Add support for darwin to `core:c/libc`

---
 core/c/libc/complex.odin |  2 ++
 core/c/libc/ctype.odin   |  2 ++
 core/c/libc/errno.odin   | 16 ++++++++++++++++
 core/c/libc/math.odin    |  2 ++
 core/c/libc/setjmp.odin  |  3 ++-
 core/c/libc/signal.odin  | 17 ++++++++++++++++-
 core/c/libc/stdio.odin   | 34 +++++++++++++++++++++++++++++++++-
 core/c/libc/stdlib.odin  | 20 +++++++++++++++++++-
 core/c/libc/string.odin  |  2 ++
 core/c/libc/threads.odin |  5 +++++
 core/c/libc/time.odin    |  8 +++++---
 core/c/libc/uchar.odin   |  2 ++
 core/c/libc/wchar.odin   |  2 ++
 core/c/libc/wctype.odin  |  9 ++++++++-
 14 files changed, 116 insertions(+), 8 deletions(-)

diff --git a/core/c/libc/complex.odin b/core/c/libc/complex.odin
index e91d39023..62b28f0cd 100644
--- a/core/c/libc/complex.odin
+++ b/core/c/libc/complex.odin
@@ -4,6 +4,8 @@ package libc
 
 when ODIN_OS == "windows" {
 	foreign import libc "system:libucrt.lib"
+} else when ODIN_OS == "darwin" {
+	foreign import libc "system:System.framework"
 } else {
 	foreign import libc "system:c"
 }
diff --git a/core/c/libc/ctype.odin b/core/c/libc/ctype.odin
index 9e4b31208..05d9dcd37 100644
--- a/core/c/libc/ctype.odin
+++ b/core/c/libc/ctype.odin
@@ -2,6 +2,8 @@ package libc
 
 when ODIN_OS == "windows" {
 	foreign import libc "system:libucrt.lib"
+} else when ODIN_OS == "darwin" {
+	foreign import libc "system:System.framework"
 } else {
 	foreign import libc "system:c"
 }
diff --git a/core/c/libc/errno.odin b/core/c/libc/errno.odin
index dd17ce515..8ebe2f734 100644
--- a/core/c/libc/errno.odin
+++ b/core/c/libc/errno.odin
@@ -4,6 +4,8 @@ package libc
 
 when ODIN_OS == "windows" {
 	foreign import libc "system:libucrt.lib"
+} else when ODIN_OS == "darwin" {
+	foreign import libc "system:System.framework"
 } else {
 	foreign import libc "system:c"
 }
@@ -38,6 +40,20 @@ when ODIN_OS == "windows" {
 	ERANGE :: 34
 }
 
+when ODIN_OS == "darwin" {
+	@(private="file")
+	@(default_calling_convention="c")
+	foreign libc {
+		@(link_name="__error")
+		_get_errno :: proc() -> ^int ---
+	}
+
+	// Unknown
+	EDOM   :: 33
+	EILSEQ :: 92
+	ERANGE :: 34
+}
+
 // Odin has no way to make an identifier "errno" behave as a function call to
 // read the value, or to produce an lvalue such that you can assign a different
 // error value to errno. To work around this, just expose it as a function like
diff --git a/core/c/libc/math.odin b/core/c/libc/math.odin
index c1c51fa25..ee702b82e 100644
--- a/core/c/libc/math.odin
+++ b/core/c/libc/math.odin
@@ -6,6 +6,8 @@ import "core:intrinsics"
 
 when ODIN_OS == "windows" {
 	foreign import libc "system:libucrt.lib"
+} else when ODIN_OS == "darwin" {
+	foreign import libc "system:System.framework"
 } else {
 	foreign import libc "system:c"
 }
diff --git a/core/c/libc/setjmp.odin b/core/c/libc/setjmp.odin
index 4f3ae3aa3..dcd4a9c64 100644
--- a/core/c/libc/setjmp.odin
+++ b/core/c/libc/setjmp.odin
@@ -4,10 +4,11 @@ package libc
 
 when ODIN_OS == "windows" {
 	foreign import libc "system:libucrt.lib"
+} else when ODIN_OS == "darwin" {
+	foreign import libc "system:System.framework"
 } else {
 	foreign import libc "system:c"
 }
-
 when ODIN_OS == "windows" {
 	@(default_calling_convention="c")
 	foreign libc {
diff --git a/core/c/libc/signal.odin b/core/c/libc/signal.odin
index ad007287e..e1044dc02 100644
--- a/core/c/libc/signal.odin
+++ b/core/c/libc/signal.odin
@@ -4,6 +4,8 @@ package libc
 
 when ODIN_OS == "windows" {
 	foreign import libc "system:libucrt.lib"
+} else when ODIN_OS == "darwin" {
+	foreign import libc "system:System.framework"
 } else {
 	foreign import libc "system:c"
 }
@@ -32,7 +34,20 @@ when ODIN_OS == "windows" {
 	SIGTERM :: 15
 }
 
-when ODIN_OS == "linux" || ODIN_OS == "freebsd" || ODIN_OS == "darwin" {
+when ODIN_OS == "linux" || ODIN_OS == "freebsd" {
+	SIG_ERR  :: rawptr(~uintptr(0))
+	SIG_DFL  :: rawptr(uintptr(0))
+	SIG_IGN  :: rawptr(uintptr(1)) 
+
+	SIGABRT  :: 6
+	SIGFPE   :: 8
+	SIGILL   :: 4
+	SIGINT   :: 2
+	SIGSEGV  :: 11
+	SIGTERM  :: 15
+}
+
+when ODIN_OS == "darwin" {
 	SIG_ERR  :: rawptr(~uintptr(0))
 	SIG_DFL  :: rawptr(uintptr(0))
 	SIG_IGN  :: rawptr(uintptr(1)) 
diff --git a/core/c/libc/stdio.odin b/core/c/libc/stdio.odin
index 89891f82e..4a39c22e9 100644
--- a/core/c/libc/stdio.odin
+++ b/core/c/libc/stdio.odin
@@ -2,6 +2,8 @@ package libc
 
 when ODIN_OS == "windows" {
 	foreign import libc "system:libucrt.lib"
+} else when ODIN_OS == "darwin" {
+	foreign import libc "system:System.framework"
 } else {
 	foreign import libc "system:c"
 }
@@ -67,7 +69,7 @@ when ODIN_OS == "linux" {
 	SEEK_CUR      :: 1
 	SEEK_END      :: 2
 
-	TMP_MAX       :: 10000
+	TMP_MAX       :: 308915776
 
 	foreign libc {
 		stderr: ^FILE
@@ -76,6 +78,36 @@ when ODIN_OS == "linux" {
 	}
 }
 
+when ODIN_OS == "darwin" {
+	fpos_t :: distinct i64
+	
+	_IOFBF        :: 0
+	_IOLBF        :: 1
+	_IONBF        :: 2
+
+	BUFSIZ        :: 1024
+
+	EOF           :: int(-1)
+
+	FOPEN_MAX     :: 20
+
+	FILENAME_MAX  :: 1024
+
+	L_tmpnam      :: 1024
+
+	SEEK_SET      :: 0
+	SEEK_CUR      :: 1
+	SEEK_END      :: 2
+
+	TMP_MAX       :: 308915776
+
+	foreign libc {
+		@(link_name="__stderrp") stderr: ^FILE
+		@(link_name="__stdinp")  stdin:  ^FILE
+		@(link_name="__stdoutp") stdout: ^FILE
+	}
+}
+
 @(default_calling_convention="c")
 foreign libc {
 	// 7.21.4 Operations on files
diff --git a/core/c/libc/stdlib.odin b/core/c/libc/stdlib.odin
index 0e24b0d5c..b368c0cee 100644
--- a/core/c/libc/stdlib.odin
+++ b/core/c/libc/stdlib.odin
@@ -4,6 +4,8 @@ package libc
 
 when ODIN_OS == "windows" {
 	foreign import libc "system:libucrt.lib"
+} else when ODIN_OS == "darwin" {
+	foreign import libc "system:System.framework"
 } else {
 	foreign import libc "system:c"
 }
@@ -33,7 +35,23 @@ when ODIN_OS == "linux" {
 	}
 
 	MB_CUR_MAX :: #force_inline proc() -> size_t {
-		return __ctype_get_mb_cur_max()
+		return size_t(__ctype_get_mb_cur_max())
+	}
+}
+
+
+when ODIN_OS == "darwin" {
+	RAND_MAX :: 0x7fffffff
+
+	// GLIBC and MUSL only
+	@(private="file")
+	@(default_calling_convention="c")
+	foreign libc {
+		___mb_cur_max :: proc() -> int ---
+	}
+
+	MB_CUR_MAX :: #force_inline proc() -> size_t {
+		return size_t(___mb_cur_max())
 	}
 }
 
diff --git a/core/c/libc/string.odin b/core/c/libc/string.odin
index cd577237c..c91124dcb 100644
--- a/core/c/libc/string.odin
+++ b/core/c/libc/string.odin
@@ -6,6 +6,8 @@ import "core:runtime"
 
 when ODIN_OS == "windows" {
 	foreign import libc "system:libucrt.lib"
+} else when ODIN_OS == "darwin" {
+	foreign import libc "system:System.framework"
 } else {
 	foreign import libc "system:c"
 }
diff --git a/core/c/libc/threads.odin b/core/c/libc/threads.odin
index 630216d06..ad305b517 100644
--- a/core/c/libc/threads.odin
+++ b/core/c/libc/threads.odin
@@ -136,3 +136,8 @@ when ODIN_OS == "linux" {
 		tss_set       :: proc(key: tss_t, val: rawptr) -> int ---
 	}
 }
+
+
+when ODIN_OS == "darwin" {
+	// TODO: find out what this is meant to be!
+}
diff --git a/core/c/libc/time.odin b/core/c/libc/time.odin
index 7cc677bff..96e80e216 100644
--- a/core/c/libc/time.odin
+++ b/core/c/libc/time.odin
@@ -4,6 +4,8 @@ package libc
 
 when ODIN_OS == "windows" {
 	foreign import libc "system:libucrt.lib"
+} else when ODIN_OS == "darwin" {
+	foreign import libc "system:System.framework"
 } else {
 	foreign import libc "system:c"
 }
@@ -43,7 +45,7 @@ when ODIN_OS == "windows" {
 	}
 }
 
-when ODIN_OS == "linux" || ODIN_OS == "freebsd" {
+when ODIN_OS == "linux" || ODIN_OS == "freebsd" || ODIN_OS == "darwin" {
 	@(default_calling_convention="c")
 	foreign libc {
 		// 7.27.2 Time manipulation functions
@@ -75,7 +77,7 @@ when ODIN_OS == "linux" || ODIN_OS == "freebsd" {
 
 	tm :: struct {
 		tm_sec, tm_min, tm_hour, tm_mday, tm_mon, tm_year, tm_wday, tm_yday, tm_isdst: int,
-		_: long,
-		_: rawptr,
+		tm_gmtoff: long,
+		tm_zone: rawptr,
 	}
 }
diff --git a/core/c/libc/uchar.odin b/core/c/libc/uchar.odin
index 978d9b7bf..e49c29e51 100644
--- a/core/c/libc/uchar.odin
+++ b/core/c/libc/uchar.odin
@@ -4,6 +4,8 @@ package libc
 
 when ODIN_OS == "windows" {
 	foreign import libc "system:libucrt.lib"
+} else when ODIN_OS == "darwin" {
+	foreign import libc "system:System.framework"
 } else {
 	foreign import libc "system:c"
 }
diff --git a/core/c/libc/wchar.odin b/core/c/libc/wchar.odin
index d88a49dd9..fc206e494 100644
--- a/core/c/libc/wchar.odin
+++ b/core/c/libc/wchar.odin
@@ -4,6 +4,8 @@ package libc
 
 when ODIN_OS == "windows" {
 	foreign import libc "system:libucrt.lib"
+} else when ODIN_OS == "darwin" {
+	foreign import libc "system:System.framework"
 } else {
 	foreign import libc "system:c"
 }
diff --git a/core/c/libc/wctype.odin b/core/c/libc/wctype.odin
index 24af30c97..47f17e0b4 100644
--- a/core/c/libc/wctype.odin
+++ b/core/c/libc/wctype.odin
@@ -4,6 +4,8 @@ package libc
 
 when ODIN_OS == "windows" {
 	foreign import libc "system:libucrt.lib"
+} else when ODIN_OS == "darwin" {
+	foreign import libc "system:System.framework"
 } else {
 	foreign import libc "system:c"
 }
@@ -14,10 +16,15 @@ when ODIN_OS == "windows" {
 }
 
 when ODIN_OS == "linux" {
-	wctrans_t :: distinct rawptr
+	wctrans_t :: distinct intptr_t
 	wctype_t  :: distinct ulong
 }
 
+when ODIN_OS == "darwin" {
+	wctrans_t :: distinct int
+	wctype_t  :: distinct u32
+}
+
 @(default_calling_convention="c")
 foreign libc {
 	// 7.30.2.1 Wide character classification functions

From e8775250730b78cdaac36e90decca473081978d0 Mon Sep 17 00:00:00 2001
From: gingerBill <bill@gingerbill.org>
Date: Wed, 17 Nov 2021 10:40:55 +0000
Subject: [PATCH 13/38] Keep `-vet` happy for -no-crt and wasm targets

---
 core/runtime/procs.odin | 2 --
 1 file changed, 2 deletions(-)

diff --git a/core/runtime/procs.odin b/core/runtime/procs.odin
index fe37c7e7d..961f6376f 100644
--- a/core/runtime/procs.odin
+++ b/core/runtime/procs.odin
@@ -42,7 +42,6 @@ when ODIN_NO_CRT && ODIN_OS == "windows" {
 	memmove :: proc "c" (dst, src: rawptr, len: int) -> rawptr {
 		if dst != src {
 			d, s := ([^]byte)(dst), ([^]byte)(src)
-			d_end, s_end := d[len:], s[len:]
 			for i := len-1; i >= 0; i -= 1 {
 				d[i] = s[i]
 			}
@@ -54,7 +53,6 @@ when ODIN_NO_CRT && ODIN_OS == "windows" {
 	memcpy :: proc "c" (dst, src: rawptr, len: int) -> rawptr {
 		if dst != src {
 			d, s := ([^]byte)(dst), ([^]byte)(src)
-			d_end, s_end := d[len:], s[len:]
 			for i := len-1; i >= 0; i -= 1 {
 				d[i] = s[i]
 			}

From 9be0d18e5df63895e66782bb07484ee242e7028c Mon Sep 17 00:00:00 2001
From: gingerBill <bill@gingerbill.org>
Date: Wed, 17 Nov 2021 11:02:11 +0000
Subject: [PATCH 14/38] Correct `x in ptr` logic

---
 src/llvm_backend_expr.cpp | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/src/llvm_backend_expr.cpp b/src/llvm_backend_expr.cpp
index 7f162856c..a23d60894 100644
--- a/src/llvm_backend_expr.cpp
+++ b/src/llvm_backend_expr.cpp
@@ -1369,7 +1369,7 @@ lbValue lb_build_binary_expr(lbProcedure *p, Ast *expr) {
 			Type *rt = base_type(right.type);
 			if (is_type_pointer(rt)) {
 				right = lb_emit_load(p, right);
-				rt = type_deref(rt);
+				rt = base_type(type_deref(rt));
 			}
 
 			switch (rt->kind) {

From d1e76ee4f299fa2a47306c3dc8a4929abfdd4886 Mon Sep 17 00:00:00 2001
From: Yawning Angel <yawning@schwanenlied.me>
Date: Sat, 6 Nov 2021 02:36:30 +0000
Subject: [PATCH 15/38] core/crypto: Add constant-time memory comparison
 routines

Using a constant-time comparison is required when comparing things like
MACs, password digests, and etc to avoid exposing sensitive data via
trivial timing attacks.

These routines could also live under core:mem, but they are somewhat
specialized, and are likely only useful for cryptographic applications.
---
 core/crypto/crypto.odin | 41 +++++++++++++++++++++++++++++++++++++++++
 1 file changed, 41 insertions(+)
 create mode 100644 core/crypto/crypto.odin

diff --git a/core/crypto/crypto.odin b/core/crypto/crypto.odin
new file mode 100644
index 000000000..ddcc5d367
--- /dev/null
+++ b/core/crypto/crypto.odin
@@ -0,0 +1,41 @@
+package crypto
+
+import "core:mem"
+
+// compare_constant_time returns 1 iff a and b are equal, 0 otherwise.
+//
+// The execution time of this routine is constant regardless of the contents
+// of the slices being compared, as long as the length of the slices is equal.
+// If the length of the two slices is different, it will early-return 0.
+compare_constant_time :: proc "contextless" (a, b: []byte) -> int {
+	// If the length of the slices is different, early return.
+	//
+	// This leaks the fact that the slices have a different length,
+	// but the routine is primarily intended for comparing things
+	// like MACS and password digests.
+	n := len(a)
+	if n != len(b) {
+		return 0
+	}
+
+	return compare_byte_ptrs_constant_time(raw_data(a), raw_data(b), n)
+}
+
+// compare_byte_ptrs_constant_time returns 1 iff the bytes pointed to by
+// a and b are equal, 0 otherwise.
+//
+// The execution time of this routine is constant regardless of the
+// contents of the memory being compared.
+compare_byte_ptrs_constant_time :: proc "contextless" (a, b: ^byte, n: int) -> int {
+	x := mem.slice_ptr(a, n)
+	y := mem.slice_ptr(b, n)
+
+	v: byte
+	for i in 0..<n {
+		v |= x[i] ~ y[i]
+	}
+
+	// After the loop, v == 0 iff a == b.  The subtraction will underflow
+	// iff v == 0, setting the sign-bit, which gets returned.
+	return int((u32(v)-1) >> 31)
+}

From 1a7a6a9116c7d9ed0e9ced208d0373ea62ad46c3 Mon Sep 17 00:00:00 2001
From: Yawning Angel <yawning@schwanenlied.me>
Date: Sat, 6 Nov 2021 04:21:24 +0000
Subject: [PATCH 16/38] core/crypto: Add x25519

This package implements the X25519 key agreement scheme as specified in
RFC 7748, using routines taken from fiat-crypto and Monocypher.
---
 core/crypto/_fiat/README.md                   |  35 +
 core/crypto/_fiat/fiat.odin                   |  24 +
 core/crypto/_fiat/field_curve25519/field.odin | 138 ++++
 .../_fiat/field_curve25519/field51.odin       | 616 ++++++++++++++++++
 core/crypto/x25519/x25519.odin                | 126 ++++
 tests/core/crypto/test_core_crypto.odin       |   5 +
 .../core/crypto/test_core_crypto_modern.odin  |  95 +++
 7 files changed, 1039 insertions(+)
 create mode 100644 core/crypto/_fiat/README.md
 create mode 100644 core/crypto/_fiat/fiat.odin
 create mode 100644 core/crypto/_fiat/field_curve25519/field.odin
 create mode 100644 core/crypto/_fiat/field_curve25519/field51.odin
 create mode 100644 core/crypto/x25519/x25519.odin
 create mode 100644 tests/core/crypto/test_core_crypto_modern.odin

diff --git a/core/crypto/_fiat/README.md b/core/crypto/_fiat/README.md
new file mode 100644
index 000000000..cd510d442
--- /dev/null
+++ b/core/crypto/_fiat/README.md
@@ -0,0 +1,35 @@
+# fiat
+
+This package contains low level arithmetic required to implement certain
+cryptographic primitives, ported from the [fiat-crypto project][1]
+along with some higher-level helpers.
+
+## Notes
+
+fiat-crypto gives the choice of 3 licenses for derived works.  The 1-Clause
+BSD license is chosen as it is compatible with Odin's existing licensing.
+
+The routines are intended to be timing-safe, as long as the underlying
+integer arithmetic is constant time.  This is true on most systems commonly
+used today, with the notable exception of WASM.
+
+While fiat-crypto provides both output targeting both 32-bit and 64-bit
+architectures, only the 64-bit versions were used, as 32-bit architectures
+are becoming increasingly uncommon and irrelevant.
+
+With the current Odin syntax, the Go output is trivially ported in most
+cases and was used as the basis of the port.
+
+In the future, it would be better to auto-generate Odin either directly
+by adding an appropriate code-gen backend written in Coq, or perhaps by
+parsing the JSON output.
+
+As this is a port rather than autogenerated output, none of fiat-crypto's
+formal verification guarantees apply, unless it is possible to prove binary
+equivalence.
+
+For the most part, alterations to the base fiat-crypto generated code was
+kept to a minimum, to aid auditability.  This results in a somewhat
+ideosyncratic style, and in some cases minor performance penalties.
+
+[1]: https://github.com/mit-plv/fiat-crypto
diff --git a/core/crypto/_fiat/fiat.odin b/core/crypto/_fiat/fiat.odin
new file mode 100644
index 000000000..ae9727149
--- /dev/null
+++ b/core/crypto/_fiat/fiat.odin
@@ -0,0 +1,24 @@
+package fiat
+
+// This package provides various helpers and types common to all of the
+// fiat-crypto derived backends.
+
+// This code only works on a two's complement system.
+#assert((-1 & 3) == 3)
+
+u1 :: distinct u8
+i1 :: distinct i8
+
+cmovznz_u64 :: #force_inline proc "contextless" (arg1: u1, arg2, arg3: u64) -> (out1: u64) {
+	x1 := (u64(arg1) * 0xffffffffffffffff)
+	x2 := ((x1 & arg3) | ((~x1) & arg2))
+	out1 = x2
+	return
+}
+
+cmovznz_u32 :: #force_inline proc "contextless" (arg1: u1, arg2, arg3: u32) -> (out1: u32) {
+	x1 := (u32(arg1) * 0xffffffff)
+	x2 := ((x1 & arg3) | ((~x1) & arg2))
+	out1 = x2
+	return
+}
diff --git a/core/crypto/_fiat/field_curve25519/field.odin b/core/crypto/_fiat/field_curve25519/field.odin
new file mode 100644
index 000000000..faf8ae3f7
--- /dev/null
+++ b/core/crypto/_fiat/field_curve25519/field.odin
@@ -0,0 +1,138 @@
+package field_curve25519
+
+import "core:crypto"
+import "core:mem"
+
+fe_relax_cast :: #force_inline proc "contextless" (arg1: ^Tight_Field_Element) -> ^Loose_Field_Element {
+	return transmute(^Loose_Field_Element)(arg1)
+}
+
+fe_tighten_cast :: #force_inline proc "contextless" (arg1: ^Loose_Field_Element) -> ^Tight_Field_Element {
+	return transmute(^Tight_Field_Element)(arg1)
+}
+
+fe_from_bytes :: proc "contextless" (out1: ^Tight_Field_Element, arg1: ^[32]byte) {
+	// Ignore the unused bit by copying the input and masking the bit off
+	// prior to deserialization.
+	tmp1: [32]byte = ---
+	copy_slice(tmp1[:], arg1[:])
+	tmp1[31] &= 127
+
+	_fe_from_bytes(out1, &tmp1)
+
+	mem.zero_explicit(&tmp1, size_of(tmp1))
+}
+
+fe_equal :: proc "contextless" (arg1, arg2: ^Tight_Field_Element) -> int {
+	tmp2: [32]byte = ---
+
+	fe_to_bytes(&tmp2, arg2)
+	ret := fe_equal_bytes(arg1, &tmp2)
+
+	mem.zero_explicit(&tmp2, size_of(tmp2))
+
+	return ret
+}
+
+fe_equal_bytes :: proc "contextless" (arg1: ^Tight_Field_Element, arg2: ^[32]byte) -> int {
+	tmp1: [32]byte = ---
+
+	fe_to_bytes(&tmp1, arg1)
+
+	ret := crypto.compare_constant_time(tmp1[:], arg2[:])
+
+	mem.zero_explicit(&tmp1, size_of(tmp1))
+
+	return ret
+}
+
+fe_carry_pow2k :: proc (out1: ^Tight_Field_Element, arg1: ^Loose_Field_Element, arg2: uint) {
+	// Special case: `arg1^(2 * 0) = 1`, though this should never happen.
+	if arg2 == 0 {
+		fe_one(out1)
+		return
+	}
+
+	fe_carry_square(out1, arg1)
+	for _ in 1..<arg2 {
+		fe_carry_square(out1, fe_relax_cast(out1))
+	}
+}
+
+fe_carry_opp :: #force_inline proc "contextless" (out1, arg1: ^Tight_Field_Element) {
+	fe_opp(fe_relax_cast(out1), arg1)
+	fe_carry(out1, fe_relax_cast(out1))
+}
+
+fe_carry_invsqrt :: proc (out1: ^Tight_Field_Element, arg1: ^Loose_Field_Element) -> int {
+	// Inverse square root taken from Monocypher.
+
+	tmp1, tmp2, tmp3: Tight_Field_Element = ---, ---, ---
+
+	// t0 = x^((p-5)/8)
+	// Can be achieved with a simple double & add ladder,
+	// but it would be slower.
+	fe_carry_pow2k(&tmp1, arg1, 1)
+	fe_carry_pow2k(&tmp2, fe_relax_cast(&tmp1), 2)
+	fe_carry_mul(&tmp2, arg1, fe_relax_cast(&tmp2))
+	fe_carry_mul(&tmp1, fe_relax_cast(&tmp1), fe_relax_cast(&tmp2))
+	fe_carry_pow2k(&tmp1, fe_relax_cast(&tmp1), 1)
+	fe_carry_mul(&tmp1, fe_relax_cast(&tmp2), fe_relax_cast(&tmp1))
+	fe_carry_pow2k(&tmp2, fe_relax_cast(&tmp1), 5)
+	fe_carry_mul(&tmp1, fe_relax_cast(&tmp2), fe_relax_cast(&tmp1))
+	fe_carry_pow2k(&tmp2, fe_relax_cast(&tmp1), 10)
+	fe_carry_mul(&tmp2, fe_relax_cast(&tmp2), fe_relax_cast(&tmp1))
+	fe_carry_pow2k(&tmp3, fe_relax_cast(&tmp2), 20)
+	fe_carry_mul(&tmp2, fe_relax_cast(&tmp3), fe_relax_cast(&tmp2))
+	fe_carry_pow2k(&tmp2, fe_relax_cast(&tmp2), 10)
+	fe_carry_mul(&tmp1, fe_relax_cast(&tmp2), fe_relax_cast(&tmp1))
+	fe_carry_pow2k(&tmp2, fe_relax_cast(&tmp1), 50)
+	fe_carry_mul(&tmp2, fe_relax_cast(&tmp2), fe_relax_cast(&tmp1))
+	fe_carry_pow2k(&tmp3, fe_relax_cast(&tmp2), 100)
+	fe_carry_mul(&tmp2, fe_relax_cast(&tmp3), fe_relax_cast(&tmp2))
+	fe_carry_pow2k(&tmp2, fe_relax_cast(&tmp2), 50)
+	fe_carry_mul(&tmp1, fe_relax_cast(&tmp2), fe_relax_cast(&tmp1))
+	fe_carry_pow2k(&tmp1, fe_relax_cast(&tmp1), 2)
+	fe_carry_mul(&tmp1, fe_relax_cast(&tmp1), arg1)
+
+	// quartic = x^((p-1)/4)
+	quartic := &tmp2
+	fe_carry_square(quartic, fe_relax_cast(&tmp1))
+	fe_carry_mul(quartic, fe_relax_cast(quartic), arg1)
+
+	// Serialize quartic once to save on repeated serialization/sanitization.
+	quartic_buf: [32]byte = ---
+	fe_to_bytes(&quartic_buf, quartic)
+	check := &tmp3
+
+	fe_one(check)
+	p1 := fe_equal_bytes(check, &quartic_buf)
+	fe_carry_opp(check, check)
+	m1 := fe_equal_bytes(check, &quartic_buf)
+	fe_carry_opp(check, &SQRT_M1)
+	ms := fe_equal_bytes(check, &quartic_buf)
+
+	// if quartic == -1 or sqrt(-1)
+	// then  isr = x^((p-1)/4) * sqrt(-1)
+	// else  isr = x^((p-1)/4)
+	fe_carry_mul(out1, fe_relax_cast(&tmp1), fe_relax_cast(&SQRT_M1))
+	fe_cond_assign(out1, &tmp1, (m1|ms) ~ 1)
+
+	mem.zero_explicit(&tmp1, size_of(tmp1))
+	mem.zero_explicit(&tmp2, size_of(tmp2))
+	mem.zero_explicit(&tmp3, size_of(tmp3))
+	mem.zero_explicit(&quartic_buf, size_of(quartic_buf))
+
+	return p1 | m1
+}
+
+fe_carry_inv :: proc (out1: ^Tight_Field_Element, arg1: ^Loose_Field_Element) {
+	tmp1: Tight_Field_Element
+
+	fe_carry_square(&tmp1, arg1)
+	_ = fe_carry_invsqrt(&tmp1, fe_relax_cast(&tmp1))
+	fe_carry_square(&tmp1, fe_relax_cast(&tmp1))
+	fe_carry_mul(out1, fe_relax_cast(&tmp1), arg1)
+
+	mem.zero_explicit(&tmp1, size_of(tmp1))
+}
diff --git a/core/crypto/_fiat/field_curve25519/field51.odin b/core/crypto/_fiat/field_curve25519/field51.odin
new file mode 100644
index 000000000..e4ca98b57
--- /dev/null
+++ b/core/crypto/_fiat/field_curve25519/field51.odin
@@ -0,0 +1,616 @@
+// The BSD 1-Clause License (BSD-1-Clause)
+//
+// Copyright (c) 2015-2020 the fiat-crypto authors (see the AUTHORS file)
+// All rights reserved.
+//
+// Redistribution and use in source and binary forms, with or without
+// modification, are permitted provided that the following conditions are
+// met:
+//
+//     1. Redistributions of source code must retain the above copyright
+//        notice, this list of conditions and the following disclaimer.
+//
+// THIS SOFTWARE IS PROVIDED BY the fiat-crypto authors "AS IS"
+// AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO,
+// THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
+// PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL Berkeley Software Design,
+// Inc. BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
+// EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
+// PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
+// PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF
+// LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING
+// NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
+// SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+
+package field_curve25519
+
+// The file provides arithmetic on the field Z/(2^255-19) using
+// unsaturated 64-bit integer arithmetic.  It is derived primarily
+// from the machine generated Golang output from the fiat-crypto project.
+//
+// While the base implementation is provably correct, this implementation
+// makes no such claims as the port and optimizations were done by hand.
+// At some point, it may be worth adding support to fiat-crypto for
+// generating Odin output.
+//
+// TODO:
+//  * When fiat-crypto supports it, using a saturated 64-bit limbs
+//    instead of 51-bit limbs will be faster, though the gains are
+//    minimal unless adcx/adox/mulx are used.
+
+import fiat "core:crypto/_fiat"
+import "core:math/bits"
+
+Loose_Field_Element :: distinct [5]u64
+Tight_Field_Element :: distinct [5]u64
+
+SQRT_M1 := Tight_Field_Element{
+	1718705420411056,
+	234908883556509,
+	2233514472574048,
+	2117202627021982,
+	765476049583133,
+}
+
+_addcarryx_u51 :: #force_inline proc "contextless" (arg1: fiat.u1, arg2, arg3: u64) -> (out1: u64, out2: fiat.u1) {
+	x1 := ((u64(arg1) + arg2) + arg3)
+	x2 := (x1 & 0x7ffffffffffff)
+	x3 := fiat.u1((x1 >> 51))
+	out1 = x2
+	out2 = x3
+	return
+}
+
+_subborrowx_u51 :: #force_inline proc "contextless" (arg1: fiat.u1, arg2, arg3: u64) -> (out1: u64, out2: fiat.u1) {
+	x1 := ((i64(arg2) - i64(arg1)) - i64(arg3))
+	x2 := fiat.i1((x1 >> 51))
+	x3 := (u64(x1) & 0x7ffffffffffff)
+	out1 = x3
+	out2 = (0x0 - fiat.u1(x2))
+	return
+}
+
+fe_carry_mul :: proc (out1: ^Tight_Field_Element, arg1, arg2: ^Loose_Field_Element) {
+	x2, x1 := bits.mul_u64(arg1[4], (arg2[4] * 0x13))
+	x4, x3 := bits.mul_u64(arg1[4], (arg2[3] * 0x13))
+	x6, x5 := bits.mul_u64(arg1[4], (arg2[2] * 0x13))
+	x8, x7 := bits.mul_u64(arg1[4], (arg2[1] * 0x13))
+	x10, x9 := bits.mul_u64(arg1[3], (arg2[4] * 0x13))
+	x12, x11 := bits.mul_u64(arg1[3], (arg2[3] * 0x13))
+	x14, x13 := bits.mul_u64(arg1[3], (arg2[2] * 0x13))
+	x16, x15 := bits.mul_u64(arg1[2], (arg2[4] * 0x13))
+	x18, x17 := bits.mul_u64(arg1[2], (arg2[3] * 0x13))
+	x20, x19 := bits.mul_u64(arg1[1], (arg2[4] * 0x13))
+	x22, x21 := bits.mul_u64(arg1[4], arg2[0])
+	x24, x23 := bits.mul_u64(arg1[3], arg2[1])
+	x26, x25 := bits.mul_u64(arg1[3], arg2[0])
+	x28, x27 := bits.mul_u64(arg1[2], arg2[2])
+	x30, x29 := bits.mul_u64(arg1[2], arg2[1])
+	x32, x31 := bits.mul_u64(arg1[2], arg2[0])
+	x34, x33 := bits.mul_u64(arg1[1], arg2[3])
+	x36, x35 := bits.mul_u64(arg1[1], arg2[2])
+	x38, x37 := bits.mul_u64(arg1[1], arg2[1])
+	x40, x39 := bits.mul_u64(arg1[1], arg2[0])
+	x42, x41 := bits.mul_u64(arg1[0], arg2[4])
+	x44, x43 := bits.mul_u64(arg1[0], arg2[3])
+	x46, x45 := bits.mul_u64(arg1[0], arg2[2])
+	x48, x47 := bits.mul_u64(arg1[0], arg2[1])
+	x50, x49 := bits.mul_u64(arg1[0], arg2[0])
+	x51, x52 := bits.add_u64(x13, x7, u64(0x0))
+	x53, _ := bits.add_u64(x14, x8, u64(fiat.u1(x52)))
+	x55, x56 := bits.add_u64(x17, x51, u64(0x0))
+	x57, _ := bits.add_u64(x18, x53, u64(fiat.u1(x56)))
+	x59, x60 := bits.add_u64(x19, x55, u64(0x0))
+	x61, _ := bits.add_u64(x20, x57, u64(fiat.u1(x60)))
+	x63, x64 := bits.add_u64(x49, x59, u64(0x0))
+	x65, _ := bits.add_u64(x50, x61, u64(fiat.u1(x64)))
+	x67 := ((x63 >> 51) | ((x65 << 13) & 0xffffffffffffffff))
+	x68 := (x63 & 0x7ffffffffffff)
+	x69, x70 := bits.add_u64(x23, x21, u64(0x0))
+	x71, _ := bits.add_u64(x24, x22, u64(fiat.u1(x70)))
+	x73, x74 := bits.add_u64(x27, x69, u64(0x0))
+	x75, _ := bits.add_u64(x28, x71, u64(fiat.u1(x74)))
+	x77, x78 := bits.add_u64(x33, x73, u64(0x0))
+	x79, _ := bits.add_u64(x34, x75, u64(fiat.u1(x78)))
+	x81, x82 := bits.add_u64(x41, x77, u64(0x0))
+	x83, _ := bits.add_u64(x42, x79, u64(fiat.u1(x82)))
+	x85, x86 := bits.add_u64(x25, x1, u64(0x0))
+	x87, _ := bits.add_u64(x26, x2, u64(fiat.u1(x86)))
+	x89, x90 := bits.add_u64(x29, x85, u64(0x0))
+	x91, _ := bits.add_u64(x30, x87, u64(fiat.u1(x90)))
+	x93, x94 := bits.add_u64(x35, x89, u64(0x0))
+	x95, _ := bits.add_u64(x36, x91, u64(fiat.u1(x94)))
+	x97, x98 := bits.add_u64(x43, x93, u64(0x0))
+	x99, _ := bits.add_u64(x44, x95, u64(fiat.u1(x98)))
+	x101, x102 := bits.add_u64(x9, x3, u64(0x0))
+	x103, _ := bits.add_u64(x10, x4, u64(fiat.u1(x102)))
+	x105, x106 := bits.add_u64(x31, x101, u64(0x0))
+	x107, _ := bits.add_u64(x32, x103, u64(fiat.u1(x106)))
+	x109, x110 := bits.add_u64(x37, x105, u64(0x0))
+	x111, _ := bits.add_u64(x38, x107, u64(fiat.u1(x110)))
+	x113, x114 := bits.add_u64(x45, x109, u64(0x0))
+	x115, _ := bits.add_u64(x46, x111, u64(fiat.u1(x114)))
+	x117, x118 := bits.add_u64(x11, x5, u64(0x0))
+	x119, _ := bits.add_u64(x12, x6, u64(fiat.u1(x118)))
+	x121, x122 := bits.add_u64(x15, x117, u64(0x0))
+	x123, _ := bits.add_u64(x16, x119, u64(fiat.u1(x122)))
+	x125, x126 := bits.add_u64(x39, x121, u64(0x0))
+	x127, _ := bits.add_u64(x40, x123, u64(fiat.u1(x126)))
+	x129, x130 := bits.add_u64(x47, x125, u64(0x0))
+	x131, _ := bits.add_u64(x48, x127, u64(fiat.u1(x130)))
+	x133, x134 := bits.add_u64(x67, x129, u64(0x0))
+	x135 := (u64(fiat.u1(x134)) + x131)
+	x136 := ((x133 >> 51) | ((x135 << 13) & 0xffffffffffffffff))
+	x137 := (x133 & 0x7ffffffffffff)
+	x138, x139 := bits.add_u64(x136, x113, u64(0x0))
+	x140 := (u64(fiat.u1(x139)) + x115)
+	x141 := ((x138 >> 51) | ((x140 << 13) & 0xffffffffffffffff))
+	x142 := (x138 & 0x7ffffffffffff)
+	x143, x144 := bits.add_u64(x141, x97, u64(0x0))
+	x145 := (u64(fiat.u1(x144)) + x99)
+	x146 := ((x143 >> 51) | ((x145 << 13) & 0xffffffffffffffff))
+	x147 := (x143 & 0x7ffffffffffff)
+	x148, x149 := bits.add_u64(x146, x81, u64(0x0))
+	x150 := (u64(fiat.u1(x149)) + x83)
+	x151 := ((x148 >> 51) | ((x150 << 13) & 0xffffffffffffffff))
+	x152 := (x148 & 0x7ffffffffffff)
+	x153 := (x151 * 0x13)
+	x154 := (x68 + x153)
+	x155 := (x154 >> 51)
+	x156 := (x154 & 0x7ffffffffffff)
+	x157 := (x155 + x137)
+	x158 := fiat.u1((x157 >> 51))
+	x159 := (x157 & 0x7ffffffffffff)
+	x160 := (u64(x158) + x142)
+	out1[0] = x156
+	out1[1] = x159
+	out1[2] = x160
+	out1[3] = x147
+	out1[4] = x152
+}
+
+fe_carry_square :: proc (out1: ^Tight_Field_Element, arg1: ^Loose_Field_Element) {
+	x1 := (arg1[4] * 0x13)
+	x2 := (x1 * 0x2)
+	x3 := (arg1[4] * 0x2)
+	x4 := (arg1[3] * 0x13)
+	x5 := (x4 * 0x2)
+	x6 := (arg1[3] * 0x2)
+	x7 := (arg1[2] * 0x2)
+	x8 := (arg1[1] * 0x2)
+	x10, x9 := bits.mul_u64(arg1[4], x1)
+	x12, x11 := bits.mul_u64(arg1[3], x2)
+	x14, x13 := bits.mul_u64(arg1[3], x4)
+	x16, x15 := bits.mul_u64(arg1[2], x2)
+	x18, x17 := bits.mul_u64(arg1[2], x5)
+	x20, x19 := bits.mul_u64(arg1[2], arg1[2])
+	x22, x21 := bits.mul_u64(arg1[1], x2)
+	x24, x23 := bits.mul_u64(arg1[1], x6)
+	x26, x25 := bits.mul_u64(arg1[1], x7)
+	x28, x27 := bits.mul_u64(arg1[1], arg1[1])
+	x30, x29 := bits.mul_u64(arg1[0], x3)
+	x32, x31 := bits.mul_u64(arg1[0], x6)
+	x34, x33 := bits.mul_u64(arg1[0], x7)
+	x36, x35 := bits.mul_u64(arg1[0], x8)
+	x38, x37 := bits.mul_u64(arg1[0], arg1[0])
+	x39, x40 := bits.add_u64(x21, x17, u64(0x0))
+	x41, _ := bits.add_u64(x22, x18, u64(fiat.u1(x40)))
+	x43, x44 := bits.add_u64(x37, x39, u64(0x0))
+	x45, _ := bits.add_u64(x38, x41, u64(fiat.u1(x44)))
+	x47 := ((x43 >> 51) | ((x45 << 13) & 0xffffffffffffffff))
+	x48 := (x43 & 0x7ffffffffffff)
+	x49, x50 := bits.add_u64(x23, x19, u64(0x0))
+	x51, _ := bits.add_u64(x24, x20, u64(fiat.u1(x50)))
+	x53, x54 := bits.add_u64(x29, x49, u64(0x0))
+	x55, _ := bits.add_u64(x30, x51, u64(fiat.u1(x54)))
+	x57, x58 := bits.add_u64(x25, x9, u64(0x0))
+	x59, _ := bits.add_u64(x26, x10, u64(fiat.u1(x58)))
+	x61, x62 := bits.add_u64(x31, x57, u64(0x0))
+	x63, _ := bits.add_u64(x32, x59, u64(fiat.u1(x62)))
+	x65, x66 := bits.add_u64(x27, x11, u64(0x0))
+	x67, _ := bits.add_u64(x28, x12, u64(fiat.u1(x66)))
+	x69, x70 := bits.add_u64(x33, x65, u64(0x0))
+	x71, _ := bits.add_u64(x34, x67, u64(fiat.u1(x70)))
+	x73, x74 := bits.add_u64(x15, x13, u64(0x0))
+	x75, _ := bits.add_u64(x16, x14, u64(fiat.u1(x74)))
+	x77, x78 := bits.add_u64(x35, x73, u64(0x0))
+	x79, _ := bits.add_u64(x36, x75, u64(fiat.u1(x78)))
+	x81, x82 := bits.add_u64(x47, x77, u64(0x0))
+	x83 := (u64(fiat.u1(x82)) + x79)
+	x84 := ((x81 >> 51) | ((x83 << 13) & 0xffffffffffffffff))
+	x85 := (x81 & 0x7ffffffffffff)
+	x86, x87 := bits.add_u64(x84, x69, u64(0x0))
+	x88 := (u64(fiat.u1(x87)) + x71)
+	x89 := ((x86 >> 51) | ((x88 << 13) & 0xffffffffffffffff))
+	x90 := (x86 & 0x7ffffffffffff)
+	x91, x92 := bits.add_u64(x89, x61, u64(0x0))
+	x93 := (u64(fiat.u1(x92)) + x63)
+	x94 := ((x91 >> 51) | ((x93 << 13) & 0xffffffffffffffff))
+	x95 := (x91 & 0x7ffffffffffff)
+	x96, x97 := bits.add_u64(x94, x53, u64(0x0))
+	x98 := (u64(fiat.u1(x97)) + x55)
+	x99 := ((x96 >> 51) | ((x98 << 13) & 0xffffffffffffffff))
+	x100 := (x96 & 0x7ffffffffffff)
+	x101 := (x99 * 0x13)
+	x102 := (x48 + x101)
+	x103 := (x102 >> 51)
+	x104 := (x102 & 0x7ffffffffffff)
+	x105 := (x103 + x85)
+	x106 := fiat.u1((x105 >> 51))
+	x107 := (x105 & 0x7ffffffffffff)
+	x108 := (u64(x106) + x90)
+	out1[0] = x104
+	out1[1] = x107
+	out1[2] = x108
+	out1[3] = x95
+	out1[4] = x100
+}
+
+fe_carry :: proc "contextless" (out1: ^Tight_Field_Element, arg1: ^Loose_Field_Element) {
+	x1 := arg1[0]
+	x2 := ((x1 >> 51) + arg1[1])
+	x3 := ((x2 >> 51) + arg1[2])
+	x4 := ((x3 >> 51) + arg1[3])
+	x5 := ((x4 >> 51) + arg1[4])
+	x6 := ((x1 & 0x7ffffffffffff) + ((x5 >> 51) * 0x13))
+	x7 := (u64(fiat.u1((x6 >> 51))) + (x2 & 0x7ffffffffffff))
+	x8 := (x6 & 0x7ffffffffffff)
+	x9 := (x7 & 0x7ffffffffffff)
+	x10 := (u64(fiat.u1((x7 >> 51))) + (x3 & 0x7ffffffffffff))
+	x11 := (x4 & 0x7ffffffffffff)
+	x12 := (x5 & 0x7ffffffffffff)
+	out1[0] = x8
+	out1[1] = x9
+	out1[2] = x10
+	out1[3] = x11
+	out1[4] = x12
+}
+
+fe_add :: proc "contextless" (out1: ^Loose_Field_Element, arg1, arg2: ^Tight_Field_Element) {
+	x1 := (arg1[0] + arg2[0])
+	x2 := (arg1[1] + arg2[1])
+	x3 := (arg1[2] + arg2[2])
+	x4 := (arg1[3] + arg2[3])
+	x5 := (arg1[4] + arg2[4])
+	out1[0] = x1
+	out1[1] = x2
+	out1[2] = x3
+	out1[3] = x4
+	out1[4] = x5
+}
+
+fe_sub :: proc "contextless" (out1: ^Loose_Field_Element, arg1, arg2: ^Tight_Field_Element) {
+	x1 := ((0xfffffffffffda + arg1[0]) - arg2[0])
+	x2 := ((0xffffffffffffe + arg1[1]) - arg2[1])
+	x3 := ((0xffffffffffffe + arg1[2]) - arg2[2])
+	x4 := ((0xffffffffffffe + arg1[3]) - arg2[3])
+	x5 := ((0xffffffffffffe + arg1[4]) - arg2[4])
+	out1[0] = x1
+	out1[1] = x2
+	out1[2] = x3
+	out1[3] = x4
+	out1[4] = x5
+}
+
+fe_opp :: proc "contextless" (out1: ^Loose_Field_Element, arg1: ^Tight_Field_Element) {
+	x1 := (0xfffffffffffda - arg1[0])
+	x2 := (0xffffffffffffe - arg1[1])
+	x3 := (0xffffffffffffe - arg1[2])
+	x4 := (0xffffffffffffe - arg1[3])
+	x5 := (0xffffffffffffe - arg1[4])
+	out1[0] = x1
+	out1[1] = x2
+	out1[2] = x3
+	out1[3] = x4
+	out1[4] = x5
+}
+
+fe_cond_assign :: proc "contextless" (out1, arg1: ^Tight_Field_Element, arg2: int) {
+	x1 := fiat.cmovznz_u64(fiat.u1(arg2), out1[0], arg1[0])
+	x2 := fiat.cmovznz_u64(fiat.u1(arg2), out1[1], arg1[1])
+	x3 := fiat.cmovznz_u64(fiat.u1(arg2), out1[2], arg1[2])
+	x4 := fiat.cmovznz_u64(fiat.u1(arg2), out1[3], arg1[3])
+	x5 := fiat.cmovznz_u64(fiat.u1(arg2), out1[4], arg1[4])
+	out1[0] = x1
+	out1[1] = x2
+	out1[2] = x3
+	out1[3] = x4
+	out1[4] = x5
+}
+
+fe_to_bytes :: proc "contextless" (out1: ^[32]byte, arg1: ^Tight_Field_Element) {
+	x1, x2 := _subborrowx_u51(0x0, arg1[0], 0x7ffffffffffed)
+	x3, x4 := _subborrowx_u51(x2, arg1[1], 0x7ffffffffffff)
+	x5, x6 := _subborrowx_u51(x4, arg1[2], 0x7ffffffffffff)
+	x7, x8 := _subborrowx_u51(x6, arg1[3], 0x7ffffffffffff)
+	x9, x10 := _subborrowx_u51(x8, arg1[4], 0x7ffffffffffff)
+	x11 := fiat.cmovznz_u64(x10, u64(0x0), 0xffffffffffffffff)
+	x12, x13 := _addcarryx_u51(0x0, x1, (x11 & 0x7ffffffffffed))
+	x14, x15 := _addcarryx_u51(x13, x3, (x11 & 0x7ffffffffffff))
+	x16, x17 := _addcarryx_u51(x15, x5, (x11 & 0x7ffffffffffff))
+	x18, x19 := _addcarryx_u51(x17, x7, (x11 & 0x7ffffffffffff))
+	x20, _ := _addcarryx_u51(x19, x9, (x11 & 0x7ffffffffffff))
+	x22 := (x20 << 4)
+	x23 := (x18 * u64(0x2))
+	x24 := (x16 << 6)
+	x25 := (x14 << 3)
+	x26 := (u8(x12) & 0xff)
+	x27 := (x12 >> 8)
+	x28 := (u8(x27) & 0xff)
+	x29 := (x27 >> 8)
+	x30 := (u8(x29) & 0xff)
+	x31 := (x29 >> 8)
+	x32 := (u8(x31) & 0xff)
+	x33 := (x31 >> 8)
+	x34 := (u8(x33) & 0xff)
+	x35 := (x33 >> 8)
+	x36 := (u8(x35) & 0xff)
+	x37 := u8((x35 >> 8))
+	x38 := (x25 + u64(x37))
+	x39 := (u8(x38) & 0xff)
+	x40 := (x38 >> 8)
+	x41 := (u8(x40) & 0xff)
+	x42 := (x40 >> 8)
+	x43 := (u8(x42) & 0xff)
+	x44 := (x42 >> 8)
+	x45 := (u8(x44) & 0xff)
+	x46 := (x44 >> 8)
+	x47 := (u8(x46) & 0xff)
+	x48 := (x46 >> 8)
+	x49 := (u8(x48) & 0xff)
+	x50 := u8((x48 >> 8))
+	x51 := (x24 + u64(x50))
+	x52 := (u8(x51) & 0xff)
+	x53 := (x51 >> 8)
+	x54 := (u8(x53) & 0xff)
+	x55 := (x53 >> 8)
+	x56 := (u8(x55) & 0xff)
+	x57 := (x55 >> 8)
+	x58 := (u8(x57) & 0xff)
+	x59 := (x57 >> 8)
+	x60 := (u8(x59) & 0xff)
+	x61 := (x59 >> 8)
+	x62 := (u8(x61) & 0xff)
+	x63 := (x61 >> 8)
+	x64 := (u8(x63) & 0xff)
+	x65 := fiat.u1((x63 >> 8))
+	x66 := (x23 + u64(x65))
+	x67 := (u8(x66) & 0xff)
+	x68 := (x66 >> 8)
+	x69 := (u8(x68) & 0xff)
+	x70 := (x68 >> 8)
+	x71 := (u8(x70) & 0xff)
+	x72 := (x70 >> 8)
+	x73 := (u8(x72) & 0xff)
+	x74 := (x72 >> 8)
+	x75 := (u8(x74) & 0xff)
+	x76 := (x74 >> 8)
+	x77 := (u8(x76) & 0xff)
+	x78 := u8((x76 >> 8))
+	x79 := (x22 + u64(x78))
+	x80 := (u8(x79) & 0xff)
+	x81 := (x79 >> 8)
+	x82 := (u8(x81) & 0xff)
+	x83 := (x81 >> 8)
+	x84 := (u8(x83) & 0xff)
+	x85 := (x83 >> 8)
+	x86 := (u8(x85) & 0xff)
+	x87 := (x85 >> 8)
+	x88 := (u8(x87) & 0xff)
+	x89 := (x87 >> 8)
+	x90 := (u8(x89) & 0xff)
+	x91 := u8((x89 >> 8))
+	out1[0] = x26
+	out1[1] = x28
+	out1[2] = x30
+	out1[3] = x32
+	out1[4] = x34
+	out1[5] = x36
+	out1[6] = x39
+	out1[7] = x41
+	out1[8] = x43
+	out1[9] = x45
+	out1[10] = x47
+	out1[11] = x49
+	out1[12] = x52
+	out1[13] = x54
+	out1[14] = x56
+	out1[15] = x58
+	out1[16] = x60
+	out1[17] = x62
+	out1[18] = x64
+	out1[19] = x67
+	out1[20] = x69
+	out1[21] = x71
+	out1[22] = x73
+	out1[23] = x75
+	out1[24] = x77
+	out1[25] = x80
+	out1[26] = x82
+	out1[27] = x84
+	out1[28] = x86
+	out1[29] = x88
+	out1[30] = x90
+	out1[31] = x91
+}
+
+_fe_from_bytes :: proc "contextless" (out1: ^Tight_Field_Element, arg1: ^[32]byte) {
+	x1 := (u64(arg1[31]) << 44)
+	x2 := (u64(arg1[30]) << 36)
+	x3 := (u64(arg1[29]) << 28)
+	x4 := (u64(arg1[28]) << 20)
+	x5 := (u64(arg1[27]) << 12)
+	x6 := (u64(arg1[26]) << 4)
+	x7 := (u64(arg1[25]) << 47)
+	x8 := (u64(arg1[24]) << 39)
+	x9 := (u64(arg1[23]) << 31)
+	x10 := (u64(arg1[22]) << 23)
+	x11 := (u64(arg1[21]) << 15)
+	x12 := (u64(arg1[20]) << 7)
+	x13 := (u64(arg1[19]) << 50)
+	x14 := (u64(arg1[18]) << 42)
+	x15 := (u64(arg1[17]) << 34)
+	x16 := (u64(arg1[16]) << 26)
+	x17 := (u64(arg1[15]) << 18)
+	x18 := (u64(arg1[14]) << 10)
+	x19 := (u64(arg1[13]) << 2)
+	x20 := (u64(arg1[12]) << 45)
+	x21 := (u64(arg1[11]) << 37)
+	x22 := (u64(arg1[10]) << 29)
+	x23 := (u64(arg1[9]) << 21)
+	x24 := (u64(arg1[8]) << 13)
+	x25 := (u64(arg1[7]) << 5)
+	x26 := (u64(arg1[6]) << 48)
+	x27 := (u64(arg1[5]) << 40)
+	x28 := (u64(arg1[4]) << 32)
+	x29 := (u64(arg1[3]) << 24)
+	x30 := (u64(arg1[2]) << 16)
+	x31 := (u64(arg1[1]) << 8)
+	x32 := arg1[0]
+	x33 := (x31 + u64(x32))
+	x34 := (x30 + x33)
+	x35 := (x29 + x34)
+	x36 := (x28 + x35)
+	x37 := (x27 + x36)
+	x38 := (x26 + x37)
+	x39 := (x38 & 0x7ffffffffffff)
+	x40 := u8((x38 >> 51))
+	x41 := (x25 + u64(x40))
+	x42 := (x24 + x41)
+	x43 := (x23 + x42)
+	x44 := (x22 + x43)
+	x45 := (x21 + x44)
+	x46 := (x20 + x45)
+	x47 := (x46 & 0x7ffffffffffff)
+	x48 := u8((x46 >> 51))
+	x49 := (x19 + u64(x48))
+	x50 := (x18 + x49)
+	x51 := (x17 + x50)
+	x52 := (x16 + x51)
+	x53 := (x15 + x52)
+	x54 := (x14 + x53)
+	x55 := (x13 + x54)
+	x56 := (x55 & 0x7ffffffffffff)
+	x57 := u8((x55 >> 51))
+	x58 := (x12 + u64(x57))
+	x59 := (x11 + x58)
+	x60 := (x10 + x59)
+	x61 := (x9 + x60)
+	x62 := (x8 + x61)
+	x63 := (x7 + x62)
+	x64 := (x63 & 0x7ffffffffffff)
+	x65 := u8((x63 >> 51))
+	x66 := (x6 + u64(x65))
+	x67 := (x5 + x66)
+	x68 := (x4 + x67)
+	x69 := (x3 + x68)
+	x70 := (x2 + x69)
+	x71 := (x1 + x70)
+	out1[0] = x39
+	out1[1] = x47
+	out1[2] = x56
+	out1[3] = x64
+	out1[4] = x71
+}
+
+fe_relax :: proc "contextless" (out1: ^Loose_Field_Element, arg1: ^Tight_Field_Element) {
+	x1 := arg1[0]
+	x2 := arg1[1]
+	x3 := arg1[2]
+	x4 := arg1[3]
+	x5 := arg1[4]
+	out1[0] = x1
+	out1[1] = x2
+	out1[2] = x3
+	out1[3] = x4
+	out1[4] = x5
+}
+
+fe_carry_scmul_121666 :: proc (out1: ^Tight_Field_Element, arg1: ^Loose_Field_Element) {
+	x2, x1 := bits.mul_u64(0x1db42, arg1[4])
+	x4, x3 := bits.mul_u64(0x1db42, arg1[3])
+	x6, x5 := bits.mul_u64(0x1db42, arg1[2])
+	x8, x7 := bits.mul_u64(0x1db42, arg1[1])
+	x10, x9 := bits.mul_u64(0x1db42, arg1[0])
+	x11 := ((x9 >> 51) | ((x10 << 13) & 0xffffffffffffffff))
+	x12 := (x9 & 0x7ffffffffffff)
+	x13, x14 := bits.add_u64(x11, x7, u64(0x0))
+	x15 := (u64(fiat.u1(x14)) + x8)
+	x16 := ((x13 >> 51) | ((x15 << 13) & 0xffffffffffffffff))
+	x17 := (x13 & 0x7ffffffffffff)
+	x18, x19 := bits.add_u64(x16, x5, u64(0x0))
+	x20 := (u64(fiat.u1(x19)) + x6)
+	x21 := ((x18 >> 51) | ((x20 << 13) & 0xffffffffffffffff))
+	x22 := (x18 & 0x7ffffffffffff)
+	x23, x24 := bits.add_u64(x21, x3, u64(0x0))
+	x25 := (u64(fiat.u1(x24)) + x4)
+	x26 := ((x23 >> 51) | ((x25 << 13) & 0xffffffffffffffff))
+	x27 := (x23 & 0x7ffffffffffff)
+	x28, x29 := bits.add_u64(x26, x1, u64(0x0))
+	x30 := (u64(fiat.u1(x29)) + x2)
+	x31 := ((x28 >> 51) | ((x30 << 13) & 0xffffffffffffffff))
+	x32 := (x28 & 0x7ffffffffffff)
+	x33 := (x31 * 0x13)
+	x34 := (x12 + x33)
+	x35 := fiat.u1((x34 >> 51))
+	x36 := (x34 & 0x7ffffffffffff)
+	x37 := (u64(x35) + x17)
+	x38 := fiat.u1((x37 >> 51))
+	x39 := (x37 & 0x7ffffffffffff)
+	x40 := (u64(x38) + x22)
+	out1[0] = x36
+	out1[1] = x39
+	out1[2] = x40
+	out1[3] = x27
+	out1[4] = x32
+}
+
+// The following routines were added by hand, and do not come from fiat-crypto.
+
+fe_zero :: proc "contextless" (out1: ^Tight_Field_Element) {
+	out1[0] = 0
+	out1[1] = 0
+	out1[2] = 0
+	out1[3] = 0
+	out1[4] = 0
+}
+
+fe_one :: proc "contextless" (out1: ^Tight_Field_Element) {
+	out1[0] = 1
+	out1[1] = 0
+	out1[2] = 0
+	out1[3] = 0
+	out1[4] = 0
+}
+
+fe_set :: proc "contextless" (out1, arg1: ^Tight_Field_Element) {
+	x1 := arg1[0]
+	x2 := arg1[1]
+	x3 := arg1[2]
+	x4 := arg1[3]
+	x5 := arg1[4]
+	out1[0] = x1
+	out1[1] = x2
+	out1[2] = x3
+	out1[3] = x4
+	out1[4] = x5
+}
+
+fe_cond_swap :: proc "contextless" (out1, out2: ^Tight_Field_Element, arg1: int) {
+	mask := -u64(arg1)
+	x := (out1[0] ~ out2[0]) & mask
+	x1, y1 := out1[0] ~ x, out2[0] ~ x
+	x = (out1[1] ~ out2[1]) & mask
+	x2, y2 := out1[1] ~ x, out2[1] ~ x
+	x = (out1[2] ~ out2[2]) & mask
+	x3, y3 := out1[2] ~ x, out2[2] ~ x
+	x = (out1[3] ~ out2[3]) & mask
+	x4, y4 := out1[3] ~ x, out2[3] ~ x
+	x = (out1[4] ~ out2[4]) & mask
+	x5, y5 := out1[4] ~ x, out2[4] ~ x
+	out1[0], out2[0] = x1, y1
+	out1[1], out2[1] = x2, y2
+	out1[2], out2[2] = x3, y3
+	out1[3], out2[3] = x4, y4
+	out1[4], out2[4] = x5, y5
+}
diff --git a/core/crypto/x25519/x25519.odin b/core/crypto/x25519/x25519.odin
new file mode 100644
index 000000000..dfc8daa47
--- /dev/null
+++ b/core/crypto/x25519/x25519.odin
@@ -0,0 +1,126 @@
+package x25519
+
+import field "core:crypto/_fiat/field_curve25519"
+import "core:mem"
+
+SCALAR_SIZE :: 32
+POINT_SIZE :: 32
+
+_BASE_POINT: [32]byte = {9, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0}
+
+_scalar_bit :: #force_inline proc "contextless" (s: ^[32]byte, i: int) -> u8 {
+	if i < 0 {
+		return 0
+	}
+	return (s[i>>3] >> uint(i&7)) & 1
+}
+
+_scalarmult :: proc (out, scalar, point: ^[32]byte) {
+	// Montgomery pseduo-multiplication taken from Monocypher.
+
+	// computes the scalar product
+	x1: field.Tight_Field_Element = ---
+	field.fe_from_bytes(&x1, point)
+
+	// computes the actual scalar product (the result is in x2 and z2)
+	x2, x3, z2, z3: field.Tight_Field_Element =  ---, ---, ---, ---
+	t0, t1: field.Loose_Field_Element = ---, ---
+
+	// Montgomery ladder
+	// In projective coordinates, to avoid divisions: x = X / Z
+	// We don't care about the y coordinate, it's only 1 bit of information
+	field.fe_one(&x2) // "zero" point
+	field.fe_zero(&z2)
+	field.fe_set(&x3, &x1) // "one" point
+	field.fe_one(&z3)
+
+	swap: int
+	for pos := 255-1; pos >= 0; pos = pos - 1 	{
+		// constant time conditional swap before ladder step
+		b := int(_scalar_bit(scalar, pos))
+		swap ~= b // xor trick avoids swapping at the end of the loop
+		field.fe_cond_swap(&x2, &x3, swap)
+		field.fe_cond_swap(&z2, &z3, swap)
+		swap = b // anticipates one last swap after the loop
+
+		// Montgomery ladder step: replaces (P2, P3) by (P2*2, P2+P3)
+		// with differential addition
+		//
+		// Note: This deliberately omits reductions after add/sub operations
+		// if the result is only ever used as the input to a mul/square since
+		// the implementations of those can deal with non-reduced inputs.
+		//
+		// fe_tighten_cast is only used to store a fully reduced
+		// output in a Loose_Field_Element, or to provide such a
+		// Loose_Field_Element as a Tight_Field_Element argument.
+		field.fe_sub(&t0, &x3, &z3)
+		field.fe_sub(&t1, &x2, &z2)
+		field.fe_add(field.fe_relax_cast(&x2), &x2, &z2) // x2 - unreduced
+		field.fe_add(field.fe_relax_cast(&z2), &x3, &z3) // z2 - unreduced
+		field.fe_carry_mul(&z3, &t0, field.fe_relax_cast(&x2))
+		field.fe_carry_mul(&z2, field.fe_relax_cast(&z2), &t1) // z2 - reduced
+		field.fe_carry_square(field.fe_tighten_cast(&t0), &t1) // t0 - reduced
+		field.fe_carry_square(field.fe_tighten_cast(&t1), field.fe_relax_cast(&x2)) // t1 - reduced
+		field.fe_add(field.fe_relax_cast(&x3), &z3, &z2) // x3 - unreduced
+		field.fe_sub(field.fe_relax_cast(&z2), &z3, &z2) // z2 - unreduced
+		field.fe_carry_mul(&x2, &t1, &t0) // x2 - reduced
+		field.fe_sub(&t1, field.fe_tighten_cast(&t1), field.fe_tighten_cast(&t0)) // safe - t1/t0 is reduced
+		field.fe_carry_square(&z2, field.fe_relax_cast(&z2)) // z2 - reduced
+		field.fe_carry_scmul_121666(&z3, &t1)
+		field.fe_carry_square(&x3, field.fe_relax_cast(&x3)) // x3 - reduced
+		field.fe_add(&t0, field.fe_tighten_cast(&t0), &z3) // safe - t0 is reduced
+		field.fe_carry_mul(&z3, field.fe_relax_cast(&x1), field.fe_relax_cast(&z2))
+		field.fe_carry_mul(&z2, &t1, &t0)
+	}
+	// last swap is necessary to compensate for the xor trick
+	// Note: after this swap, P3 == P2 + P1.
+	field.fe_cond_swap(&x2, &x3, swap)
+	field.fe_cond_swap(&z2, &z3, swap)
+
+	// normalises the coordinates: x == X / Z
+	field.fe_carry_inv(&z2, field.fe_relax_cast(&z2))
+	field.fe_carry_mul(&x2, field.fe_relax_cast(&x2), field.fe_relax_cast(&z2))
+	field.fe_to_bytes(out, &x2)
+
+	mem.zero_explicit(&x1, size_of(x1))
+	mem.zero_explicit(&x2, size_of(x2))
+	mem.zero_explicit(&x3, size_of(x3))
+	mem.zero_explicit(&z2, size_of(z2))
+	mem.zero_explicit(&z3, size_of(z3))
+	mem.zero_explicit(&t0, size_of(t0))
+	mem.zero_explicit(&t1, size_of(t1))
+}
+
+scalarmult :: proc (dst, scalar, point: []byte) {
+	if len(scalar) != SCALAR_SIZE {
+		panic("crypto/x25519: invalid scalar size")
+	}
+	if len(point) != POINT_SIZE {
+		panic("crypto/x25519: invalid point size")
+	}
+	if len(dst) != POINT_SIZE {
+		panic("crypto/x25519: invalid destination point size")
+	}
+
+	// "clamp" the scalar
+	e: [32]byte = ---
+	copy_slice(e[:], scalar)
+	e[0] &= 248
+	e[31] &= 127
+	e[31] |= 64
+
+	p: [32]byte = ---
+	copy_slice(p[:], point)
+
+	d: [32]byte = ---
+	_scalarmult(&d, &e, &p)
+	copy_slice(dst, d[:])
+
+	mem.zero_explicit(&e, size_of(e))
+	mem.zero_explicit(&d, size_of(d))
+}
+
+scalarmult_basepoint :: proc (dst, scalar: []byte) {
+	// TODO/perf: Switch to using a precomputed table.
+	scalarmult(dst, scalar, _BASE_POINT[:])
+}
diff --git a/tests/core/crypto/test_core_crypto.odin b/tests/core/crypto/test_core_crypto.odin
index df9920552..768ba242f 100644
--- a/tests/core/crypto/test_core_crypto.odin
+++ b/tests/core/crypto/test_core_crypto.odin
@@ -115,6 +115,11 @@ main :: proc() {
     test_haval_224(&t)
     test_haval_256(&t)
 
+    // "modern" crypto tests
+    test_x25519(&t)
+
+    bench_modern(&t)
+
     fmt.printf("%v/%v tests successful.\n", TEST_count - TEST_fail, TEST_count)
 }
 
diff --git a/tests/core/crypto/test_core_crypto_modern.odin b/tests/core/crypto/test_core_crypto_modern.odin
new file mode 100644
index 000000000..4d7f08bb1
--- /dev/null
+++ b/tests/core/crypto/test_core_crypto_modern.odin
@@ -0,0 +1,95 @@
+package test_core_crypto
+
+import "core:testing"
+import "core:fmt"
+import "core:time"
+
+import "core:crypto/x25519"
+
+_digit_value :: proc(r: rune) -> int {
+	ri := int(r)
+	v: int = 16
+	switch r {
+	case '0'..='9': v = ri-'0'
+	case 'a'..='z': v = ri-'a'+10
+	case 'A'..='Z': v = ri-'A'+10
+	}
+	return v
+}
+
+_decode_hex32 :: proc(s: string) -> [32]byte{
+	b: [32]byte
+	for i := 0; i < len(s); i = i + 2 {
+		hi := _digit_value(rune(s[i]))
+		lo := _digit_value(rune(s[i+1]))
+		b[i/2] = byte(hi << 4 | lo)
+	}
+	return b
+}
+
+TestECDH :: struct {
+	scalar:  string,
+	point:   string,
+	product: string,
+}
+
+@(test)
+test_x25519 :: proc(t: ^testing.T) {
+	log(t, "Testing X25519")
+
+	test_vectors := [?]TestECDH {
+		// Test vectors from RFC 7748
+		TestECDH{
+			"a546e36bf0527c9d3b16154b82465edd62144c0ac1fc5a18506a2244ba449ac4",
+			"e6db6867583030db3594c1a424b15f7c726624ec26b3353b10a903a6d0ab1c4c",
+			"c3da55379de9c6908e94ea4df28d084f32eccf03491c71f754b4075577a28552",
+		},
+		TestECDH{
+			"4b66e9d4d1b4673c5ad22691957d6af5c11b6421e0ea01d42ca4169e7918ba0d",
+			"e5210f12786811d3f4b7959d0538ae2c31dbe7106fc03c3efc4cd549c715a493",
+			"95cbde9476e8907d7aade45cb4b873f88b595a68799fa152e6f8f7647aac7957",
+		},
+	}
+	for v, _ in test_vectors {
+		scalar := _decode_hex32(v.scalar)
+		point := _decode_hex32(v.point)
+
+		derived_point: [x25519.POINT_SIZE]byte
+		x25519.scalarmult(derived_point[:], scalar[:], point[:])
+		derived_point_str := hex_string(derived_point[:])
+
+		expect(t, derived_point_str == v.product, fmt.tprintf("Expected %s for %s * %s, but got %s instead", v.product, v.scalar, v.point, derived_point_str))
+
+		// Abuse the test vectors to sanity-check the scalar-basepoint multiply.
+		p1, p2: [x25519.POINT_SIZE]byte
+		x25519.scalarmult_basepoint(p1[:], scalar[:])
+		x25519.scalarmult(p2[:], scalar[:], x25519._BASE_POINT[:])
+		p1_str, p2_str := hex_string(p1[:]), hex_string(p2[:])
+		expect(t, p1_str == p2_str, fmt.tprintf("Expected %s for %s * basepoint, but got %s instead", p2_str, v.scalar, p1_str))
+	}
+
+    // TODO/tests: Run the wycheproof test vectors, once I figure out
+    // how to work with JSON.
+}
+
+@(test)
+bench_modern :: proc(t: ^testing.T) {
+	fmt.println("Starting benchmarks:")
+
+	bench_x25519(t)
+}
+
+bench_x25519 :: proc(t: ^testing.T) {
+	point := _decode_hex32("deadbeefdeadbeefdeadbeefdeadbeefdeadbeefdeadbeefdeadbeefdeadbeef")
+	scalar := _decode_hex32("cafebabecafebabecafebabecafebabecafebabecafebabecafebabecafebabe")
+	out: [x25519.POINT_SIZE]byte = ---
+
+	iters :: 10000
+	start := time.now()
+	for i := 0; i < iters; i = i + 1 {
+		x25519.scalarmult(out[:], scalar[:], point[:])
+	}
+	elapsed := time.since(start)
+
+	log(t, fmt.tprintf("x25519.scalarmult: ~%f us/op", time.duration_microseconds(elapsed) / iters))
+}

From 64db286582dc6007317bc5c74d7f5e156f22f855 Mon Sep 17 00:00:00 2001
From: Yawning Angel <yawning@schwanenlied.me>
Date: Sat, 6 Nov 2021 07:38:04 +0000
Subject: [PATCH 17/38] core/crypto: Add poly1305

This package implements the Poly1305 MAC algorithm as specified in RFC
8439, using routines taked from fiat-crypto and poly1305-donna.
---
 core/crypto/_fiat/field_poly1305/field.odin   |  45 +++
 .../_fiat/field_poly1305/field4344.odin       | 356 ++++++++++++++++++
 core/crypto/poly1305/poly1305.odin            | 163 ++++++++
 tests/core/crypto/test_core_crypto.odin       |   1 +
 .../core/crypto/test_core_crypto_modern.odin  | 131 +++++++
 5 files changed, 696 insertions(+)
 create mode 100644 core/crypto/_fiat/field_poly1305/field.odin
 create mode 100644 core/crypto/_fiat/field_poly1305/field4344.odin
 create mode 100644 core/crypto/poly1305/poly1305.odin

diff --git a/core/crypto/_fiat/field_poly1305/field.odin b/core/crypto/_fiat/field_poly1305/field.odin
new file mode 100644
index 000000000..642949b02
--- /dev/null
+++ b/core/crypto/_fiat/field_poly1305/field.odin
@@ -0,0 +1,45 @@
+package field_poly1305
+
+import "core:crypto/util"
+import "core:mem"
+
+fe_relax_cast :: #force_inline proc "contextless" (arg1: ^Tight_Field_Element) -> ^Loose_Field_Element {
+	return transmute(^Loose_Field_Element)(arg1)
+}
+
+fe_tighten_cast :: #force_inline proc "contextless" (arg1: ^Loose_Field_Element) -> ^Tight_Field_Element {
+	return transmute(^Tight_Field_Element)(arg1)
+}
+
+fe_from_bytes :: proc (out1: ^Tight_Field_Element, arg1: []byte, arg2: byte, sanitize: bool = true) {
+	// fiat-crypto's deserialization routine wants 256-bits of input, but
+	// r/s are 128-bits long, and block processing works on 128-bits plus a
+	// final bit.
+	//
+	// This is more ergonomic, and while the copy is unfortunate, this avoids
+	// having to alter the fiat-crypto derived code.
+
+	assert(len(arg1) == 16)
+
+	tmp: [32]byte
+	copy_slice(tmp[0:16], arg1[:])
+	tmp[16] = arg2
+
+	_fe_from_bytes(out1, &tmp)
+
+	// Need to sanitize the temporary buffer when deserializing `s`.
+	if sanitize {
+		mem.zero_explicit(&tmp, size_of(tmp))
+	}
+}
+
+fe_from_u64s :: proc "contextless" (out1: ^Tight_Field_Element, lo, hi: u64) {
+	tmp: [32]byte
+	util.PUT_U64_LE(tmp[0:8], lo)
+	util.PUT_U64_LE(tmp[8:16], hi)
+
+	_fe_from_bytes(out1, &tmp)
+
+	// This routine is only used to deserialize `r` which is confidential.
+	mem.zero_explicit(&tmp, size_of(tmp))
+}
diff --git a/core/crypto/_fiat/field_poly1305/field4344.odin b/core/crypto/_fiat/field_poly1305/field4344.odin
new file mode 100644
index 000000000..ba9bc2694
--- /dev/null
+++ b/core/crypto/_fiat/field_poly1305/field4344.odin
@@ -0,0 +1,356 @@
+// The BSD 1-Clause License (BSD-1-Clause)
+//
+// Copyright (c) 2015-2020 the fiat-crypto authors (see the AUTHORS file)
+// All rights reserved.
+//
+// Redistribution and use in source and binary forms, with or without
+// modification, are permitted provided that the following conditions are
+// met:
+//
+//     1. Redistributions of source code must retain the above copyright
+//        notice, this list of conditions and the following disclaimer.
+//
+// THIS SOFTWARE IS PROVIDED BY the fiat-crypto authors "AS IS"
+// AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO,
+// THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
+// PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL Berkeley Software Design,
+// Inc. BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
+// EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
+// PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
+// PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF
+// LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING
+// NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
+// SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+
+package field_poly1305
+
+// This file provides arithmetic on the field Z/(2^130 - 5) using
+// unsaturated 64-bit integer arithmetic.  It is derived primarily
+// from the machine generate Golang output from the fiat-crypto project.
+//
+// While the base implementation is provably correct, this implementation
+// makes no such claims as the port and optimizations were done by hand.
+// At some point, it may be worth adding support to fiat-crypto for
+// generating Odin output.
+
+import fiat "core:crypto/_fiat"
+import "core:math/bits"
+
+Loose_Field_Element :: distinct [3]u64
+Tight_Field_Element :: distinct [3]u64
+
+_addcarryx_u44 :: #force_inline proc "contextless" (arg1: fiat.u1, arg2, arg3: u64) -> (out1: u64, out2: fiat.u1) {
+	x1 := ((u64(arg1) + arg2) + arg3)
+	x2 := (x1 & 0xfffffffffff)
+	x3 := fiat.u1((x1 >> 44))
+	out1 = x2
+	out2 = x3
+	return
+}
+
+_subborrowx_u44 :: #force_inline proc "contextless" (arg1: fiat.u1, arg2, arg3: u64) -> (out1: u64, out2: fiat.u1) {
+	x1 := ((i64(arg2) - i64(arg1)) - i64(arg3))
+	x2 := fiat.i1((x1 >> 44))
+	x3 := (u64(x1) & 0xfffffffffff)
+	out1 = x3
+	out2 = (0x0 - fiat.u1(x2))
+	return
+}
+
+_addcarryx_u43 :: #force_inline proc "contextless" (arg1: fiat.u1, arg2, arg3: u64) -> (out1: u64, out2: fiat.u1) {
+	x1 := ((u64(arg1) + arg2) + arg3)
+	x2 := (x1 & 0x7ffffffffff)
+	x3 := fiat.u1((x1 >> 43))
+	out1 = x2
+	out2 = x3
+	return
+}
+
+_subborrowx_u43 :: #force_inline proc "contextless" (arg1: fiat.u1, arg2, arg3: u64) -> (out1: u64, out2: fiat.u1) {
+	x1 := ((i64(arg2) - i64(arg1)) - i64(arg3))
+	x2 := fiat.i1((x1 >> 43))
+	x3 := (u64(x1) & 0x7ffffffffff)
+	out1 = x3
+	out2 = (0x0 - fiat.u1(x2))
+	return
+}
+
+fe_carry_mul :: proc (out1: ^Tight_Field_Element, arg1, arg2: ^Loose_Field_Element) {
+	x2, x1 := bits.mul_u64(arg1[2], (arg2[2] * 0x5))
+	x4, x3 := bits.mul_u64(arg1[2], (arg2[1] * 0xa))
+	x6, x5 := bits.mul_u64(arg1[1], (arg2[2] * 0xa))
+	x8, x7 := bits.mul_u64(arg1[2], arg2[0])
+	x10, x9 := bits.mul_u64(arg1[1], (arg2[1] * 0x2))
+	x12, x11 := bits.mul_u64(arg1[1], arg2[0])
+	x14, x13 := bits.mul_u64(arg1[0], arg2[2])
+	x16, x15 := bits.mul_u64(arg1[0], arg2[1])
+	x18, x17 := bits.mul_u64(arg1[0], arg2[0])
+	x19, x20 := bits.add_u64(x5, x3, u64(0x0))
+	x21, _ := bits.add_u64(x6, x4, u64(fiat.u1(x20)))
+	x23, x24 := bits.add_u64(x17, x19, u64(0x0))
+	x25, _ := bits.add_u64(x18, x21, u64(fiat.u1(x24)))
+	x27 := ((x23 >> 44) | ((x25 << 20) & 0xffffffffffffffff))
+	x28 := (x23 & 0xfffffffffff)
+	x29, x30 := bits.add_u64(x9, x7, u64(0x0))
+	x31, _ := bits.add_u64(x10, x8, u64(fiat.u1(x30)))
+	x33, x34 := bits.add_u64(x13, x29, u64(0x0))
+	x35, _ := bits.add_u64(x14, x31, u64(fiat.u1(x34)))
+	x37, x38 := bits.add_u64(x11, x1, u64(0x0))
+	x39, _ := bits.add_u64(x12, x2, u64(fiat.u1(x38)))
+	x41, x42 := bits.add_u64(x15, x37, u64(0x0))
+	x43, _ := bits.add_u64(x16, x39, u64(fiat.u1(x42)))
+	x45, x46 := bits.add_u64(x27, x41, u64(0x0))
+	x47 := (u64(fiat.u1(x46)) + x43)
+	x48 := ((x45 >> 43) | ((x47 << 21) & 0xffffffffffffffff))
+	x49 := (x45 & 0x7ffffffffff)
+	x50, x51 := bits.add_u64(x48, x33, u64(0x0))
+	x52 := (u64(fiat.u1(x51)) + x35)
+	x53 := ((x50 >> 43) | ((x52 << 21) & 0xffffffffffffffff))
+	x54 := (x50 & 0x7ffffffffff)
+	x55 := (x53 * 0x5)
+	x56 := (x28 + x55)
+	x57 := (x56 >> 44)
+	x58 := (x56 & 0xfffffffffff)
+	x59 := (x57 + x49)
+	x60 := fiat.u1((x59 >> 43))
+	x61 := (x59 & 0x7ffffffffff)
+	x62 := (u64(x60) + x54)
+	out1[0] = x58
+	out1[1] = x61
+	out1[2] = x62
+}
+
+fe_carry_square :: proc (out1: ^Tight_Field_Element, arg1: ^Loose_Field_Element) {
+	x1 := (arg1[2] * 0x5)
+	x2 := (x1 * 0x2)
+	x3 := (arg1[2] * 0x2)
+	x4 := (arg1[1] * 0x2)
+	x6, x5 := bits.mul_u64(arg1[2], x1)
+	x8, x7 := bits.mul_u64(arg1[1], (x2 * 0x2))
+	x10, x9 := bits.mul_u64(arg1[1], (arg1[1] * 0x2))
+	x12, x11 := bits.mul_u64(arg1[0], x3)
+	x14, x13 := bits.mul_u64(arg1[0], x4)
+	x16, x15 := bits.mul_u64(arg1[0], arg1[0])
+	x17, x18 := bits.add_u64(x15, x7, u64(0x0))
+	x19, _ := bits.add_u64(x16, x8, u64(fiat.u1(x18)))
+	x21 := ((x17 >> 44) | ((x19 << 20) & 0xffffffffffffffff))
+	x22 := (x17 & 0xfffffffffff)
+	x23, x24 := bits.add_u64(x11, x9, u64(0x0))
+	x25, _ := bits.add_u64(x12, x10, u64(fiat.u1(x24)))
+	x27, x28 := bits.add_u64(x13, x5, u64(0x0))
+	x29, _ := bits.add_u64(x14, x6, u64(fiat.u1(x28)))
+	x31, x32 := bits.add_u64(x21, x27, u64(0x0))
+	x33 := (u64(fiat.u1(x32)) + x29)
+	x34 := ((x31 >> 43) | ((x33 << 21) & 0xffffffffffffffff))
+	x35 := (x31 & 0x7ffffffffff)
+	x36, x37 := bits.add_u64(x34, x23, u64(0x0))
+	x38 := (u64(fiat.u1(x37)) + x25)
+	x39 := ((x36 >> 43) | ((x38 << 21) & 0xffffffffffffffff))
+	x40 := (x36 & 0x7ffffffffff)
+	x41 := (x39 * 0x5)
+	x42 := (x22 + x41)
+	x43 := (x42 >> 44)
+	x44 := (x42 & 0xfffffffffff)
+	x45 := (x43 + x35)
+	x46 := fiat.u1((x45 >> 43))
+	x47 := (x45 & 0x7ffffffffff)
+	x48 := (u64(x46) + x40)
+	out1[0] = x44
+	out1[1] = x47
+	out1[2] = x48
+}
+
+fe_carry :: proc "contextless" (out1: ^Tight_Field_Element, arg1: ^Loose_Field_Element) {
+	x1 := arg1[0]
+	x2 := ((x1 >> 44) + arg1[1])
+	x3 := ((x2 >> 43) + arg1[2])
+	x4 := ((x1 & 0xfffffffffff) + ((x3 >> 43) * 0x5))
+	x5 := (u64(fiat.u1((x4 >> 44))) + (x2 & 0x7ffffffffff))
+	x6 := (x4 & 0xfffffffffff)
+	x7 := (x5 & 0x7ffffffffff)
+	x8 := (u64(fiat.u1((x5 >> 43))) + (x3 & 0x7ffffffffff))
+	out1[0] = x6
+	out1[1] = x7
+	out1[2] = x8
+}
+
+fe_add :: proc "contextless" (out1: ^Loose_Field_Element, arg1, arg2: ^Tight_Field_Element) {
+	x1 := (arg1[0] + arg2[0])
+	x2 := (arg1[1] + arg2[1])
+	x3 := (arg1[2] + arg2[2])
+	out1[0] = x1
+	out1[1] = x2
+	out1[2] = x3
+}
+
+fe_sub :: proc "contextless" (out1: ^Loose_Field_Element, arg1, arg2: ^Tight_Field_Element) {
+	x1 := ((0x1ffffffffff6 + arg1[0]) - arg2[0])
+	x2 := ((0xffffffffffe + arg1[1]) - arg2[1])
+	x3 := ((0xffffffffffe + arg1[2]) - arg2[2])
+	out1[0] = x1
+	out1[1] = x2
+	out1[2] = x3
+}
+
+fe_opp :: proc "contextless" (out1: ^Loose_Field_Element, arg1: ^Tight_Field_Element) {
+	x1 := (0x1ffffffffff6 - arg1[0])
+	x2 := (0xffffffffffe - arg1[1])
+	x3 := (0xffffffffffe - arg1[2])
+	out1[0] = x1
+	out1[1] = x2
+	out1[2] = x3
+}
+
+fe_cond_assign :: proc "contextless" (out1, arg1: ^Tight_Field_Element, arg2: bool) {
+	x1 := fiat.cmovznz_u64(fiat.u1(arg2), out1[0], arg1[0])
+	x2 := fiat.cmovznz_u64(fiat.u1(arg2), out1[1], arg1[1])
+	x3 := fiat.cmovznz_u64(fiat.u1(arg2), out1[2], arg1[2])
+	out1[0] = x1
+	out1[1] = x2
+	out1[2] = x3
+}
+
+fe_to_bytes :: proc "contextless" (out1: ^[32]byte, arg1: ^Tight_Field_Element) {
+	x1, x2 := _subborrowx_u44(0x0, arg1[0], 0xffffffffffb)
+	x3, x4 := _subborrowx_u43(x2, arg1[1], 0x7ffffffffff)
+	x5, x6 := _subborrowx_u43(x4, arg1[2], 0x7ffffffffff)
+	x7 := fiat.cmovznz_u64(x6, u64(0x0), 0xffffffffffffffff)
+	x8, x9 := _addcarryx_u44(0x0, x1, (x7 & 0xffffffffffb))
+	x10, x11 := _addcarryx_u43(x9, x3, (x7 & 0x7ffffffffff))
+	x12, _ := _addcarryx_u43(x11, x5, (x7 & 0x7ffffffffff))
+	x14 := (x12 << 7)
+	x15 := (x10 << 4)
+	x16 := (u8(x8) & 0xff)
+	x17 := (x8 >> 8)
+	x18 := (u8(x17) & 0xff)
+	x19 := (x17 >> 8)
+	x20 := (u8(x19) & 0xff)
+	x21 := (x19 >> 8)
+	x22 := (u8(x21) & 0xff)
+	x23 := (x21 >> 8)
+	x24 := (u8(x23) & 0xff)
+	x25 := u8((x23 >> 8))
+	x26 := (x15 + u64(x25))
+	x27 := (u8(x26) & 0xff)
+	x28 := (x26 >> 8)
+	x29 := (u8(x28) & 0xff)
+	x30 := (x28 >> 8)
+	x31 := (u8(x30) & 0xff)
+	x32 := (x30 >> 8)
+	x33 := (u8(x32) & 0xff)
+	x34 := (x32 >> 8)
+	x35 := (u8(x34) & 0xff)
+	x36 := u8((x34 >> 8))
+	x37 := (x14 + u64(x36))
+	x38 := (u8(x37) & 0xff)
+	x39 := (x37 >> 8)
+	x40 := (u8(x39) & 0xff)
+	x41 := (x39 >> 8)
+	x42 := (u8(x41) & 0xff)
+	x43 := (x41 >> 8)
+	x44 := (u8(x43) & 0xff)
+	x45 := (x43 >> 8)
+	x46 := (u8(x45) & 0xff)
+	x47 := (x45 >> 8)
+	x48 := (u8(x47) & 0xff)
+	x49 := u8((x47 >> 8))
+	out1[0] = x16
+	out1[1] = x18
+	out1[2] = x20
+	out1[3] = x22
+	out1[4] = x24
+	out1[5] = x27
+	out1[6] = x29
+	out1[7] = x31
+	out1[8] = x33
+	out1[9] = x35
+	out1[10] = x38
+	out1[11] = x40
+	out1[12] = x42
+	out1[13] = x44
+	out1[14] = x46
+	out1[15] = x48
+	out1[16] = x49
+}
+
+_fe_from_bytes :: proc "contextless" (out1: ^Tight_Field_Element, arg1: ^[32]byte) {
+	x1 := (u64(arg1[16]) << 41)
+	x2 := (u64(arg1[15]) << 33)
+	x3 := (u64(arg1[14]) << 25)
+	x4 := (u64(arg1[13]) << 17)
+	x5 := (u64(arg1[12]) << 9)
+	x6 := (u64(arg1[11]) * u64(0x2))
+	x7 := (u64(arg1[10]) << 36)
+	x8 := (u64(arg1[9]) << 28)
+	x9 := (u64(arg1[8]) << 20)
+	x10 := (u64(arg1[7]) << 12)
+	x11 := (u64(arg1[6]) << 4)
+	x12 := (u64(arg1[5]) << 40)
+	x13 := (u64(arg1[4]) << 32)
+	x14 := (u64(arg1[3]) << 24)
+	x15 := (u64(arg1[2]) << 16)
+	x16 := (u64(arg1[1]) << 8)
+	x17 := arg1[0]
+	x18 := (x16 + u64(x17))
+	x19 := (x15 + x18)
+	x20 := (x14 + x19)
+	x21 := (x13 + x20)
+	x22 := (x12 + x21)
+	x23 := (x22 & 0xfffffffffff)
+	x24 := u8((x22 >> 44))
+	x25 := (x11 + u64(x24))
+	x26 := (x10 + x25)
+	x27 := (x9 + x26)
+	x28 := (x8 + x27)
+	x29 := (x7 + x28)
+	x30 := (x29 & 0x7ffffffffff)
+	x31 := fiat.u1((x29 >> 43))
+	x32 := (x6 + u64(x31))
+	x33 := (x5 + x32)
+	x34 := (x4 + x33)
+	x35 := (x3 + x34)
+	x36 := (x2 + x35)
+	x37 := (x1 + x36)
+	out1[0] = x23
+	out1[1] = x30
+	out1[2] = x37
+}
+
+fe_relax :: proc "contextless" (out1: ^Loose_Field_Element, arg1: ^Tight_Field_Element) {
+	x1 := arg1[0]
+	x2 := arg1[1]
+	x3 := arg1[2]
+	out1[0] = x1
+	out1[1] = x2
+	out1[2] = x3
+}
+
+// The following routines were added by hand, and do not come from fiat-crypto.
+
+fe_zero :: proc "contextless" (out1: ^Tight_Field_Element) {
+	out1[0] = 0
+	out1[1] = 0
+	out1[2] = 0
+}
+
+fe_set :: #force_inline proc "contextless" (out1, arg1: ^Tight_Field_Element) {
+	x1 := arg1[0]
+	x2 := arg1[1]
+	x3 := arg1[2]
+	out1[0] = x1
+	out1[1] = x2
+	out1[2] = x3
+}
+
+fe_cond_swap :: proc "contextless" (out1, out2: ^Tight_Field_Element, arg1: bool) {
+	mask := -u64(arg1)
+	x := (out1[0] ~ out2[0]) & mask
+	x1, y1 := out1[0] ~ x, out2[0] ~ x
+	x = (out1[1] ~ out2[1]) & mask
+	x2, y2 := out1[1] ~ x, out2[1] ~ x
+	x = (out1[2] ~ out2[2]) & mask
+	x3, y3 := out1[2] ~ x, out2[2] ~ x
+	out1[0], out2[0] = x1, y1
+	out1[1], out2[1] = x2, y2
+	out1[2], out2[2] = x3, y3
+}
diff --git a/core/crypto/poly1305/poly1305.odin b/core/crypto/poly1305/poly1305.odin
new file mode 100644
index 000000000..8986be879
--- /dev/null
+++ b/core/crypto/poly1305/poly1305.odin
@@ -0,0 +1,163 @@
+package poly1305
+
+import "core:crypto"
+import "core:crypto/util"
+import field "core:crypto/_fiat/field_poly1305"
+import "core:mem"
+
+KEY_SIZE :: 32
+TAG_SIZE :: 16
+
+_BLOCK_SIZE :: 16
+
+sum :: proc (dst, msg, key: []byte) {
+	ctx: Context = ---
+
+	init(&ctx, key)
+	update(&ctx, msg)
+	final(&ctx, dst)
+}
+
+verify :: proc (tag, msg, key: []byte) -> bool {
+	ctx: Context = ---
+	derived_tag: [16]byte = ---
+
+	if len(tag) != TAG_SIZE {
+		panic("crypto/poly1305: invalid tag size")
+	}
+
+	init(&ctx, key)
+	update(&ctx, msg)
+	final(&ctx, derived_tag[:])
+
+	return crypto.compare_constant_time(derived_tag[:], tag) == 1
+}
+
+Context :: struct {
+	_r: field.Tight_Field_Element,
+	_a: field.Tight_Field_Element,
+	_s: field.Tight_Field_Element,
+
+	_buffer: [_BLOCK_SIZE]byte,
+	_leftover: int,
+
+	_is_initialized: bool,
+}
+
+init :: proc (ctx: ^Context, key: []byte) {
+	if len(key) != KEY_SIZE {
+		panic("crypto/poly1305: invalid key size")
+	}
+
+	// r = le_bytes_to_num(key[0..15])
+	// r = clamp(r) (r &= 0xffffffc0ffffffc0ffffffc0fffffff)
+	tmp_lo := util.U64_LE(key[0:8]) & 0x0ffffffc0fffffff
+	tmp_hi := util.U64_LE(key[8:16]) & 0xffffffc0ffffffc
+	field.fe_from_u64s(&ctx._r, tmp_lo, tmp_hi)
+
+	// s = le_bytes_to_num(key[16..31])
+	field.fe_from_bytes(&ctx._s, key[16:32], 0)
+
+	// a = 0
+	field.fe_zero(&ctx._a)
+
+	// No leftover in buffer
+	ctx._leftover = 0
+
+	ctx._is_initialized = true
+}
+
+update :: proc (ctx: ^Context, data: []byte) {
+	assert(ctx._is_initialized)
+
+	msg := data
+	msg_len := len(data)
+
+	// Handle leftover
+	if ctx._leftover > 0 {
+		want := min(_BLOCK_SIZE - ctx._leftover, msg_len)
+		copy_slice(ctx._buffer[ctx._leftover:], msg[:want])
+		msg_len = msg_len - want
+		msg = msg[want:]
+		ctx._leftover = ctx._leftover + want
+		if ctx._leftover < _BLOCK_SIZE {
+			return
+		}
+		_blocks(ctx, ctx._buffer[:])
+		ctx._leftover = 0
+	}
+
+	// Process full blocks
+	if msg_len >= _BLOCK_SIZE {
+		want := msg_len & (~int(_BLOCK_SIZE - 1))
+		_blocks(ctx, msg[:want])
+		msg = msg[want:]
+		msg_len = msg_len - want
+	}
+
+	// Store leftover
+	if msg_len > 0 {
+		// TODO: While -donna does it this way, I'm fairly sure that
+		// `ctx._leftover == 0` is an invariant at this point.
+		copy(ctx._buffer[ctx._leftover:], msg)
+		ctx._leftover = ctx._leftover + msg_len
+	}
+}
+
+final :: proc (ctx: ^Context, dst: []byte) {
+	assert(ctx._is_initialized)
+
+	if len(dst) != TAG_SIZE {
+		panic("poly1305: invalid destination tag size")
+	}
+
+	// Process remaining block
+	if ctx._leftover > 0 {
+		ctx._buffer[ctx._leftover] = 1
+		for i := ctx._leftover + 1; i < _BLOCK_SIZE; i = i + 1 {
+			ctx._buffer[i] = 0
+		}
+		_blocks(ctx, ctx._buffer[:], true)
+	}
+
+	// a += s
+	field.fe_add(field.fe_relax_cast(&ctx._a), &ctx._a, &ctx._s) // _a unreduced
+	field.fe_carry(&ctx._a, field.fe_relax_cast(&ctx._a)) // _a reduced
+
+	// return num_to_16_le_bytes(a)
+	tmp: [32]byte = ---
+	field.fe_to_bytes(&tmp, &ctx._a)
+	copy_slice(dst, tmp[0:16])
+
+	reset(ctx)
+}
+
+reset :: proc (ctx: ^Context) {
+	mem.zero_explicit(&ctx._r, size_of(ctx._r))
+	mem.zero_explicit(&ctx._a, size_of(ctx._a))
+	mem.zero_explicit(&ctx._s, size_of(ctx._s))
+	mem.zero_explicit(&ctx._buffer, size_of(ctx._buffer))
+
+	ctx._is_initialized = false
+}
+
+_blocks :: proc (ctx: ^Context, msg: []byte, final := false) {
+	n: field.Tight_Field_Element = ---
+	final_byte := byte(!final)
+
+	data := msg
+	data_len := len(data)
+	for data_len >= _BLOCK_SIZE {
+		// n = le_bytes_to_num(msg[((i-1)*16)..*i*16] | [0x01])
+		field.fe_from_bytes(&n, data[:_BLOCK_SIZE], final_byte, false)
+
+		// a += n
+		field.fe_add(field.fe_relax_cast(&ctx._a), &ctx._a, &n) // _a unreduced
+
+		// a = (r * a) % p
+		field.fe_carry_mul(&ctx._a, field.fe_relax_cast(&ctx._a), field.fe_relax_cast(&ctx._r)) // _a reduced
+
+		data = data[_BLOCK_SIZE:]
+		data_len = data_len - _BLOCK_SIZE
+	}
+}
diff --git a/tests/core/crypto/test_core_crypto.odin b/tests/core/crypto/test_core_crypto.odin
index 768ba242f..c27b5c6bc 100644
--- a/tests/core/crypto/test_core_crypto.odin
+++ b/tests/core/crypto/test_core_crypto.odin
@@ -116,6 +116,7 @@ main :: proc() {
     test_haval_256(&t)
 
     // "modern" crypto tests
+    test_poly1305(&t)
     test_x25519(&t)
 
     bench_modern(&t)
diff --git a/tests/core/crypto/test_core_crypto_modern.odin b/tests/core/crypto/test_core_crypto_modern.odin
index 4d7f08bb1..f4f07928e 100644
--- a/tests/core/crypto/test_core_crypto_modern.odin
+++ b/tests/core/crypto/test_core_crypto_modern.odin
@@ -4,6 +4,7 @@ import "core:testing"
 import "core:fmt"
 import "core:time"
 
+import "core:crypto/poly1305"
 import "core:crypto/x25519"
 
 _digit_value :: proc(r: rune) -> int {
@@ -27,6 +28,70 @@ _decode_hex32 :: proc(s: string) -> [32]byte{
 	return b
 }
 
+@(test)
+test_poly1305 :: proc(t: ^testing.T) {
+	log(t, "Testing poly1305")
+
+	// Test cases taken from poly1305-donna.
+	key := [poly1305.KEY_SIZE]byte{
+		0xee,0xa6,0xa7,0x25,0x1c,0x1e,0x72,0x91,
+		0x6d,0x11,0xc2,0xcb,0x21,0x4d,0x3c,0x25,
+		0x25,0x39,0x12,0x1d,0x8e,0x23,0x4e,0x65,
+		0x2d,0x65,0x1f,0xa4,0xc8,0xcf,0xf8,0x80,
+	}
+
+	msg := [131]byte{
+		0x8e,0x99,0x3b,0x9f,0x48,0x68,0x12,0x73,
+		0xc2,0x96,0x50,0xba,0x32,0xfc,0x76,0xce,
+		0x48,0x33,0x2e,0xa7,0x16,0x4d,0x96,0xa4,
+		0x47,0x6f,0xb8,0xc5,0x31,0xa1,0x18,0x6a,
+		0xc0,0xdf,0xc1,0x7c,0x98,0xdc,0xe8,0x7b,
+		0x4d,0xa7,0xf0,0x11,0xec,0x48,0xc9,0x72,
+		0x71,0xd2,0xc2,0x0f,0x9b,0x92,0x8f,0xe2,
+		0x27,0x0d,0x6f,0xb8,0x63,0xd5,0x17,0x38,
+		0xb4,0x8e,0xee,0xe3,0x14,0xa7,0xcc,0x8a,
+		0xb9,0x32,0x16,0x45,0x48,0xe5,0x26,0xae,
+		0x90,0x22,0x43,0x68,0x51,0x7a,0xcf,0xea,
+		0xbd,0x6b,0xb3,0x73,0x2b,0xc0,0xe9,0xda,
+		0x99,0x83,0x2b,0x61,0xca,0x01,0xb6,0xde,
+		0x56,0x24,0x4a,0x9e,0x88,0xd5,0xf9,0xb3,
+		0x79,0x73,0xf6,0x22,0xa4,0x3d,0x14,0xa6,
+		0x59,0x9b,0x1f,0x65,0x4c,0xb4,0x5a,0x74,
+		0xe3,0x55,0xa5,
+	}
+
+	tag := [poly1305.TAG_SIZE]byte{
+		0xf3,0xff,0xc7,0x70,0x3f,0x94,0x00,0xe5,
+		0x2a,0x7d,0xfb,0x4b,0x3d,0x33,0x05,0xd9,
+	}
+	tag_str := hex_string(tag[:])
+
+	// Verify - oneshot + compare
+	ok := poly1305.verify(tag[:], msg[:], key[:])
+	expect(t, ok, "oneshot verify call failed")
+
+	// Sum - oneshot
+	derived_tag: [poly1305.TAG_SIZE]byte
+	poly1305.sum(derived_tag[:], msg[:], key[:])
+	derived_tag_str := hex_string(derived_tag[:])
+	expect(t, derived_tag_str == tag_str, fmt.tprintf("Expected %s for sum(msg, key), but got %s instead", tag_str, derived_tag_str))
+
+	// Incremental
+	mem.zero(&derived_tag, size_of(derived_tag))
+	ctx: poly1305.Context = ---
+	poly1305.init(&ctx, key[:])
+	read_lengths := [11]int{32, 64, 16, 8, 4, 2, 1, 1, 1, 1, 1}
+	off := 0
+	for read_length in read_lengths {
+		to_read := msg[off:off+read_length]
+		poly1305.update(&ctx, to_read)
+		off = off + read_length
+	}
+	poly1305.final(&ctx, derived_tag[:])
+	derived_tag_str = hex_string(derived_tag[:])
+	expect(t, derived_tag_str == tag_str, fmt.tprintf("Expected %s for init/update/final - incremental, but got %s instead", tag_str, derived_tag_str))
+}
+
 TestECDH :: struct {
 	scalar:  string,
 	point:   string,
@@ -76,9 +141,75 @@ test_x25519 :: proc(t: ^testing.T) {
 bench_modern :: proc(t: ^testing.T) {
 	fmt.println("Starting benchmarks:")
 
+	bench_poly1305(t)
 	bench_x25519(t)
 }
 
+_setup_poly1305 :: proc(options: ^time.Benchmark_Options, allocator := context.allocator) -> (err: time.Benchmark_Error) {
+	assert(options != nil)
+
+	options.input = make([]u8, options.bytes, allocator)
+	return nil if len(options.input) == options.bytes else .Allocation_Error
+}
+
+_teardown_poly1305 :: proc(options: ^time.Benchmark_Options, allocator := context.allocator) -> (err: time.Benchmark_Error) {
+	assert(options != nil)
+
+	delete(options.input)
+	return nil
+}
+
+_benchmark_poly1305 :: proc(options: ^time.Benchmark_Options, allocator := context.allocator) -> (err: time.Benchmark_Error) {
+	buf := options.input
+	key := [poly1305.KEY_SIZE]byte{
+		0xde, 0xad, 0xbe, 0xef, 0xde, 0xad, 0xbe, 0xef,
+		0xde, 0xad, 0xbe, 0xef, 0xde, 0xad, 0xbe, 0xef,
+		0xde, 0xad, 0xbe, 0xef, 0xde, 0xad, 0xbe, 0xef,
+		0xde, 0xad, 0xbe, 0xef, 0xde, 0xad, 0xbe, 0xef,
+	}
+
+	tag: [poly1305.TAG_SIZE]byte = ---
+	for _ in 0..=options.rounds {
+		poly1305.sum(tag[:], buf, key[:])
+	}
+	options.count     = options.rounds
+	options.processed = options.rounds * options.bytes
+	//options.hash      = u128(h)
+	return nil
+}
+
+benchmark_print :: proc(name: string, options: ^time.Benchmark_Options) {
+	fmt.printf("\t[%v] %v rounds, %v bytes processed in %v ns\n\t\t%5.3f rounds/s, %5.3f MiB/s\n",
+		name,
+		options.rounds,
+		options.processed,
+		time.duration_nanoseconds(options.duration),
+		options.rounds_per_second,
+		options.megabytes_per_second,
+	)
+}
+
+bench_poly1305 :: proc(t: ^testing.T) {
+	name    := "Poly1305 64 zero bytes"
+	options := &time.Benchmark_Options{
+		rounds   = 1_000,
+		bytes    = 64,
+		setup    = _setup_poly1305,
+		bench    = _benchmark_poly1305,
+		teardown = _teardown_poly1305,
+	}
+
+	err  := time.benchmark(options, context.allocator)
+	expect(t, err == nil, name)
+	benchmark_print(name, options)
+
+	name = "Poly1305 1024 zero bytes"
+	options.bytes = 1024
+	err = time.benchmark(options, context.allocator)
+	expect(t, err == nil, name)
+	benchmark_print(name, options)
+}
+
 bench_x25519 :: proc(t: ^testing.T) {
 	point := _decode_hex32("deadbeefdeadbeefdeadbeefdeadbeefdeadbeefdeadbeefdeadbeefdeadbeef")
 	scalar := _decode_hex32("cafebabecafebabecafebabecafebabecafebabecafebabecafebabecafebabe")

From 4647081f4953ad22810b3ff120d4c499f4240701 Mon Sep 17 00:00:00 2001
From: Yawning Angel <yawning@schwanenlied.me>
Date: Mon, 8 Nov 2021 04:47:42 +0000
Subject: [PATCH 18/38] core/crypto/poly1305: Triple performance on amd64 with
 -o:speed

---
 core/crypto/_fiat/field_poly1305/field.odin | 47 +++++++++++++++------
 1 file changed, 34 insertions(+), 13 deletions(-)

diff --git a/core/crypto/_fiat/field_poly1305/field.odin b/core/crypto/_fiat/field_poly1305/field.odin
index 642949b02..bfb7cf1f9 100644
--- a/core/crypto/_fiat/field_poly1305/field.odin
+++ b/core/crypto/_fiat/field_poly1305/field.odin
@@ -11,25 +11,46 @@ fe_tighten_cast :: #force_inline proc "contextless" (arg1: ^Loose_Field_Element)
 	return transmute(^Tight_Field_Element)(arg1)
 }
 
-fe_from_bytes :: proc (out1: ^Tight_Field_Element, arg1: []byte, arg2: byte, sanitize: bool = true) {
-	// fiat-crypto's deserialization routine wants 256-bits of input, but
-	// r/s are 128-bits long, and block processing works on 128-bits plus a
-	// final bit.
+fe_from_bytes :: #force_inline proc (out1: ^Tight_Field_Element, arg1: []byte, arg2: byte, sanitize: bool = true) {
+	// fiat-crypto's deserialization routine effectively processes a
+	// single byte at a time, and wants 256-bits of input for a value
+	// that will be 128-bits or 129-bits.
 	//
-	// This is more ergonomic, and while the copy is unfortunate, this avoids
-	// having to alter the fiat-crypto derived code.
+	// This is somewhat cumbersome to use, so at a minimum a wrapper
+	// makes implementing the actual MAC block processing considerably
+	// neater.
 
 	assert(len(arg1) == 16)
 
-	tmp: [32]byte
-	copy_slice(tmp[0:16], arg1[:])
-	tmp[16] = arg2
+	when ODIN_ARCH == "386" || ODIN_ARCH == "amd64" {
+		// While it may be unwise to do deserialization here on our
+		// own when fiat-crypto provides equivalent functionality,
+		// doing it this way provides a little under 3x performance
+		// improvement when optimization is enabled.
+		src_p := transmute(^[2]u64)(&arg1[0])
+		lo := src_p[0]
+		hi := src_p[1]
 
-	_fe_from_bytes(out1, &tmp)
+		// This is inspired by poly1305-donna, though adjustments were
+		// made since a Tight_Field_Element's limbs are 44-bits, 43-bits,
+		// and 43-bits wide.
+		//
+		// Note: This could be transplated into fe_from_u64s, but that
+		// code is called once per MAC, and is non-criticial path.
+		hibit := u64(arg2) << 41 // arg2 << 128
+		out1[0] = lo & 0xfffffffffff
+		out1[1] = ((lo >> 44) | (hi << 20)) & 0x7ffffffffff
+		out1[2] = ((hi >> 23) & 0x7ffffffffff) | hibit
+	} else {
+		tmp: [32]byte
+		copy_slice(tmp[0:16], arg1[:])
+		tmp[16] = arg2
 
-	// Need to sanitize the temporary buffer when deserializing `s`.
-	if sanitize {
-		mem.zero_explicit(&tmp, size_of(tmp))
+		_fe_from_bytes(out1, &tmp)
+		if sanitize {
+			// This is used to deserialize `s` which is confidential.
+			mem.zero_explicit(&tmp, size_of(tmp))
+		}
 	}
 }
 

From 7bed3176360df79d88e1e6022e62b985d3648579 Mon Sep 17 00:00:00 2001
From: Yawning Angel <yawning@schwanenlied.me>
Date: Sat, 6 Nov 2021 23:15:50 +0000
Subject: [PATCH 19/38] core/crypto: Add chacha20

This package implements the ChaCha20 stream cipher as specified in
RFC 8439, and the somewhat non-standard XChaCha20 variant that supports
a 192-bit nonce.

While an IETF draft for XChaCha20 standardization exists,
implementations that pre-date the draft use a 64-bit counter, instead of
the IETF-style 32-bit one.  This implementation opts for the latter as
compatibility with libsodium is more important than compatibility with
an expired IETF draft.
---
 core/crypto/chacha20/chacha20.odin            | 581 ++++++++++++++++++
 tests/core/crypto/test_core_crypto.odin       |   1 +
 .../core/crypto/test_core_crypto_modern.odin  | 150 ++++-
 3 files changed, 728 insertions(+), 4 deletions(-)
 create mode 100644 core/crypto/chacha20/chacha20.odin

diff --git a/core/crypto/chacha20/chacha20.odin b/core/crypto/chacha20/chacha20.odin
new file mode 100644
index 000000000..f6f551692
--- /dev/null
+++ b/core/crypto/chacha20/chacha20.odin
@@ -0,0 +1,581 @@
+package chacha20
+
+import "core:crypto/util"
+import "core:math/bits"
+import "core:mem"
+
+KEY_SIZE :: 32
+NONCE_SIZE :: 12
+XNONCE_SIZE :: 24
+
+_MAX_CTR_IETF :: 0xffffffff
+
+_BLOCK_SIZE :: 64
+_STATE_SIZE_U32 :: 16
+_ROUNDS :: 20
+
+_SIGMA_0 : u32 : 0x61707865
+_SIGMA_1 : u32 : 0x3320646e
+_SIGMA_2 : u32 : 0x79622d32
+_SIGMA_3 : u32 : 0x6b206574
+
+Context :: struct {
+	_s: [_STATE_SIZE_U32]u32,
+
+	_buffer: [_BLOCK_SIZE]byte,
+	_off: int,
+
+	_is_ietf_flavor: bool,
+	_is_initialized: bool,
+}
+
+init :: proc (ctx: ^Context, key, nonce: []byte) {
+	if len(key) != KEY_SIZE {
+		panic("crypto/chacha20: invalid ChaCha20 key size")
+	}
+	if n_len := len(nonce); n_len != NONCE_SIZE && n_len != XNONCE_SIZE {
+		panic("crypto/chacha20: invalid (X)ChaCha20 nonce size")
+	}
+
+	k, n := key, nonce
+
+	// Derive the XChaCha20 subkey and sub-nonce via HChaCha20.
+	is_xchacha := len(nonce) == XNONCE_SIZE
+	if is_xchacha {
+		sub_key := ctx._buffer[:KEY_SIZE]
+		_hchacha20(sub_key, k, n)
+		k = sub_key
+		n = n[16:24]
+	}
+
+	ctx._s[0] = _SIGMA_0
+	ctx._s[1] = _SIGMA_1
+	ctx._s[2] = _SIGMA_2
+	ctx._s[3] = _SIGMA_3
+	ctx._s[4] = util.U32_LE(k[0:4])
+	ctx._s[5] = util.U32_LE(k[4:8])
+	ctx._s[6] = util.U32_LE(k[8:12])
+	ctx._s[7] = util.U32_LE(k[12:16])
+	ctx._s[8] = util.U32_LE(k[16:20])
+	ctx._s[9] = util.U32_LE(k[20:24])
+	ctx._s[10] = util.U32_LE(k[24:28])
+	ctx._s[11] = util.U32_LE(k[28:32])
+	ctx._s[12] = 0
+	if !is_xchacha {
+		ctx._s[13] = util.U32_LE(n[0:4])
+		ctx._s[14] = util.U32_LE(n[4:8])
+		ctx._s[15] = util.U32_LE(n[8:12])
+	} else {
+		ctx._s[13] = 0
+		ctx._s[14] = util.U32_LE(n[0:4])
+		ctx._s[15] = util.U32_LE(n[4:8])
+
+		// The sub-key is stored in the keystream buffer.  While
+		// this will be overwritten in most circumstances, explicitly
+		// clear it out early.
+		mem.zero_explicit(&ctx._buffer, KEY_SIZE)
+	}
+
+	ctx._off = _BLOCK_SIZE
+	ctx._is_ietf_flavor = !is_xchacha
+	ctx._is_initialized = true
+}
+
+seek :: proc (ctx: ^Context, block_nr: u64) {
+	assert(ctx._is_initialized)
+
+	if ctx._is_ietf_flavor {
+		if block_nr > _MAX_CTR_IETF {
+			panic("crypto/chacha20: attempted to seek past maximum counter")
+		}
+	} else {
+		ctx._s[13] = u32(block_nr >> 32)
+	}
+	ctx._s[12] = u32(block_nr)
+	ctx._off = _BLOCK_SIZE
+}
+
+xor_bytes :: proc (ctx: ^Context, dst, src: []byte) {
+	assert(ctx._is_initialized)
+
+	// TODO: Enforcing that dst and src alias exactly or not at all
+	// is a good idea, though odd aliasing should be extremely uncommon.
+
+	src, dst := src, dst
+	if dst_len := len(dst); dst_len < len(src) {
+		src = src[:dst_len]
+	}
+
+	for remaining := len(src); remaining > 0; {
+		// Process multiple blocks at once
+		if ctx._off == _BLOCK_SIZE {
+			if nr_blocks := remaining / _BLOCK_SIZE; nr_blocks > 0 {
+				direct_bytes := nr_blocks * _BLOCK_SIZE
+				_do_blocks(ctx, dst, src, nr_blocks)
+				remaining -= direct_bytes
+				if remaining == 0 {
+					return
+				}
+				dst = dst[direct_bytes:]
+				src = src[direct_bytes:]
+			}
+
+			// If there is a partial block, generate and buffer 1 block
+			// worth of keystream.
+			_do_blocks(ctx, ctx._buffer[:], nil, 1)
+			ctx._off = 0
+		}
+
+		// Process partial blocks from the buffered keystream.
+		to_xor := min(_BLOCK_SIZE - ctx._off, remaining)
+		buffered_keystream := ctx._buffer[ctx._off:]
+		for i := 0; i < to_xor; i = i + 1 {
+			dst[i] = buffered_keystream[i] ~ src[i]
+		}
+		ctx._off += to_xor
+		dst = dst[to_xor:]
+		src = src[to_xor:]
+		remaining -= to_xor
+	}
+}
+
+keystream_bytes :: proc (ctx: ^Context, dst: []byte) {
+	assert(ctx._is_initialized)
+
+	dst := dst
+	for remaining := len(dst); remaining > 0; {
+		// Process multiple blocks at once
+		if ctx._off == _BLOCK_SIZE {
+			if nr_blocks := remaining / _BLOCK_SIZE; nr_blocks > 0 {
+				direct_bytes := nr_blocks * _BLOCK_SIZE
+				_do_blocks(ctx, dst, nil, nr_blocks)
+				remaining -= direct_bytes
+				if remaining == 0 {
+					return
+				}
+				dst = dst[direct_bytes:]
+			}
+
+			// If there is a partial block, generate and buffer 1 block
+			// worth of keystream.
+			_do_blocks(ctx, ctx._buffer[:], nil, 1)
+			ctx._off = 0
+		}
+
+		// Process partial blocks from the buffered keystream.
+		to_copy := min(_BLOCK_SIZE - ctx._off, remaining)
+		buffered_keystream := ctx._buffer[ctx._off:]
+		copy(dst[:to_copy], buffered_keystream[:to_copy])
+		ctx._off += to_copy
+		dst = dst[to_copy:]
+		remaining -= to_copy
+	}
+}
+
+reset :: proc (ctx: ^Context) {
+	mem.zero_explicit(&ctx._s, size_of(ctx._s))
+	mem.zero_explicit(&ctx._buffer, size_of(ctx._buffer))
+
+	ctx._is_initialized = false
+}
+
+_do_blocks :: proc (ctx: ^Context, dst, src: []byte, nr_blocks: int) {
+	// Enforce the maximum consumed keystream per nonce.
+	//
+	// While all modern "standard" definitions of ChaCha20 use
+	// the IETF 32-bit counter, for XChaCha20 most common
+	// implementations allow for a 64-bit counter.
+	//
+	// Honestly, the answer here is "use a MRAE primitive", but
+	// go with common practice in the case of XChaCha20.
+	if ctx._is_ietf_flavor {
+		if u64(ctx._s[12]) + u64(nr_blocks) > 0xffffffff {
+			panic("crypto/chacha20: maximum ChaCha20 keystream per nonce reached")
+		}
+	} else {
+		ctr := (u64(ctx._s[13]) << 32) | u64(ctx._s[12])
+		if _, carry := bits.add_u64(ctr, u64(nr_blocks), 0); carry != 0 {
+			panic("crypto/chacha20: maximum XChaCha20 keystream per nonce reached")
+		}
+	}
+
+	dst, src := dst, src
+	x := &ctx._s
+	for n := 0; n < nr_blocks; n = n + 1 {
+		x0, x1, x2, x3 := _SIGMA_0, _SIGMA_1, _SIGMA_2, _SIGMA_3
+		x4, x5, x6, x7, x8, x9, x10, x11, x12, x13, x14, x15 := x[4], x[5], x[6], x[7], x[8], x[9], x[10], x[11], x[12], x[13], x[14], x[15]
+
+		for i := _ROUNDS; i > 0; i = i - 2 {
+			// Even when forcing inlining manually inlining all of
+			// these is decently faster.
+
+			// quarterround(x, 0, 4, 8, 12)
+			x0 += x4
+			x12 ~= x0
+			x12 = util.ROTL32(x12, 16)
+			x8 += x12
+			x4 ~= x8
+			x4 = util.ROTL32(x4, 12)
+			x0 += x4
+			x12 ~= x0
+			x12 = util.ROTL32(x12, 8)
+			x8 += x12
+			x4 ~= x8
+			x4 = util.ROTL32(x4, 7)
+
+			// quarterround(x, 1, 5, 9, 13)
+			x1 += x5
+			x13 ~= x1
+			x13 = util.ROTL32(x13, 16)
+			x9 += x13
+			x5 ~= x9
+			x5 = util.ROTL32(x5, 12)
+			x1 += x5
+			x13 ~= x1
+			x13 = util.ROTL32(x13, 8)
+			x9 += x13
+			x5 ~= x9
+			x5 = util.ROTL32(x5, 7)
+
+			// quarterround(x, 2, 6, 10, 14)
+			x2 += x6
+			x14 ~= x2
+			x14 = util.ROTL32(x14, 16)
+			x10 += x14
+			x6 ~= x10
+			x6 = util.ROTL32(x6, 12)
+			x2 += x6
+			x14 ~= x2
+			x14 = util.ROTL32(x14, 8)
+			x10 += x14
+			x6 ~= x10
+			x6 = util.ROTL32(x6, 7)
+
+			// quarterround(x, 3, 7, 11, 15)
+			x3 += x7
+			x15 ~= x3
+			x15 = util.ROTL32(x15, 16)
+			x11 += x15
+			x7 ~= x11
+			x7 = util.ROTL32(x7, 12)
+			x3 += x7
+			x15 ~= x3
+			x15 = util.ROTL32(x15, 8)
+			x11 += x15
+			x7 ~= x11
+			x7 = util.ROTL32(x7, 7)
+
+			// quarterround(x, 0, 5, 10, 15)
+			x0 += x5
+			x15 ~= x0
+			x15 = util.ROTL32(x15, 16)
+			x10 += x15
+			x5 ~= x10
+			x5 = util.ROTL32(x5, 12)
+			x0 += x5
+			x15 ~= x0
+			x15 = util.ROTL32(x15, 8)
+			x10 += x15
+			x5 ~= x10
+			x5 = util.ROTL32(x5, 7)
+
+			// quarterround(x, 1, 6, 11, 12)
+			x1 += x6
+			x12 ~= x1
+			x12 = util.ROTL32(x12, 16)
+			x11 += x12
+			x6 ~= x11
+			x6 = util.ROTL32(x6, 12)
+			x1 += x6
+			x12 ~= x1
+			x12 = util.ROTL32(x12, 8)
+			x11 += x12
+			x6 ~= x11
+			x6 = util.ROTL32(x6, 7)
+
+			// quarterround(x, 2, 7, 8, 13)
+			x2 += x7
+			x13 ~= x2
+			x13 = util.ROTL32(x13, 16)
+			x8 += x13
+			x7 ~= x8
+			x7 = util.ROTL32(x7, 12)
+			x2 += x7
+			x13 ~= x2
+			x13 = util.ROTL32(x13, 8)
+			x8 += x13
+			x7 ~= x8
+			x7 = util.ROTL32(x7, 7)
+
+			// quarterround(x, 3, 4, 9, 14)
+			x3 += x4
+			x14 ~= x3
+			x14 = util.ROTL32(x14, 16)
+			x9 += x14
+			x4 ~= x9
+			x4 = util.ROTL32(x4, 12)
+			x3 += x4
+			x14 ~= x3
+			x14 = util.ROTL32(x14, 8)
+			x9 += x14
+			x4 ~= x9
+			x4 = util.ROTL32(x4, 7)
+		}
+
+		x0 += _SIGMA_0
+		x1 += _SIGMA_1
+		x2 += _SIGMA_2
+		x3 += _SIGMA_3
+		x4 += x[4]
+		x5 += x[5]
+		x6 += x[6]
+		x7 += x[7]
+		x8 += x[8]
+		x9 += x[9]
+		x10 += x[10]
+		x11 += x[11]
+		x12 += x[12]
+		x13 += x[13]
+		x14 += x[14]
+		x15 += x[15]
+
+		// While the "correct" answer to getting more performance out of
+		// this is "use vector operations", support for that is currently
+		// a work in progress/to be designed.
+		//
+		// Until dedicated assembly can be written leverage the fact that
+		// the callers of this routine ensure that src/dst are valid.
+
+		when ODIN_ARCH == "386" || ODIN_ARCH == "amd64" {
+			// util.PUT_U32_LE/util.U32_LE are not required on little-endian
+			// systems that also happen to not be strict about aligned
+			// memory access.
+
+			dst_p := transmute(^[16]u32)(&dst[0])
+			if src != nil {
+				src_p := transmute(^[16]u32)(&src[0])
+				dst_p[0] = src_p[0] ~ x0
+				dst_p[1] = src_p[1] ~ x1
+				dst_p[2] = src_p[2] ~ x2
+				dst_p[3] = src_p[3] ~ x3
+				dst_p[4] = src_p[4] ~ x4
+				dst_p[5] = src_p[5] ~ x5
+				dst_p[6] = src_p[6] ~ x6
+				dst_p[7] = src_p[7] ~ x7
+				dst_p[8] = src_p[8] ~ x8
+				dst_p[9] = src_p[9] ~ x9
+				dst_p[10] = src_p[10] ~ x10
+				dst_p[11] = src_p[11] ~ x11
+				dst_p[12] = src_p[12] ~ x12
+				dst_p[13] = src_p[13] ~ x13
+				dst_p[14] = src_p[14] ~ x14
+				dst_p[15] = src_p[15] ~ x15
+				src = src[_BLOCK_SIZE:]
+			} else {
+				dst_p[0] = x0
+				dst_p[1] = x1
+				dst_p[2] = x2
+				dst_p[3] = x3
+				dst_p[4] = x4
+				dst_p[5] = x5
+				dst_p[6] = x6
+				dst_p[7] = x7
+				dst_p[8] = x8
+				dst_p[9] = x9
+				dst_p[10] = x10
+				dst_p[11] = x11
+				dst_p[12] = x12
+				dst_p[13] = x13
+				dst_p[14] = x14
+				dst_p[15] = x15
+			}
+			dst = dst[_BLOCK_SIZE:]
+		} else {
+			#no_bounds_check {
+				if src != nil {
+					util.PUT_U32_LE(dst[0:4], util.U32_LE(src[0:4]) ~ x0)
+					util.PUT_U32_LE(dst[4:8], util.U32_LE(src[4:8]) ~ x1)
+					util.PUT_U32_LE(dst[8:12], util.U32_LE(src[8:12]) ~ x2)
+					util.PUT_U32_LE(dst[12:16], util.U32_LE(src[12:16]) ~ x3)
+					util.PUT_U32_LE(dst[16:20], util.U32_LE(src[16:20]) ~ x4)
+					util.PUT_U32_LE(dst[20:24], util.U32_LE(src[20:24]) ~ x5)
+					util.PUT_U32_LE(dst[24:28], util.U32_LE(src[24:28]) ~ x6)
+					util.PUT_U32_LE(dst[28:32], util.U32_LE(src[28:32]) ~ x7)
+					util.PUT_U32_LE(dst[32:36], util.U32_LE(src[32:36]) ~ x8)
+					util.PUT_U32_LE(dst[36:40], util.U32_LE(src[36:40]) ~ x9)
+					util.PUT_U32_LE(dst[40:44], util.U32_LE(src[40:44]) ~ x10)
+					util.PUT_U32_LE(dst[44:48], util.U32_LE(src[44:48]) ~ x11)
+					util.PUT_U32_LE(dst[48:52], util.U32_LE(src[48:52]) ~ x12)
+					util.PUT_U32_LE(dst[52:56], util.U32_LE(src[52:56]) ~ x13)
+					util.PUT_U32_LE(dst[56:60], util.U32_LE(src[56:60]) ~ x14)
+					util.PUT_U32_LE(dst[60:64], util.U32_LE(src[60:64]) ~ x15)
+					src = src[_BLOCK_SIZE:]
+				} else {
+					util.PUT_U32_LE(dst[0:4], x0)
+					util.PUT_U32_LE(dst[4:8], x1)
+					util.PUT_U32_LE(dst[8:12], x2)
+					util.PUT_U32_LE(dst[12:16], x3)
+					util.PUT_U32_LE(dst[16:20], x4)
+					util.PUT_U32_LE(dst[20:24], x5)
+					util.PUT_U32_LE(dst[24:28], x6)
+					util.PUT_U32_LE(dst[28:32], x7)
+					util.PUT_U32_LE(dst[32:36], x8)
+					util.PUT_U32_LE(dst[36:40], x9)
+					util.PUT_U32_LE(dst[40:44], x10)
+					util.PUT_U32_LE(dst[44:48], x11)
+					util.PUT_U32_LE(dst[48:52], x12)
+					util.PUT_U32_LE(dst[52:56], x13)
+					util.PUT_U32_LE(dst[56:60], x14)
+					util.PUT_U32_LE(dst[60:64], x15)
+				}
+				dst = dst[_BLOCK_SIZE:]
+			}
+		}
+
+		// Increment the counter.  Overflow checking is done upon
+		// entry into the routine, so a 64-bit increment safely
+		// covers both cases.
+		new_ctr := ((u64(ctx._s[13]) << 32) | u64(ctx._s[12])) + 1
+		x[12] = u32(new_ctr)
+		x[13] = u32(new_ctr >> 32)
+	}
+}
+
+_hchacha20 :: proc (dst, key, nonce: []byte) {
+	x0, x1, x2, x3 := _SIGMA_0, _SIGMA_1, _SIGMA_2, _SIGMA_3
+	x4 := util.U32_LE(key[0:4])
+	x5 := util.U32_LE(key[4:8])
+	x6 := util.U32_LE(key[8:12])
+	x7 := util.U32_LE(key[12:16])
+	x8 := util.U32_LE(key[16:20])
+	x9 := util.U32_LE(key[20:24])
+	x10 := util.U32_LE(key[24:28])
+	x11 := util.U32_LE(key[28:32])
+	x12 := util.U32_LE(nonce[0:4])
+	x13 := util.U32_LE(nonce[4:8])
+	x14 := util.U32_LE(nonce[8:12])
+	x15 := util.U32_LE(nonce[12:16])
+
+	for i := _ROUNDS; i > 0; i = i - 2 {
+		// quarterround(x, 0, 4, 8, 12)
+		x0 += x4
+		x12 ~= x0
+		x12 = util.ROTL32(x12, 16)
+		x8 += x12
+		x4 ~= x8
+		x4 = util.ROTL32(x4, 12)
+		x0 += x4
+		x12 ~= x0
+		x12 = util.ROTL32(x12, 8)
+		x8 += x12
+		x4 ~= x8
+		x4 = util.ROTL32(x4, 7)
+
+		// quarterround(x, 1, 5, 9, 13)
+		x1 += x5
+		x13 ~= x1
+		x13 = util.ROTL32(x13, 16)
+		x9 += x13
+		x5 ~= x9
+		x5 = util.ROTL32(x5, 12)
+		x1 += x5
+		x13 ~= x1
+		x13 = util.ROTL32(x13, 8)
+		x9 += x13
+		x5 ~= x9
+		x5 = util.ROTL32(x5, 7)
+
+		// quarterround(x, 2, 6, 10, 14)
+		x2 += x6
+		x14 ~= x2
+		x14 = util.ROTL32(x14, 16)
+		x10 += x14
+		x6 ~= x10
+		x6 = util.ROTL32(x6, 12)
+		x2 += x6
+		x14 ~= x2
+		x14 = util.ROTL32(x14, 8)
+		x10 += x14
+		x6 ~= x10
+		x6 = util.ROTL32(x6, 7)
+
+		// quarterround(x, 3, 7, 11, 15)
+		x3 += x7
+		x15 ~= x3
+		x15 = util.ROTL32(x15, 16)
+		x11 += x15
+		x7 ~= x11
+		x7 = util.ROTL32(x7, 12)
+		x3 += x7
+		x15 ~= x3
+		x15 = util.ROTL32(x15, 8)
+		x11 += x15
+		x7 ~= x11
+		x7 = util.ROTL32(x7, 7)
+
+		// quarterround(x, 0, 5, 10, 15)
+		x0 += x5
+		x15 ~= x0
+		x15 = util.ROTL32(x15, 16)
+		x10 += x15
+		x5 ~= x10
+		x5 = util.ROTL32(x5, 12)
+		x0 += x5
+		x15 ~= x0
+		x15 = util.ROTL32(x15, 8)
+		x10 += x15
+		x5 ~= x10
+		x5 = util.ROTL32(x5, 7)
+
+		// quarterround(x, 1, 6, 11, 12)
+		x1 += x6
+		x12 ~= x1
+		x12 = util.ROTL32(x12, 16)
+		x11 += x12
+		x6 ~= x11
+		x6 = util.ROTL32(x6, 12)
+		x1 += x6
+		x12 ~= x1
+		x12 = util.ROTL32(x12, 8)
+		x11 += x12
+		x6 ~= x11
+		x6 = util.ROTL32(x6, 7)
+
+		// quarterround(x, 2, 7, 8, 13)
+		x2 += x7
+		x13 ~= x2
+		x13 = util.ROTL32(x13, 16)
+		x8 += x13
+		x7 ~= x8
+		x7 = util.ROTL32(x7, 12)
+		x2 += x7
+		x13 ~= x2
+		x13 = util.ROTL32(x13, 8)
+		x8 += x13
+		x7 ~= x8
+		x7 = util.ROTL32(x7, 7)
+
+		// quarterround(x, 3, 4, 9, 14)
+		x3 += x4
+		x14 ~= x3
+		x14 = util.ROTL32(x14, 16)
+		x9 += x14
+		x4 ~= x9
+		x4 = util.ROTL32(x4, 12)
+		x3 += x4
+		x14 ~= x3
+		x14 = util.ROTL32(x14, 8)
+		x9 += x14
+		x4 ~= x9
+		x4 = util.ROTL32(x4, 7)
+	}
+
+	util.PUT_U32_LE(dst[0:4], x0)
+	util.PUT_U32_LE(dst[4:8], x1)
+	util.PUT_U32_LE(dst[8:12], x2)
+	util.PUT_U32_LE(dst[12:16], x3)
+	util.PUT_U32_LE(dst[16:20], x12)
+	util.PUT_U32_LE(dst[20:24], x13)
+	util.PUT_U32_LE(dst[24:28], x14)
+	util.PUT_U32_LE(dst[28:32], x15)
+}
diff --git a/tests/core/crypto/test_core_crypto.odin b/tests/core/crypto/test_core_crypto.odin
index c27b5c6bc..b73a191ad 100644
--- a/tests/core/crypto/test_core_crypto.odin
+++ b/tests/core/crypto/test_core_crypto.odin
@@ -116,6 +116,7 @@ main :: proc() {
     test_haval_256(&t)
 
     // "modern" crypto tests
+    test_chacha20(&t)
     test_poly1305(&t)
     test_x25519(&t)
 
diff --git a/tests/core/crypto/test_core_crypto_modern.odin b/tests/core/crypto/test_core_crypto_modern.odin
index f4f07928e..45ec8b339 100644
--- a/tests/core/crypto/test_core_crypto_modern.odin
+++ b/tests/core/crypto/test_core_crypto_modern.odin
@@ -2,8 +2,10 @@ package test_core_crypto
 
 import "core:testing"
 import "core:fmt"
+import "core:mem"
 import "core:time"
 
+import "core:crypto/chacha20"
 import "core:crypto/poly1305"
 import "core:crypto/x25519"
 
@@ -28,6 +30,94 @@ _decode_hex32 :: proc(s: string) -> [32]byte{
 	return b
 }
 
+@(test)
+test_chacha20 :: proc(t: ^testing.T) {
+	log(t, "Testing (X)ChaCha20")
+
+	// Test cases taken from RFC 8439, and draft-irtf-cfrg-xchacha-03
+	plaintext_str := "Ladies and Gentlemen of the class of '99: If I could offer you only one tip for the future, sunscreen would be it."
+	plaintext := transmute([]byte)(plaintext_str)
+
+	key := [chacha20.KEY_SIZE]byte{
+		0x00, 0x01, 0x02, 0x03, 0x04, 0x05, 0x06, 0x07,
+		0x08, 0x09, 0x0a, 0x0b, 0x0c, 0x0d, 0x0e, 0x0f,
+		0x10, 0x11, 0x12, 0x13, 0x14, 0x15, 0x16, 0x17,
+		0x18, 0x19, 0x1a, 0x1b, 0x1c, 0x1d, 0x1e, 0x1f,
+	}
+
+	nonce := [chacha20.NONCE_SIZE]byte{
+		0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x4a,
+		0x00, 0x00, 0x00, 0x00,
+	}
+
+	ciphertext := [114]byte{
+		0x6e, 0x2e, 0x35, 0x9a, 0x25, 0x68, 0xf9, 0x80,
+		0x41, 0xba, 0x07, 0x28, 0xdd, 0x0d, 0x69, 0x81,
+		0xe9, 0x7e, 0x7a, 0xec, 0x1d, 0x43, 0x60, 0xc2,
+		0x0a, 0x27, 0xaf, 0xcc, 0xfd, 0x9f, 0xae, 0x0b,
+		0xf9, 0x1b, 0x65, 0xc5, 0x52, 0x47, 0x33, 0xab,
+		0x8f, 0x59, 0x3d, 0xab, 0xcd, 0x62, 0xb3, 0x57,
+		0x16, 0x39, 0xd6, 0x24, 0xe6, 0x51, 0x52, 0xab,
+		0x8f, 0x53, 0x0c, 0x35, 0x9f, 0x08, 0x61, 0xd8,
+		0x07, 0xca, 0x0d, 0xbf, 0x50, 0x0d, 0x6a, 0x61,
+		0x56, 0xa3, 0x8e, 0x08, 0x8a, 0x22, 0xb6, 0x5e,
+		0x52, 0xbc, 0x51, 0x4d, 0x16, 0xcc, 0xf8, 0x06,
+		0x81, 0x8c, 0xe9, 0x1a, 0xb7, 0x79, 0x37, 0x36,
+		0x5a, 0xf9, 0x0b, 0xbf, 0x74, 0xa3, 0x5b, 0xe6,
+		0xb4, 0x0b, 0x8e, 0xed, 0xf2, 0x78, 0x5e, 0x42,
+		0x87, 0x4d,
+	}
+	ciphertext_str := hex_string(ciphertext[:])
+
+	derived_ciphertext: [114]byte
+	ctx: chacha20.Context = ---
+	chacha20.init(&ctx, key[:], nonce[:])
+	chacha20.seek(&ctx, 1) // The test vectors start the counter at 1.
+	chacha20.xor_bytes(&ctx, derived_ciphertext[:], plaintext[:])
+
+	derived_ciphertext_str := hex_string(derived_ciphertext[:])
+	expect(t, derived_ciphertext_str == ciphertext_str, fmt.tprintf("Expected %s for xor_bytes(plaintext_str), but got %s instead", ciphertext_str, derived_ciphertext_str))
+
+	xkey := [chacha20.KEY_SIZE]byte{
+		0x80, 0x81, 0x82, 0x83, 0x84, 0x85, 0x86, 0x87,
+		0x88, 0x89, 0x8a, 0x8b, 0x8c, 0x8d, 0x8e, 0x8f,
+		0x90, 0x91, 0x92, 0x93, 0x94, 0x95, 0x96, 0x97,
+		0x98, 0x99, 0x9a, 0x9b, 0x9c, 0x9d, 0x9e, 0x9f,
+	}
+
+	xnonce := [chacha20.XNONCE_SIZE]byte{
+		0x40, 0x41, 0x42, 0x43, 0x44, 0x45, 0x46, 0x47,
+		0x48, 0x49, 0x4a, 0x4b, 0x4c, 0x4d, 0x4e, 0x4f,
+		0x50, 0x51, 0x52, 0x53, 0x54, 0x55, 0x56, 0x57,
+	}
+
+	xciphertext := [114]byte{
+		0xbd, 0x6d, 0x17, 0x9d, 0x3e, 0x83, 0xd4, 0x3b,
+		0x95, 0x76, 0x57, 0x94, 0x93, 0xc0, 0xe9, 0x39,
+		0x57, 0x2a, 0x17, 0x00, 0x25, 0x2b, 0xfa, 0xcc,
+		0xbe, 0xd2, 0x90, 0x2c, 0x21, 0x39, 0x6c, 0xbb,
+		0x73, 0x1c, 0x7f, 0x1b, 0x0b, 0x4a, 0xa6, 0x44,
+		0x0b, 0xf3, 0xa8, 0x2f, 0x4e, 0xda, 0x7e, 0x39,
+		0xae, 0x64, 0xc6, 0x70, 0x8c, 0x54, 0xc2, 0x16,
+		0xcb, 0x96, 0xb7, 0x2e, 0x12, 0x13, 0xb4, 0x52,
+		0x2f, 0x8c, 0x9b, 0xa4, 0x0d, 0xb5, 0xd9, 0x45,
+		0xb1, 0x1b, 0x69, 0xb9, 0x82, 0xc1, 0xbb, 0x9e,
+		0x3f, 0x3f, 0xac, 0x2b, 0xc3, 0x69, 0x48, 0x8f,
+		0x76, 0xb2, 0x38, 0x35, 0x65, 0xd3, 0xff, 0xf9,
+		0x21, 0xf9, 0x66, 0x4c, 0x97, 0x63, 0x7d, 0xa9,
+		0x76, 0x88, 0x12, 0xf6, 0x15, 0xc6, 0x8b, 0x13,
+		0xb5, 0x2e,
+	}
+	xciphertext_str := hex_string(xciphertext[:])
+
+	chacha20.init(&ctx, xkey[:], xnonce[:])
+	chacha20.seek(&ctx, 1)
+	chacha20.xor_bytes(&ctx, derived_ciphertext[:], plaintext[:])
+
+	derived_ciphertext_str = hex_string(derived_ciphertext[:])
+	expect(t, derived_ciphertext_str == xciphertext_str, fmt.tprintf("Expected %s for xor_bytes(plaintext_str), but got %s instead", xciphertext_str, derived_ciphertext_str))
+}
+
 @(test)
 test_poly1305 :: proc(t: ^testing.T) {
 	log(t, "Testing poly1305")
@@ -141,24 +231,49 @@ test_x25519 :: proc(t: ^testing.T) {
 bench_modern :: proc(t: ^testing.T) {
 	fmt.println("Starting benchmarks:")
 
+	bench_chacha20(t)
 	bench_poly1305(t)
 	bench_x25519(t)
 }
 
-_setup_poly1305 :: proc(options: ^time.Benchmark_Options, allocator := context.allocator) -> (err: time.Benchmark_Error) {
+_setup_sized_buf :: proc(options: ^time.Benchmark_Options, allocator := context.allocator) -> (err: time.Benchmark_Error) {
 	assert(options != nil)
 
 	options.input = make([]u8, options.bytes, allocator)
 	return nil if len(options.input) == options.bytes else .Allocation_Error
 }
 
-_teardown_poly1305 :: proc(options: ^time.Benchmark_Options, allocator := context.allocator) -> (err: time.Benchmark_Error) {
+_teardown_sized_buf :: proc(options: ^time.Benchmark_Options, allocator := context.allocator) -> (err: time.Benchmark_Error) {
 	assert(options != nil)
 
 	delete(options.input)
 	return nil
 }
 
+_benchmark_chacha20 :: proc(options: ^time.Benchmark_Options, allocator := context.allocator) -> (err: time.Benchmark_Error) {
+	buf := options.input
+	key := [chacha20.KEY_SIZE]byte{
+		0xde, 0xad, 0xbe, 0xef, 0xde, 0xad, 0xbe, 0xef,
+		0xde, 0xad, 0xbe, 0xef, 0xde, 0xad, 0xbe, 0xef,
+		0xde, 0xad, 0xbe, 0xef, 0xde, 0xad, 0xbe, 0xef,
+		0xde, 0xad, 0xbe, 0xef, 0xde, 0xad, 0xbe, 0xef,
+	}
+	nonce := [chacha20.NONCE_SIZE]byte{
+		0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+		0x00, 0x00, 0x00, 0x00,
+	}
+
+	ctx: chacha20.Context = ---
+	chacha20.init(&ctx, key[:], nonce[:])
+
+	for _ in 0..=options.rounds {
+		chacha20.xor_bytes(&ctx, buf, buf)
+	}
+	options.count     = options.rounds
+	options.processed = options.rounds * options.bytes
+	return nil
+}
+
 _benchmark_poly1305 :: proc(options: ^time.Benchmark_Options, allocator := context.allocator) -> (err: time.Benchmark_Error) {
 	buf := options.input
 	key := [poly1305.KEY_SIZE]byte{
@@ -189,14 +304,41 @@ benchmark_print :: proc(name: string, options: ^time.Benchmark_Options) {
 	)
 }
 
+bench_chacha20 :: proc(t: ^testing.T) {
+	name    := "ChaCha20 64 bytes"
+	options := &time.Benchmark_Options{
+		rounds   = 1_000,
+		bytes    = 64,
+		setup    = _setup_sized_buf,
+		bench    = _benchmark_chacha20,
+		teardown = _teardown_sized_buf,
+	}
+
+	err  := time.benchmark(options, context.allocator)
+	expect(t, err == nil, name)
+	benchmark_print(name, options)
+
+	name = "ChaCha20 1024 bytes"
+	options.bytes = 1024
+	err = time.benchmark(options, context.allocator)
+	expect(t, err == nil, name)
+	benchmark_print(name, options)
+
+	name = "ChaCha20 65536 bytes"
+	options.bytes = 65536
+	err = time.benchmark(options, context.allocator)
+	expect(t, err == nil, name)
+	benchmark_print(name, options)
+}
+
 bench_poly1305 :: proc(t: ^testing.T) {
 	name    := "Poly1305 64 zero bytes"
 	options := &time.Benchmark_Options{
 		rounds   = 1_000,
 		bytes    = 64,
-		setup    = _setup_poly1305,
+		setup    = _setup_sized_buf,
 		bench    = _benchmark_poly1305,
-		teardown = _teardown_poly1305,
+		teardown = _teardown_sized_buf,
 	}
 
 	err  := time.benchmark(options, context.allocator)

From 6c4c9aef618dcf3932be88ca6df65164145b7cea Mon Sep 17 00:00:00 2001
From: Yawning Angel <yawning@schwanenlied.me>
Date: Tue, 9 Nov 2021 07:22:41 +0000
Subject: [PATCH 20/38] core/crypto: Add chacha20poly1305

This package implements the chacha20poly1305 AEAD construct as specified
in RFC 8439.
---
 .../chacha20poly1305/chacha20poly1305.odin    | 146 ++++++++++++++++++
 tests/core/crypto/test_core_crypto.odin       |   1 +
 .../core/crypto/test_core_crypto_modern.odin  | 131 +++++++++++++++-
 3 files changed, 276 insertions(+), 2 deletions(-)
 create mode 100644 core/crypto/chacha20poly1305/chacha20poly1305.odin

diff --git a/core/crypto/chacha20poly1305/chacha20poly1305.odin b/core/crypto/chacha20poly1305/chacha20poly1305.odin
new file mode 100644
index 000000000..67d89df56
--- /dev/null
+++ b/core/crypto/chacha20poly1305/chacha20poly1305.odin
@@ -0,0 +1,146 @@
+package chacha20poly1305
+
+import "core:crypto"
+import "core:crypto/chacha20"
+import "core:crypto/poly1305"
+import "core:crypto/util"
+import "core:mem"
+
+KEY_SIZE :: chacha20.KEY_SIZE
+NONCE_SIZE :: chacha20.NONCE_SIZE
+TAG_SIZE :: poly1305.TAG_SIZE
+
+_P_MAX :: 64 * 0xffffffff // 64 * (2^32-1)
+
+_validate_common_slice_sizes :: proc (tag, key, nonce, aad, text: []byte) {
+	if len(tag) != TAG_SIZE {
+		panic("crypto/chacha20poly1305: invalid destination tag size")
+	}
+	if len(key) != KEY_SIZE {
+		panic("crypto/chacha20poly1305: invalid key size")
+	}
+	if len(nonce) != NONCE_SIZE {
+		panic("crypto/chacha20poly1305: invalid nonce size")
+	}
+
+	#assert(size_of(int) == 8 || size_of(int) <= 4)
+	when size_of(int) == 8 {
+		// A_MAX = 2^64 - 1 due to the length field limit.
+		// P_MAX = 64 * (2^32 - 1) due to the IETF ChaCha20 counter limit.
+		//
+		// A_MAX is limited by size_of(int), so there is no need to
+		// enforce it. P_MAX only needs to be checked on 64-bit targets,
+		// for reasons that should be obvious.
+		if text_len := len(text); text_len > _P_MAX {
+			panic("crypto/chacha20poly1305: oversized src data")
+		}
+	}
+}
+
+_PAD: [16]byte
+_update_mac_pad16 :: #force_inline proc (ctx: ^poly1305.Context, x_len: int) {
+	if pad_len := 16 - (x_len & (16-1)); pad_len != 16 {
+		poly1305.update(ctx, _PAD[:pad_len])
+	}
+}
+
+encrypt :: proc (ciphertext, tag, key, nonce, aad, plaintext: []byte) {
+	_validate_common_slice_sizes(tag, key, nonce, aad, plaintext)
+	if len(ciphertext) != len(plaintext) {
+		panic("crypto/chacha20poly1305: invalid destination ciphertext size")
+	}
+
+	stream_ctx: chacha20.Context = ---
+	chacha20.init(&stream_ctx, key, nonce)
+
+	// otk = poly1305_key_gen(key, nonce)
+	otk: [poly1305.KEY_SIZE]byte = ---
+	chacha20.keystream_bytes(&stream_ctx, otk[:])
+	mac_ctx: poly1305.Context = ---
+	poly1305.init(&mac_ctx, otk[:])
+	mem.zero_explicit(&otk, size_of(otk))
+
+	aad_len, ciphertext_len := len(aad), len(ciphertext)
+
+	// There is nothing preventing aad and ciphertext from overlapping
+	// so auth the AAD before encrypting (slightly different from the
+	// RFC, since the RFC encrypts into a new buffer).
+	//
+	// mac_data = aad | pad16(aad)
+	poly1305.update(&mac_ctx, aad)
+	_update_mac_pad16(&mac_ctx, aad_len)
+
+	// ciphertext = chacha20_encrypt(key, 1, nonce, plaintext)
+	chacha20.seek(&stream_ctx, 1)
+	chacha20.xor_bytes(&stream_ctx, ciphertext, plaintext)
+	chacha20.reset(&stream_ctx) // Don't need the stream context anymore.
+
+	// mac_data |= ciphertext | pad16(ciphertext)
+	poly1305.update(&mac_ctx, ciphertext)
+	_update_mac_pad16(&mac_ctx, ciphertext_len)
+
+	// mac_data |= num_to_8_le_bytes(aad.length)
+	// mac_data |= num_to_8_le_bytes(ciphertext.length)
+	l_buf := otk[0:16] // Reuse the scratch buffer.
+	util.PUT_U64_LE(l_buf[0:8], u64(aad_len))
+	util.PUT_U64_LE(l_buf[8:16], u64(ciphertext_len))
+	poly1305.update(&mac_ctx, l_buf)
+
+	// tag = poly1305_mac(mac_data, otk)
+	poly1305.final(&mac_ctx, tag) // Implicitly sanitizes context.
+}
+
+decrypt :: proc (plaintext, tag, key, nonce, aad, ciphertext: []byte) -> bool {
+	_validate_common_slice_sizes(tag, key, nonce, aad, ciphertext)
+	if len(ciphertext) != len(plaintext) {
+		panic("crypto/chacha20poly1305: invalid destination plaintext size")
+	}
+
+	// Note: Unlike encrypt, this can fail early, so use defer for
+	// sanitization rather than assuming control flow reaches certain
+	// points where needed.
+
+	stream_ctx: chacha20.Context = ---
+	chacha20.init(&stream_ctx, key, nonce)
+
+	// otk = poly1305_key_gen(key, nonce)
+	otk: [poly1305.KEY_SIZE]byte = ---
+	chacha20.keystream_bytes(&stream_ctx, otk[:])
+	defer chacha20.reset(&stream_ctx)
+
+	mac_ctx: poly1305.Context = ---
+	poly1305.init(&mac_ctx, otk[:])
+	defer mem.zero_explicit(&otk, size_of(otk))
+
+	aad_len, ciphertext_len := len(aad), len(ciphertext)
+
+	// mac_data = aad | pad16(aad)
+	// mac_data |= ciphertext | pad16(ciphertext)
+	// mac_data |= num_to_8_le_bytes(aad.length)
+	// mac_data |= num_to_8_le_bytes(ciphertext.length)
+	poly1305.update(&mac_ctx, aad)
+	_update_mac_pad16(&mac_ctx, aad_len)
+	poly1305.update(&mac_ctx, ciphertext)
+	_update_mac_pad16(&mac_ctx, ciphertext_len)
+	l_buf := otk[0:16] // Reuse the scratch buffer.
+	util.PUT_U64_LE(l_buf[0:8], u64(aad_len))
+	util.PUT_U64_LE(l_buf[8:16], u64(ciphertext_len))
+	poly1305.update(&mac_ctx, l_buf)
+
+	// tag = poly1305_mac(mac_data, otk)
+	derived_tag := otk[0:poly1305.TAG_SIZE] // Reuse the scratch buffer again.
+	poly1305.final(&mac_ctx, derived_tag) // Implicitly sanitizes context.
+
+	// Validate the tag in constant time.
+	if crypto.compare_constant_time(tag, derived_tag) != 1 {
+		// Zero out the plaintext, as a defense in depth measure.
+		mem.zero_explicit(raw_data(plaintext), ciphertext_len)
+		return false
+	}
+
+	// plaintext = chacha20_decrypt(key, 1, nonce, ciphertext)
+	chacha20.seek(&stream_ctx, 1)
+	chacha20.xor_bytes(&stream_ctx, plaintext, ciphertext)
+
+	return true
+}
diff --git a/tests/core/crypto/test_core_crypto.odin b/tests/core/crypto/test_core_crypto.odin
index b73a191ad..731833096 100644
--- a/tests/core/crypto/test_core_crypto.odin
+++ b/tests/core/crypto/test_core_crypto.odin
@@ -118,6 +118,7 @@ main :: proc() {
     // "modern" crypto tests
     test_chacha20(&t)
     test_poly1305(&t)
+    test_chacha20poly1305(&t)
     test_x25519(&t)
 
     bench_modern(&t)
diff --git a/tests/core/crypto/test_core_crypto_modern.odin b/tests/core/crypto/test_core_crypto_modern.odin
index 45ec8b339..b3d9e47fd 100644
--- a/tests/core/crypto/test_core_crypto_modern.odin
+++ b/tests/core/crypto/test_core_crypto_modern.odin
@@ -6,6 +6,7 @@ import "core:mem"
 import "core:time"
 
 import "core:crypto/chacha20"
+import "core:crypto/chacha20poly1305"
 import "core:crypto/poly1305"
 import "core:crypto/x25519"
 
@@ -30,13 +31,14 @@ _decode_hex32 :: proc(s: string) -> [32]byte{
 	return b
 }
 
+_PLAINTEXT_SUNSCREEN_STR := "Ladies and Gentlemen of the class of '99: If I could offer you only one tip for the future, sunscreen would be it."
+
 @(test)
 test_chacha20 :: proc(t: ^testing.T) {
 	log(t, "Testing (X)ChaCha20")
 
 	// Test cases taken from RFC 8439, and draft-irtf-cfrg-xchacha-03
-	plaintext_str := "Ladies and Gentlemen of the class of '99: If I could offer you only one tip for the future, sunscreen would be it."
-	plaintext := transmute([]byte)(plaintext_str)
+	plaintext := transmute([]byte)(_PLAINTEXT_SUNSCREEN_STR)
 
 	key := [chacha20.KEY_SIZE]byte{
 		0x00, 0x01, 0x02, 0x03, 0x04, 0x05, 0x06, 0x07,
@@ -182,6 +184,80 @@ test_poly1305 :: proc(t: ^testing.T) {
 	expect(t, derived_tag_str == tag_str, fmt.tprintf("Expected %s for init/update/final - incremental, but got %s instead", tag_str, derived_tag_str))
 }
 
+@(test)
+test_chacha20poly1305 :: proc(t: ^testing.T) {
+	log(t, "Testing chacha20poly1205")
+
+	plaintext := transmute([]byte)(_PLAINTEXT_SUNSCREEN_STR)
+
+	aad := [12]byte{
+		0x50, 0x51, 0x52, 0x53, 0xc0, 0xc1, 0xc2, 0xc3,
+		0xc4, 0xc5, 0xc6, 0xc7,
+	}
+
+	key := [chacha20poly1305.KEY_SIZE]byte{
+		0x80, 0x81, 0x82, 0x83, 0x84, 0x85, 0x86, 0x87,
+		0x88, 0x89, 0x8a, 0x8b, 0x8c, 0x8d, 0x8e, 0x8f,
+		0x90, 0x91, 0x92, 0x93, 0x94, 0x95, 0x96, 0x97,
+		0x98, 0x99, 0x9a, 0x9b, 0x9c, 0x9d, 0x9e, 0x9f,
+	}
+
+	nonce := [chacha20poly1305.NONCE_SIZE]byte{
+		0x07, 0x00, 0x00, 0x00,
+		0x40, 0x41, 0x42, 0x43, 0x44, 0x45, 0x46, 0x47,
+	}
+
+	ciphertext := [114]byte{
+		0xd3, 0x1a, 0x8d, 0x34, 0x64, 0x8e, 0x60, 0xdb,
+		0x7b, 0x86, 0xaf, 0xbc, 0x53, 0xef, 0x7e, 0xc2,
+		0xa4, 0xad, 0xed, 0x51, 0x29, 0x6e, 0x08, 0xfe,
+		0xa9, 0xe2, 0xb5, 0xa7, 0x36, 0xee, 0x62, 0xd6,
+		0x3d, 0xbe, 0xa4, 0x5e, 0x8c, 0xa9, 0x67, 0x12,
+		0x82, 0xfa, 0xfb, 0x69, 0xda, 0x92, 0x72, 0x8b,
+		0x1a, 0x71, 0xde, 0x0a, 0x9e, 0x06, 0x0b, 0x29,
+		0x05, 0xd6, 0xa5, 0xb6, 0x7e, 0xcd, 0x3b, 0x36,
+		0x92, 0xdd, 0xbd, 0x7f, 0x2d, 0x77, 0x8b, 0x8c,
+		0x98, 0x03, 0xae, 0xe3, 0x28, 0x09, 0x1b, 0x58,
+		0xfa, 0xb3, 0x24, 0xe4, 0xfa, 0xd6, 0x75, 0x94,
+		0x55, 0x85, 0x80, 0x8b, 0x48, 0x31, 0xd7, 0xbc,
+		0x3f, 0xf4, 0xde, 0xf0, 0x8e, 0x4b, 0x7a, 0x9d,
+		0xe5, 0x76, 0xd2, 0x65, 0x86, 0xce, 0xc6, 0x4b,
+		0x61, 0x16,
+	}
+	ciphertext_str := hex_string(ciphertext[:])
+
+	tag := [chacha20poly1305.TAG_SIZE]byte{
+		0x1a, 0xe1, 0x0b, 0x59, 0x4f, 0x09, 0xe2, 0x6a,
+		0x7e, 0x90, 0x2e, 0xcb, 0xd0, 0x60, 0x06, 0x91,
+	}
+	tag_str := hex_string(tag[:])
+
+	derived_tag: [chacha20poly1305.TAG_SIZE]byte
+	derived_ciphertext: [114]byte
+
+	chacha20poly1305.encrypt(derived_ciphertext[:], derived_tag[:], key[:], nonce[:], aad[:], plaintext)
+
+	derived_ciphertext_str := hex_string(derived_ciphertext[:])
+	expect(t, derived_ciphertext_str == ciphertext_str, fmt.tprintf("Expected ciphertext %s for encrypt(aad, plaintext), but got %s instead", ciphertext_str, derived_ciphertext_str))
+
+	derived_tag_str := hex_string(derived_tag[:])
+	expect(t, derived_tag_str == tag_str, fmt.tprintf("Expected tag %s for encrypt(aad, plaintext), but got %s instead", tag_str, derived_tag_str))
+
+	derived_plaintext: [114]byte
+	ok := chacha20poly1305.decrypt(derived_plaintext[:], tag[:], key[:], nonce[:], aad[:], ciphertext[:])
+	derived_plaintext_str := string(derived_plaintext[:])
+	expect(t, ok, "Expected true for decrypt(tag, aad, ciphertext)")
+	expect(t, derived_plaintext_str == _PLAINTEXT_SUNSCREEN_STR, fmt.tprintf("Expected plaintext %s for decrypt(tag, aad, ciphertext), but got %s instead", _PLAINTEXT_SUNSCREEN_STR, derived_plaintext_str))
+
+	derived_ciphertext[0] ~= 0xa5
+	ok = chacha20poly1305.decrypt(derived_plaintext[:], tag[:], key[:], nonce[:], aad[:], derived_ciphertext[:])
+	expect(t, !ok, "Expected false for decrypt(tag, aad, corrupted_ciphertext)")
+
+	aad[0] ~= 0xa5
+	ok = chacha20poly1305.decrypt(derived_plaintext[:], tag[:], key[:], nonce[:], aad[:], ciphertext[:])
+	expect(t, !ok, "Expected false for decrypt(tag, corrupted_aad, ciphertext)")
+}
+
 TestECDH :: struct {
 	scalar:  string,
 	point:   string,
@@ -233,6 +309,7 @@ bench_modern :: proc(t: ^testing.T) {
 
 	bench_chacha20(t)
 	bench_poly1305(t)
+	bench_chacha20poly1305(t)
 	bench_x25519(t)
 }
 
@@ -293,6 +370,29 @@ _benchmark_poly1305 :: proc(options: ^time.Benchmark_Options, allocator := conte
 	return nil
 }
 
+_benchmark_chacha20poly1305 :: proc(options: ^time.Benchmark_Options, allocator := context.allocator) -> (err: time.Benchmark_Error) {
+	buf := options.input
+	key := [chacha20.KEY_SIZE]byte{
+		0xde, 0xad, 0xbe, 0xef, 0xde, 0xad, 0xbe, 0xef,
+		0xde, 0xad, 0xbe, 0xef, 0xde, 0xad, 0xbe, 0xef,
+		0xde, 0xad, 0xbe, 0xef, 0xde, 0xad, 0xbe, 0xef,
+		0xde, 0xad, 0xbe, 0xef, 0xde, 0xad, 0xbe, 0xef,
+	}
+	nonce := [chacha20.NONCE_SIZE]byte{
+		0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+		0x00, 0x00, 0x00, 0x00,
+	}
+
+	tag: [chacha20poly1305.TAG_SIZE]byte = ---
+
+	for _ in 0..=options.rounds {
+		chacha20poly1305.encrypt(buf,tag[:], key[:], nonce[:], nil, buf)
+	}
+	options.count     = options.rounds
+	options.processed = options.rounds * options.bytes
+	return nil
+}
+
 benchmark_print :: proc(name: string, options: ^time.Benchmark_Options) {
 	fmt.printf("\t[%v] %v rounds, %v bytes processed in %v ns\n\t\t%5.3f rounds/s, %5.3f MiB/s\n",
 		name,
@@ -352,6 +452,33 @@ bench_poly1305 :: proc(t: ^testing.T) {
 	benchmark_print(name, options)
 }
 
+bench_chacha20poly1305 :: proc(t: ^testing.T) {
+	name    := "chacha20poly1305 64 bytes"
+	options := &time.Benchmark_Options{
+		rounds   = 1_000,
+		bytes    = 64,
+		setup    = _setup_sized_buf,
+		bench    = _benchmark_chacha20poly1305,
+		teardown = _teardown_sized_buf,
+	}
+
+	err  := time.benchmark(options, context.allocator)
+	expect(t, err == nil, name)
+	benchmark_print(name, options)
+
+	name = "chacha20poly1305 1024 bytes"
+	options.bytes = 1024
+	err = time.benchmark(options, context.allocator)
+	expect(t, err == nil, name)
+	benchmark_print(name, options)
+
+	name = "chacha20poly1305 65536 bytes"
+	options.bytes = 65536
+	err = time.benchmark(options, context.allocator)
+	expect(t, err == nil, name)
+	benchmark_print(name, options)
+}
+
 bench_x25519 :: proc(t: ^testing.T) {
 	point := _decode_hex32("deadbeefdeadbeefdeadbeefdeadbeefdeadbeefdeadbeefdeadbeefdeadbeef")
 	scalar := _decode_hex32("cafebabecafebabecafebabecafebabecafebabecafebabecafebabecafebabe")

From 61c581baeb94ac73cbb25e93af2710d12e15f25c Mon Sep 17 00:00:00 2001
From: Yawning Angel <yawning@schwanenlied.me>
Date: Fri, 12 Nov 2021 06:22:17 +0000
Subject: [PATCH 21/38] core/sys/unix: Add syscalls_linux.odin

Linux is in the unfortunate situation where the system call number is
architecture specific.  This consolidates the system call number
definitions in a single location, adds some wrappers, and hopefully
fixes the existing non-portable invocations of the syscall intrinsic.
---
 core/mem/virtual/virtual_linux.odin   | 76 ++++++++++++---------------
 core/os/os_linux.odin                 |  5 +-
 core/sync/sync2/futex_linux.odin      |  3 +-
 core/sync/sync2/primitives_linux.odin |  5 +-
 core/sync/sync_linux.odin             |  4 +-
 core/sys/unix/syscalls_linux.odin     | 60 +++++++++++++++++++++
 6 files changed, 101 insertions(+), 52 deletions(-)
 create mode 100644 core/sys/unix/syscalls_linux.odin

diff --git a/core/mem/virtual/virtual_linux.odin b/core/mem/virtual/virtual_linux.odin
index c4dd564ee..71a56e499 100644
--- a/core/mem/virtual/virtual_linux.odin
+++ b/core/mem/virtual/virtual_linux.odin
@@ -4,64 +4,56 @@ package mem_virtual
 
 import "core:c"
 import "core:intrinsics"
+import "core:sys/unix"
 
-when ODIN_ARCH == "amd64" {
-	SYS_mmap     :: 9
-	SYS_mprotect :: 10
-	SYS_munmap   :: 11
-	SYS_madvise  :: 28
-	
-	PROT_NONE  :: 0x0
-	PROT_READ  :: 0x1
-	PROT_WRITE :: 0x2
-	PROT_EXEC  :: 0x4
-	PROT_GROWSDOWN :: 0x01000000
-	PROT_GROWSUP :: 0x02000000
+PROT_NONE  :: 0x0
+PROT_READ  :: 0x1
+PROT_WRITE :: 0x2
+PROT_EXEC  :: 0x4
+PROT_GROWSDOWN :: 0x01000000
+PROT_GROWSUP :: 0x02000000
 
-	MAP_FIXED     :: 0x1
-	MAP_PRIVATE   :: 0x2
-	MAP_SHARED    :: 0x4
-	MAP_ANONYMOUS :: 0x20
-	
-	MADV_NORMAL      :: 0
-	MADV_RANDOM      :: 1
-	MADV_SEQUENTIAL  :: 2
-	MADV_WILLNEED    :: 3
-	MADV_DONTNEED    :: 4
-	MADV_FREE        :: 8
-	MADV_REMOVE      :: 9
-	MADV_DONTFORK    :: 10
-	MADV_DOFORK      :: 11
-	MADV_MERGEABLE   :: 12
-	MADV_UNMERGEABLE :: 13
-	MADV_HUGEPAGE    :: 14
-	MADV_NOHUGEPAGE  :: 15
-	MADV_DONTDUMP    :: 16
-	MADV_DODUMP      :: 17
-	MADV_WIPEONFORK  :: 18
-	MADV_KEEPONFORK  :: 19
-	MADV_HWPOISON    :: 100
-} else {
-	#panic("Unsupported architecture")
-}
+MAP_FIXED     :: 0x1
+MAP_PRIVATE   :: 0x2
+MAP_SHARED    :: 0x4
+MAP_ANONYMOUS :: 0x20
+
+MADV_NORMAL      :: 0
+MADV_RANDOM      :: 1
+MADV_SEQUENTIAL  :: 2
+MADV_WILLNEED    :: 3
+MADV_DONTNEED    :: 4
+MADV_FREE        :: 8
+MADV_REMOVE      :: 9
+MADV_DONTFORK    :: 10
+MADV_DOFORK      :: 11
+MADV_MERGEABLE   :: 12
+MADV_UNMERGEABLE :: 13
+MADV_HUGEPAGE    :: 14
+MADV_NOHUGEPAGE  :: 15
+MADV_DONTDUMP    :: 16
+MADV_DODUMP      :: 17
+MADV_WIPEONFORK  :: 18
+MADV_KEEPONFORK  :: 19
+MADV_HWPOISON    :: 100
 
 mmap :: proc "contextless" (addr: rawptr, length: uint, prot: c.int, flags: c.int, fd: c.int, offset: uintptr) -> rawptr {
-	res := intrinsics.syscall(SYS_mmap, uintptr(addr), uintptr(length), uintptr(prot), uintptr(flags), uintptr(fd), offset)
+	res := intrinsics.syscall(unix.SYS_mmap, uintptr(addr), uintptr(length), uintptr(prot), uintptr(flags), uintptr(fd), offset)
 	return rawptr(res)
 }
 
 munmap :: proc "contextless" (addr: rawptr, length: uint) -> c.int {
-	res := intrinsics.syscall(SYS_munmap, uintptr(addr), uintptr(length))
+	res := intrinsics.syscall(unix.SYS_munmap, uintptr(addr), uintptr(length))
 	return c.int(res)
 }
 
 mprotect :: proc "contextless" (addr: rawptr, length: uint, prot: c.int) -> c.int {
-	res := intrinsics.syscall(SYS_mprotect, uintptr(addr), uintptr(length), uint(prot))
+	res := intrinsics.syscall(unix.SYS_mprotect, uintptr(addr), uintptr(length), uint(prot))
 	return c.int(res)
 }
 
 madvise :: proc "contextless" (addr: rawptr, length: uint, advice: c.int) -> c.int {
-	res := intrinsics.syscall(SYS_madvise, uintptr(addr), uintptr(length), uintptr(advice))
+	res := intrinsics.syscall(unix.SYS_madvise, uintptr(addr), uintptr(length), uintptr(advice))
 	return c.int(res)
 }
 
diff --git a/core/os/os_linux.odin b/core/os/os_linux.odin
index bc4717b44..260a051ce 100644
--- a/core/os/os_linux.odin
+++ b/core/os/os_linux.odin
@@ -8,6 +8,7 @@ import "core:strings"
 import "core:c"
 import "core:strconv"
 import "core:intrinsics"
+import "core:sys/unix"
 
 Handle    :: distinct i32
 File_Time :: distinct u64
@@ -265,8 +266,6 @@ X_OK :: 1 // Test for execute permission
 W_OK :: 2 // Test for write permission
 R_OK :: 4 // Test for read permission
 
-SYS_GETTID :: 186
-
 foreign libc {
 	@(link_name="__errno_location") __errno_location    :: proc() -> ^int ---
 
@@ -594,7 +593,7 @@ exit :: proc "contextless" (code: int) -> ! {
 }
 
 current_thread_id :: proc "contextless" () -> int {
-	return cast(int)intrinsics.syscall(SYS_GETTID)
+	return unix.sys_gettid()
 }
 
 dlopen :: proc(filename: string, flags: int) -> rawptr {
diff --git a/core/sync/sync2/futex_linux.odin b/core/sync/sync2/futex_linux.odin
index 1bd41c7cf..fca28cace 100644
--- a/core/sync/sync2/futex_linux.odin
+++ b/core/sync/sync2/futex_linux.odin
@@ -5,6 +5,7 @@ package sync2
 import "core:c"
 import "core:time"
 import "core:intrinsics"
+import "core:sys/unix"
 
 FUTEX_WAIT :: 0
 FUTEX_WAKE :: 1
@@ -34,7 +35,7 @@ get_errno :: proc(r: int) -> int {
 }
 
 internal_futex :: proc(f: ^Futex, op: c.int, val: u32, timeout: rawptr) -> int {
-	code := int(intrinsics.syscall(202, uintptr(f), uintptr(op), uintptr(val), uintptr(timeout), 0, 0))
+	code := int(intrinsics.syscall(unix.SYS_futex, uintptr(f), uintptr(op), uintptr(val), uintptr(timeout), 0, 0))
 	return get_errno(code)
 }
 
diff --git a/core/sync/sync2/primitives_linux.odin b/core/sync/sync2/primitives_linux.odin
index 4c81295bd..89ed97985 100644
--- a/core/sync/sync2/primitives_linux.odin
+++ b/core/sync/sync2/primitives_linux.odin
@@ -2,9 +2,8 @@
 //+private
 package sync2
 
-import "core:intrinsics"
+import "core:sys/unix"
 
 _current_thread_id :: proc "contextless" () -> int {
-	SYS_GETTID :: 186
-	return int(intrinsics.syscall(SYS_GETTID))
+	return unix.sys_gettid()
 }
diff --git a/core/sync/sync_linux.odin b/core/sync/sync_linux.odin
index fe856df94..340437c11 100644
--- a/core/sync/sync_linux.odin
+++ b/core/sync/sync_linux.odin
@@ -1,11 +1,9 @@
 package sync
 
 import "core:sys/unix"
-import "core:intrinsics"
 
 current_thread_id :: proc "contextless" () -> int {
-	SYS_GETTID :: 186
-	return int(intrinsics.syscall(SYS_GETTID))
+	return unix.sys_gettid()
 }
 
 
diff --git a/core/sys/unix/syscalls_linux.odin b/core/sys/unix/syscalls_linux.odin
new file mode 100644
index 000000000..659eedfbb
--- /dev/null
+++ b/core/sys/unix/syscalls_linux.odin
@@ -0,0 +1,60 @@
+package unix
+
+import "core:intrinsics"
+
+// Linux has inconsistent system call numbering across architectures,
+// for largely historical reasons.  This attempts to provide a unified
+// Odin-side interface for system calls that are required for the core
+// library to work.
+
+// For authorative system call numbers, the following files in the kernel
+// source can be used:
+//
+//  amd64: arch/x86/entry/syscalls/syscall_64.tbl
+//  arm64: include/uapi/asm-generic/unistd.h
+//  386: arch/x86/entry/syscalls/sycall_32.tbl
+//  arm: arch/arm/tools/syscall.tbl
+
+when ODIN_ARCH == "amd64" {
+	SYS_mmap : uintptr : 9
+	SYS_mprotect : uintptr : 10
+	SYS_munmap : uintptr : 11
+	SYS_madvise : uintptr : 28
+	SYS_futex : uintptr : 202
+	SYS_gettid : uintptr : 186
+	SYS_getrandom : uintptr : 318
+} else when ODIN_ARCH == "arm64" {
+	SYS_mmap : uintptr : 222
+	SYS_mprotect : uintptr : 226
+	SYS_munmap : uintptr : 215
+	SYS_madvise : uintptr : 233
+	SYS_futex : uintptr : 98
+	SYS_gettid : uintptr : 178
+	SYS_getrandom : uintptr : 278
+} else when ODIN_ARCH == "386" {
+	SYS_mmap : uintptr : 192 // 90 is "sys_old_mmap", we want mmap2
+	SYS_mprotect : uintptr : 125
+	SYS_munmap : uintptr : 91
+	SYS_madvise : uintptr : 219
+	SYS_futex : uintptr : 240
+	SYS_gettid : uintptr : 224
+	SYS_getrandom : uintptr : 355
+} else when ODIN_ARCH == "arm" {
+	SYS_mmap : uintptr : 192 // 90 is "sys_old_mmap", we want mmap2
+	SYS_mprotect : uintptr : 125
+	SYS_munmap: uintptr : 91
+	SYS_madvise: uintptr : 220
+	SYS_futex : uintptr : 240
+	SYS_gettid : uintptr: 224
+	SYS_getrandom : uintptr : 384
+} else {
+	#panic("Unsupported architecture")
+}
+
+sys_gettid :: proc "contextless" () -> int {
+	return cast(int)intrinsics.syscall(SYS_gettid)
+}
+
+sys_getrandom :: proc "contextless" (buf: ^byte, buflen: int, flags: uint) -> int {
+	return cast(int)intrinsics.syscall(SYS_getrandom, buf, cast(uintptr)(buflen), cast(uintptr)(flags))
+}

From 6bafa21bee56ccfbdf74f88bf7937a900a7d22d9 Mon Sep 17 00:00:00 2001
From: Yawning Angel <yawning@schwanenlied.me>
Date: Thu, 11 Nov 2021 07:59:45 +0000
Subject: [PATCH 22/38] crypto: Add rand_bytes

This adds `rand_bytes(dst: []byte)` which fills the destination buffer
with entropy from the cryptographic random number generator.  This takes
the "simple is best" approach and just directly returns the OS CSPRNG
output instead of doing anything fancy (a la OpenBSD's arc4random).
---
 core/crypto/crypto.odin                       | 11 +++++
 core/crypto/rand_generic.odin                 |  7 ++++
 core/crypto/rand_linux.odin                   | 37 +++++++++++++++++
 tests/core/crypto/test_core_crypto.odin       |  1 +
 .../core/crypto/test_core_crypto_modern.odin  | 40 +++++++++++++++++++
 5 files changed, 96 insertions(+)
 create mode 100644 core/crypto/rand_generic.odin
 create mode 100644 core/crypto/rand_linux.odin

diff --git a/core/crypto/crypto.odin b/core/crypto/crypto.odin
index ddcc5d367..35e88c5ed 100644
--- a/core/crypto/crypto.odin
+++ b/core/crypto/crypto.odin
@@ -39,3 +39,14 @@ compare_byte_ptrs_constant_time :: proc "contextless" (a, b: ^byte, n: int) -> i
 	// iff v == 0, setting the sign-bit, which gets returned.
 	return int((u32(v)-1) >> 31)
 }
+
+// rand_bytes fills the dst buffer with cryptographic entropy taken from
+// the system entropy source.  This routine will block if the system entropy
+// source is not ready yet.  All system entropy source failures are treated
+// as catastrophic, resulting in a panic.
+rand_bytes :: proc (dst: []byte) {
+	// zero-fill the buffer first
+	mem.zero_explicit(raw_data(dst), len(dst))
+
+	_rand_bytes(dst)
+}
diff --git a/core/crypto/rand_generic.odin b/core/crypto/rand_generic.odin
new file mode 100644
index 000000000..98890b5b1
--- /dev/null
+++ b/core/crypto/rand_generic.odin
@@ -0,0 +1,7 @@
+package crypto
+
+when ODIN_OS != "linux" {
+	_rand_bytes :: proc (dst: []byte) {
+		unimplemented("crypto: rand_bytes not supported on this OS")
+	}
+}
diff --git a/core/crypto/rand_linux.odin b/core/crypto/rand_linux.odin
new file mode 100644
index 000000000..4d1183757
--- /dev/null
+++ b/core/crypto/rand_linux.odin
@@ -0,0 +1,37 @@
+package crypto
+
+import "core:fmt"
+import "core:os"
+import "core:sys/unix"
+
+_MAX_PER_CALL_BYTES :: 33554431 // 2^25 - 1
+
+_rand_bytes :: proc (dst: []byte) {
+	dst := dst
+	l := len(dst)
+
+	for l > 0 {
+		to_read := min(l, _MAX_PER_CALL_BYTES)
+		ret := unix.sys_getrandom(raw_data(dst), to_read, 0)
+		if ret < 0 {
+			switch os.Errno(-ret) {
+			case os.EINTR:
+				// Call interupted by a signal handler, just retry the
+				// request.
+				continue
+			case os.ENOSYS:
+				// The kernel is apparently prehistoric (< 3.17 circa 2014)
+				// and does not support getrandom.
+				panic("crypto: getrandom not available in kernel")
+			case:
+				// All other failures are things that should NEVER happen
+				// unless the kernel interface changes (ie: the Linux
+				// developers break userland).
+				panic(fmt.tprintf("crypto: getrandom failed: %d", ret))
+			}
+		}
+
+		l -= ret
+		dst = dst[ret:]
+	}
+}
diff --git a/tests/core/crypto/test_core_crypto.odin b/tests/core/crypto/test_core_crypto.odin
index 731833096..2ad00be66 100644
--- a/tests/core/crypto/test_core_crypto.odin
+++ b/tests/core/crypto/test_core_crypto.odin
@@ -120,6 +120,7 @@ main :: proc() {
     test_poly1305(&t)
     test_chacha20poly1305(&t)
     test_x25519(&t)
+    test_rand_bytes(&t)
 
     bench_modern(&t)
 
diff --git a/tests/core/crypto/test_core_crypto_modern.odin b/tests/core/crypto/test_core_crypto_modern.odin
index b3d9e47fd..71adad137 100644
--- a/tests/core/crypto/test_core_crypto_modern.odin
+++ b/tests/core/crypto/test_core_crypto_modern.odin
@@ -4,6 +4,7 @@ import "core:testing"
 import "core:fmt"
 import "core:mem"
 import "core:time"
+import "core:crypto"
 
 import "core:crypto/chacha20"
 import "core:crypto/chacha20poly1305"
@@ -303,6 +304,45 @@ test_x25519 :: proc(t: ^testing.T) {
     // how to work with JSON.
 }
 
+@(test)
+test_rand_bytes :: proc(t: ^testing.T) {
+	log(t, "Testing rand_bytes")
+
+	if ODIN_OS != "linux" {
+		log(t, "rand_bytes not supported - skipping")
+		return
+	}
+
+	allocator := context.allocator
+
+	buf := make([]byte, 1 << 25, allocator)
+	defer delete(buf)
+
+	// Testing a CSPRNG for correctness is incredibly involved and
+	// beyond the scope of an implementation that offloads
+	// responsibility for correctness to the OS.
+	//
+	// Just attempt to randomize a sufficiently large buffer, where
+	// sufficiently large is:
+	//  * Larger than the maximum getentropy request size (256 bytes).
+	//  * Larger than the maximum getrandom request size (2^25 - 1 bytes).
+	//
+	// While theoretically non-deterministic, if this fails, chances
+	// are the CSPRNG is busted.
+	seems_ok := false
+	for i := 0; i < 256; i = i + 1 {
+		mem.zero_explicit(raw_data(buf), len(buf))
+		crypto.rand_bytes(buf)
+
+		if buf[0] != 0 && buf[len(buf)-1] != 0 {
+			seems_ok = true
+			break
+		}
+	}
+
+	expect(t, seems_ok, "Expected to randomize the head and tail of the buffer within a handful of attempts")
+}
+
 @(test)
 bench_modern :: proc(t: ^testing.T) {
 	fmt.println("Starting benchmarks:")

From ae59f214ee6a47d3eb3832674928e7d66f9ac2e5 Mon Sep 17 00:00:00 2001
From: gingerBill <bill@gingerbill.org>
Date: Wed, 17 Nov 2021 21:32:33 +0000
Subject: [PATCH 23/38] `@(tag=<string>)` - dummy attribute for tooling

---
 src/checker.cpp | 48 ++++++++++++++++++++++++++++++++++++++++++------
 1 file changed, 42 insertions(+), 6 deletions(-)

diff --git a/src/checker.cpp b/src/checker.cpp
index fa74c23ed..c0a15905b 100644
--- a/src/checker.cpp
+++ b/src/checker.cpp
@@ -2603,11 +2603,18 @@ ExactValue check_decl_attribute_value(CheckerContext *c, Ast *value) {
 	return ev;
 }
 
+#define ATTRIBUTE_USER_TAG_NAME "tag"
+
 
 DECL_ATTRIBUTE_PROC(foreign_block_decl_attribute) {
 	ExactValue ev = check_decl_attribute_value(c, value);
 
-	if (name == "default_calling_convention") {
+	if (name == ATTRIBUTE_USER_TAG_NAME) {
+		if (ev.kind != ExactValue_String) {
+			error(elem, "Expected a string value for '%.*s'", LIT(name));
+		}
+		return true;
+	} else if (name == "default_calling_convention") {
 		if (ev.kind == ExactValue_String) {
 			auto cc = string_to_calling_convention(ev.value_string);
 			if (cc == ProcCC_Invalid) {
@@ -2655,7 +2662,13 @@ DECL_ATTRIBUTE_PROC(foreign_block_decl_attribute) {
 }
 
 DECL_ATTRIBUTE_PROC(proc_decl_attribute) {
-	if (name == "test") {
+	if (name == ATTRIBUTE_USER_TAG_NAME) {
+		ExactValue ev = check_decl_attribute_value(c, value);
+		if (ev.kind != ExactValue_String) {
+			error(elem, "Expected a string value for '%.*s'", LIT(name));
+		}
+		return true;
+	} else if (name == "test") {
 		if (value != nullptr) {
 			error(value, "'%.*s' expects no parameter, or a string literal containing \"file\" or \"package\"", LIT(name));
 		}
@@ -2896,7 +2909,12 @@ DECL_ATTRIBUTE_PROC(proc_decl_attribute) {
 DECL_ATTRIBUTE_PROC(var_decl_attribute) {
 	ExactValue ev = check_decl_attribute_value(c, value);
 
-	if (name == "static") {
+	if (name == ATTRIBUTE_USER_TAG_NAME) {
+		if (ev.kind != ExactValue_String) {
+			error(elem, "Expected a string value for '%.*s'", LIT(name));
+		}
+		return true;
+	} else if (name == "static") {
 		if (value != nullptr) {
 			error(elem, "'static' does not have any parameters");
 		}
@@ -3011,7 +3029,13 @@ DECL_ATTRIBUTE_PROC(var_decl_attribute) {
 }
 
 DECL_ATTRIBUTE_PROC(const_decl_attribute) {
-	if (name == "private") {
+	if (name == ATTRIBUTE_USER_TAG_NAME) {
+		ExactValue ev = check_decl_attribute_value(c, value);
+		if (ev.kind != ExactValue_String) {
+			error(elem, "Expected a string value for '%.*s'", LIT(name));
+		}
+		return true;
+	} else if (name == "private") {
 		// NOTE(bill): Handled elsewhere `check_collect_value_decl`
 		return true;
 	}
@@ -3019,7 +3043,13 @@ DECL_ATTRIBUTE_PROC(const_decl_attribute) {
 }
 
 DECL_ATTRIBUTE_PROC(type_decl_attribute) {
-	if (name == "private") {
+	if (name == ATTRIBUTE_USER_TAG_NAME) {
+		ExactValue ev = check_decl_attribute_value(c, value);
+		if (ev.kind != ExactValue_String) {
+			error(elem, "Expected a string value for '%.*s'", LIT(name));
+		}
+		return true;
+	} else if (name == "private") {
 		// NOTE(bill): Handled elsewhere `check_collect_value_decl`
 		return true;
 	}
@@ -4020,7 +4050,13 @@ void check_add_import_decl(CheckerContext *ctx, Ast *decl) {
 }
 
 DECL_ATTRIBUTE_PROC(foreign_import_decl_attribute) {
-	if (name == "force" || name == "require") {
+	if (name == ATTRIBUTE_USER_TAG_NAME) {
+		ExactValue ev = check_decl_attribute_value(c, value);
+		if (ev.kind != ExactValue_String) {
+			error(elem, "Expected a string value for '%.*s'", LIT(name));
+		}
+		return true;
+	} else if (name == "force" || name == "require") {
 		if (value != nullptr) {
 			error(elem, "Expected no parameter for '%.*s'", LIT(name));
 		} else if (name == "force") {

From 61bc963e92964af4d92a0e8a8d1ff5e2520836c3 Mon Sep 17 00:00:00 2001
From: Patric Dexheimer <patric.dexheimer@gmail.com>
Date: Wed, 17 Nov 2021 19:03:01 -0300
Subject: [PATCH 24/38] GetMouseDelta

---
 vendor/raylib/raylib.odin | 3 ++-
 1 file changed, 2 insertions(+), 1 deletion(-)

diff --git a/vendor/raylib/raylib.odin b/vendor/raylib/raylib.odin
index 0c4dc6365..fb4d7dd92 100644
--- a/vendor/raylib/raylib.odin
+++ b/vendor/raylib/raylib.odin
@@ -1077,6 +1077,7 @@ foreign lib {
 	GetMouseX             :: proc() -> c.int ---                      // Returns mouse position X
 	GetMouseY             :: proc() -> c.int ---                      // Returns mouse position Y
 	GetMousePosition      :: proc() -> Vector2 ---                    // Returns mouse position XY
+	GetMouseDelta         :: proc() -> Vector2 ---                    // Returns mouse delta XY
 	SetMousePosition      :: proc(x, y: c.int) ---                    // Set mouse position XY
 	SetMouseOffset        :: proc(offsetX, offsetY: c.int) ---        // Set mouse offset
 	SetMouseScale         :: proc(scaleX, scaleY: f32) ---            // Set mouse scaling
@@ -1568,4 +1569,4 @@ MemAllocatorProc :: proc(allocator_data: rawptr, mode: mem.Allocator_Mode,
 		return nil, .Mode_Not_Implemented
 	}	
 	return nil, .Mode_Not_Implemented
-}
\ No newline at end of file
+}

From 12c1291805ce2aecc2f730c3db335e99181c7290 Mon Sep 17 00:00:00 2001
From: gingerBill <bill@gingerbill.org>
Date: Thu, 18 Nov 2021 16:14:33 +0000
Subject: [PATCH 25/38] Add optional seed parameters to all hashes

---
 core/hash/hash.odin | 42 ++++++++++++++++++++----------------------
 1 file changed, 20 insertions(+), 22 deletions(-)

diff --git a/core/hash/hash.odin b/core/hash/hash.odin
index 64c7ad5c4..f0d01bd25 100644
--- a/core/hash/hash.odin
+++ b/core/hash/hash.odin
@@ -47,8 +47,8 @@ adler32 :: proc(data: []byte, seed := u32(1)) -> u32 #no_bounds_check {
 }
 
 @(optimization_mode="speed")
-djb2 :: proc(data: []byte) -> u32 {
-	hash: u32 = 5381
+djb2 :: proc(data: []byte, seed := u32(5381)) -> u32 {
+	hash: u32 = seed
 	for b in data {
 		hash = (hash << 5) + hash + u32(b) // hash * 33 + u32(b)
 	}
@@ -56,8 +56,8 @@ djb2 :: proc(data: []byte) -> u32 {
 }
 
 @(optimization_mode="speed")
-fnv32 :: proc(data: []byte) -> u32 {
-	h: u32 = 0x811c9dc5
+fnv32 :: proc(data: []byte, seed := u32(0x811c9dc5)) -> u32 {
+	h: u32 = seed
 	for b in data {
 		h = (h * 0x01000193) ~ u32(b)
 	}
@@ -65,8 +65,8 @@ fnv32 :: proc(data: []byte) -> u32 {
 }
 
 @(optimization_mode="speed")
-fnv64 :: proc(data: []byte) -> u64 {
-	h: u64 = 0xcbf29ce484222325
+fnv64 :: proc(data: []byte, seed := u64(0xcbf29ce484222325)) -> u64 {
+	h: u64 = seed
 	for b in data {
 		h = (h * 0x100000001b3) ~ u64(b)
 	}
@@ -74,8 +74,8 @@ fnv64 :: proc(data: []byte) -> u64 {
 }
 
 @(optimization_mode="speed")
-fnv32a :: proc(data: []byte) -> u32 {
-	h: u32 = 0x811c9dc5
+fnv32a :: proc(data: []byte, seed := u32(0x811c9dc5)) -> u32 {
+	h: u32 = seed
 	for b in data {
 		h = (h ~ u32(b)) * 0x01000193
 	}
@@ -83,8 +83,8 @@ fnv32a :: proc(data: []byte) -> u32 {
 }
 
 @(optimization_mode="speed")
-fnv64a :: proc(data: []byte) -> u64 {
-	h: u64 = 0xcbf29ce484222325
+fnv64a :: proc(data: []byte, seed := u64(0xcbf29ce484222325)) -> u64 {
+	h: u64 = seed
 	for b in data {
 		h = (h ~ u64(b)) * 0x100000001b3
 	}
@@ -92,8 +92,8 @@ fnv64a :: proc(data: []byte) -> u64 {
 }
 
 @(optimization_mode="speed")
-jenkins :: proc(data: []byte) -> u32 {
-	hash: u32 = 0
+jenkins :: proc(data: []byte, seed := u32(0)) -> u32 {
+	hash: u32 = seed
 	for b in data {
 		hash += u32(b)
 		hash += hash << 10
@@ -106,11 +106,11 @@ jenkins :: proc(data: []byte) -> u32 {
 }
 
 @(optimization_mode="speed")
-murmur32 :: proc(data: []byte) -> u32 {
+murmur32 :: proc(data: []byte, seed := u32(0)) -> u32 {
 	c1_32: u32 : 0xcc9e2d51
 	c2_32: u32 : 0x1b873593
 
-	h1: u32 = 0
+	h1: u32 = seed
 	nblocks := len(data)/4
 	p := raw_data(data)
 	p1 := mem.ptr_offset(p, 4*nblocks)
@@ -156,14 +156,12 @@ murmur32 :: proc(data: []byte) -> u32 {
 }
 
 @(optimization_mode="speed")
-murmur64 :: proc(data: []byte) -> u64 {
-	SEED :: 0x9747b28c
-
+murmur64 :: proc(data: []byte, seed := u64(0x9747b28c)) -> u64 {
 	when size_of(int) == 8 {
 		m :: 0xc6a4a7935bd1e995
 		r :: 47
 
-		h: u64 = SEED ~ (u64(len(data)) * m)
+		h: u64 = seed ~ (u64(len(data)) * m)
 		data64 := mem.slice_ptr(cast(^u64)raw_data(data), len(data)/size_of(u64))
 
 		for _, i in data64 {
@@ -198,8 +196,8 @@ murmur64 :: proc(data: []byte) -> u64 {
 		m :: 0x5bd1e995
 		r :: 24
 
-		h1 := u32(SEED) ~ u32(len(data))
-		h2 := u32(SEED) >> 32
+		h1 := u32(seed) ~ u32(len(data))
+		h2 := u32(seed) >> 32
 		data32 := mem.slice_ptr(cast(^u32)raw_data(data), len(data)/size_of(u32))
 		len := len(data)
 		i := 0
@@ -262,8 +260,8 @@ murmur64 :: proc(data: []byte) -> u64 {
 }
 
 @(optimization_mode="speed")
-sdbm :: proc(data: []byte) -> u32 {
-	hash: u32 = 0
+sdbm :: proc(data: []byte, seed := u32(0)) -> u32 {
+	hash: u32 = seed
 	for b in data {
 		hash = u32(b) + (hash<<6) + (hash<<16) - hash
 	}

From 4439d59105daa74ab04433572e24891630ac0216 Mon Sep 17 00:00:00 2001
From: Michael Kutowski <skytrias@protonmail.com>
Date: Fri, 19 Nov 2021 00:24:56 +0100
Subject: [PATCH 26/38] add builtin.

---
 core/slice/slice.odin | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/core/slice/slice.odin b/core/slice/slice.odin
index 1dd777ccc..487dd46c2 100644
--- a/core/slice/slice.odin
+++ b/core/slice/slice.odin
@@ -20,7 +20,7 @@ swap :: proc(array: $T/[]$E, a, b: int) {
 }
 
 swap_between :: proc(a, b: $T/[]$E) {
-	n := min(len(a), len(b))
+	n := builtin.min(len(a), len(b))
 	if n >= 0 {
 		ptr_swap_overlapping(&a[0], &b[0], size_of(E)*n)
 	}	

From 3e04b451062d4e46bd26baad82d7c75ce5e9e1d9 Mon Sep 17 00:00:00 2001
From: gingerBill <bill@gingerbill.org>
Date: Fri, 19 Nov 2021 12:26:10 +0000
Subject: [PATCH 27/38] Allow cast from float to complex

---
 src/check_expr.cpp | 3 +++
 1 file changed, 3 insertions(+)

diff --git a/src/check_expr.cpp b/src/check_expr.cpp
index 96ca2d308..3c884d117 100644
--- a/src/check_expr.cpp
+++ b/src/check_expr.cpp
@@ -2453,6 +2453,9 @@ bool check_is_castable_to(CheckerContext *c, Operand *operand, Type *y) {
 		return true;
 	}
 
+	if (is_type_float(src) && is_type_complex(dst)) {
+		return true;
+	}
 	if (is_type_float(src) && is_type_quaternion(dst)) {
 		return true;
 	}

From daebaa8b5027731680037a12ad3e63936dc5aef2 Mon Sep 17 00:00:00 2001
From: gingerBill <bill@gingerbill.org>
Date: Fri, 19 Nov 2021 15:43:13 +0000
Subject: [PATCH 28/38] Fix #1319

---
 src/llvm_backend_expr.cpp    |  2 --
 src/llvm_backend_general.cpp | 11 ++++++++---
 src/llvm_backend_stmt.cpp    |  9 ++++++++-
 src/types.cpp                |  8 +++++++-
 4 files changed, 23 insertions(+), 7 deletions(-)

diff --git a/src/llvm_backend_expr.cpp b/src/llvm_backend_expr.cpp
index a23d60894..5187279fa 100644
--- a/src/llvm_backend_expr.cpp
+++ b/src/llvm_backend_expr.cpp
@@ -1841,7 +1841,6 @@ lbValue lb_emit_conv(lbProcedure *p, lbValue value, Type *t) {
 		return res;
 	}
 
-	#if 1
 	if (is_type_union(dst)) {
 		for_array(i, dst->Union.variants) {
 			Type *vt = dst->Union.variants[i];
@@ -1852,7 +1851,6 @@ lbValue lb_emit_conv(lbProcedure *p, lbValue value, Type *t) {
 			}
 		}
 	}
-	#endif
 
 	// NOTE(bill): This has to be done before 'Pointer <-> Pointer' as it's
 	// subtype polymorphism casting
diff --git a/src/llvm_backend_general.cpp b/src/llvm_backend_general.cpp
index b671f0c8f..17eeb0bea 100644
--- a/src/llvm_backend_general.cpp
+++ b/src/llvm_backend_general.cpp
@@ -1142,7 +1142,7 @@ lbValue lb_emit_union_tag_ptr(lbProcedure *p, lbValue u) {
 
 	LLVMTypeRef uvt = LLVMGetElementType(LLVMTypeOf(u.value));
 	unsigned element_count = LLVMCountStructElementTypes(uvt);
-	GB_ASSERT_MSG(element_count == 2, "element_count=%u (%s) != (%s)", element_count, type_to_string(ut), LLVMPrintTypeToString(uvt));
+	GB_ASSERT_MSG(element_count >= 2, "element_count=%u (%s) != (%s)", element_count, type_to_string(ut), LLVMPrintTypeToString(uvt));
 
 	lbValue tag_ptr = {};
 	tag_ptr.value = LLVMBuildStructGEP(p->builder, u.value, 1, "");
@@ -1795,7 +1795,7 @@ LLVMTypeRef lb_type_internal(lbModule *m, Type *type) {
 
 			unsigned block_size = cast(unsigned)type->Union.variant_block_size;
 
-			auto fields = array_make<LLVMTypeRef>(temporary_allocator(), 0, 2);
+			auto fields = array_make<LLVMTypeRef>(temporary_allocator(), 0, 3);
 			if (is_type_union_maybe_pointer(type)) {
 				LLVMTypeRef variant = lb_type(m, type->Union.variants[0]);
 				array_add(&fields, variant);
@@ -1804,7 +1804,12 @@ LLVMTypeRef lb_type_internal(lbModule *m, Type *type) {
 				LLVMTypeRef tag_type   = lb_type(m, union_tag_type(type));
 				array_add(&fields, block_type);
 				array_add(&fields, tag_type);
-				
+				i64 used_size = lb_sizeof(block_type) + lb_sizeof(tag_type);
+				i64 padding = size - used_size;
+				if (padding > 0) {
+					LLVMTypeRef padding_type = lb_type_padding_filler(m, padding, align);
+					array_add(&fields, padding_type);
+				}
 			}
 			
 			return LLVMStructTypeInContext(ctx, fields.data, cast(unsigned)fields.count, false);
diff --git a/src/llvm_backend_stmt.cpp b/src/llvm_backend_stmt.cpp
index c2ff0dfe1..016e464b8 100644
--- a/src/llvm_backend_stmt.cpp
+++ b/src/llvm_backend_stmt.cpp
@@ -1485,7 +1485,14 @@ void lb_build_return_stmt_internal(lbProcedure *p, lbValue const &res) {
 
 	if (return_by_pointer) {
 		if (res.value != nullptr) {
-			LLVMBuildStore(p->builder, res.value, p->return_ptr.addr.value);
+			LLVMValueRef res_val = res.value;
+			i64 sz = type_size_of(res.type);
+			if (LLVMIsALoadInst(res_val) && sz > build_context.word_size) {
+				lbValue ptr = lb_address_from_load_or_generate_local(p, res);
+				lb_mem_copy_non_overlapping(p, p->return_ptr.addr, ptr, lb_const_int(p->module, t_int, sz));
+			} else {
+				LLVMBuildStore(p->builder, res_val, p->return_ptr.addr.value);
+			}
 		} else {
 			LLVMBuildStore(p->builder, LLVMConstNull(p->abi_function_type->ret.type), p->return_ptr.addr.value);
 		}
diff --git a/src/types.cpp b/src/types.cpp
index e609815c6..c8bdbd72a 100644
--- a/src/types.cpp
+++ b/src/types.cpp
@@ -4019,7 +4019,13 @@ gbString write_type_to_string(gbString str, Type *type) {
 
 	case Type_BitSet:
 		str = gb_string_appendc(str, "bit_set[");
-		str = write_type_to_string(str, type->BitSet.elem);
+		if (is_type_enum(type->BitSet.elem)) {
+			str = write_type_to_string(str, type->BitSet.elem);
+		} else {
+			str = gb_string_append_fmt(str, "%lld", type->BitSet.lower);
+			str = gb_string_append_fmt(str, "..=");
+			str = gb_string_append_fmt(str, "%lld", type->BitSet.upper);
+		}
 		if (type->BitSet.underlying != nullptr) {
 			str = gb_string_appendc(str, "; ");
 			str = write_type_to_string(str, type->BitSet.underlying);

From 2c7bf87998ff41191697f7fce2509c5a76b721f6 Mon Sep 17 00:00:00 2001
From: Gus <43172308+Gaunsessa@users.noreply.github.com>
Date: Sat, 20 Nov 2021 20:02:21 +1100
Subject: [PATCH 29/38] Added darwin support

---
 vendor/glfw/bindings/bindings.odin | 1 +
 1 file changed, 1 insertion(+)

diff --git a/vendor/glfw/bindings/bindings.odin b/vendor/glfw/bindings/bindings.odin
index 06b5f5b32..84905f603 100644
--- a/vendor/glfw/bindings/bindings.odin
+++ b/vendor/glfw/bindings/bindings.odin
@@ -4,6 +4,7 @@ import "core:c"
 import vk "vendor:vulkan"
 
 when ODIN_OS == "linux"   { foreign import glfw "system:glfw" } // TODO: Add the billion-or-so static libs to link to in linux
+when ODIN_OS == "darwin"  { foreign import glfw "system:glfw" }
 when ODIN_OS == "windows" { 
 	foreign import glfw { 
 		"../lib/glfw3_mt.lib",

From 56d2bbc5b9509ecb10c8e700afc5cb14a5e23d8b Mon Sep 17 00:00:00 2001
From: Gus <43172308+Gaunsessa@users.noreply.github.com>
Date: Sat, 20 Nov 2021 20:03:54 +1100
Subject: [PATCH 30/38] Added back ln for js

---
 core/math/math_basic_js.odin | 14 +++++++++++++-
 1 file changed, 13 insertions(+), 1 deletion(-)

diff --git a/core/math/math_basic_js.odin b/core/math/math_basic_js.odin
index 06c8b636d..ec572f898 100644
--- a/core/math/math_basic_js.odin
+++ b/core/math/math_basic_js.odin
@@ -39,4 +39,16 @@ cos_f32     :: proc "c" (θ: f32) -> f32             { return f32(cos_f64(f64(θ
 pow_f32     :: proc "c" (x, power: f32) -> f32      { return f32(pow_f64(f64(x), f64(power)))         }
 fmuladd_f32 :: proc "c" (a, b, c: f32) -> f32       { return f32(fmuladd_f64(f64(a), f64(a), f64(c))) }
 ln_f32      :: proc "c" (x: f32) -> f32             { return f32(ln_f64(f64(x)))                      }
-exp_f32     :: proc "c" (x: f32) -> f32             { return f32(exp_f64(f64(x)))                     }
\ No newline at end of file
+exp_f32     :: proc "c" (x: f32) -> f32             { return f32(exp_f64(f64(x)))                     }
+
+ln_f16le :: proc "contextless" (x: f16le) -> f16le { return #force_inline f16le(ln_f64(f64(x))) }
+ln_f16be :: proc "contextless" (x: f16be) -> f16be { return #force_inline f16be(ln_f64(f64(x))) }
+ln_f32le :: proc "contextless" (x: f32le) -> f32le { return #force_inline f32le(ln_f64(f64(x))) }
+ln_f32be :: proc "contextless" (x: f32be) -> f32be { return #force_inline f32be(ln_f64(f64(x))) }
+ln_f64le :: proc "contextless" (x: f64le) -> f64le { return #force_inline f64le(ln_f64(f64(x))) }
+ln_f64be :: proc "contextless" (x: f64be) -> f64be { return #force_inline f64be(ln_f64(f64(x))) }
+ln :: proc{
+	ln_f16, ln_f16le, ln_f16be,
+	ln_f32, ln_f32le, ln_f32be,
+	ln_f64, ln_f64le, ln_f64be,
+}

From 446f1f6183498516028bee7e78903e1f659f3036 Mon Sep 17 00:00:00 2001
From: gingerBill <bill@gingerbill.org>
Date: Sat, 20 Nov 2021 19:27:34 +0000
Subject: [PATCH 31/38] Correct foreign imports for portmidi on Windows

---
 vendor/portmidi/portmidi.odin | 10 ++++++++--
 1 file changed, 8 insertions(+), 2 deletions(-)

diff --git a/vendor/portmidi/portmidi.odin b/vendor/portmidi/portmidi.odin
index 05b33aeff..0bf3b4a42 100644
--- a/vendor/portmidi/portmidi.odin
+++ b/vendor/portmidi/portmidi.odin
@@ -3,7 +3,13 @@ package portmidi
 import "core:c"
 import "core:strings"
 
-when ODIN_OS == "windows" { foreign import lib "portmidi.lib" }
+when ODIN_OS == "windows" { 
+	foreign import lib {
+		"portmidi_s.lib",
+		"system:Winmm.lib",
+		"system:Advapi32.lib",
+	}
+}
 
 #assert(size_of(b32) == size_of(c.int))
 
@@ -140,7 +146,7 @@ foreign lib {
 	    not be manipulated or freed. The pointer is guaranteed to be valid
 	    between calls to Initialize() and Terminate().
 	*/
-	GetDeviceInfo :: proc(id: DeviceID) -> DeviceInfo ---
+	GetDeviceInfo :: proc(id: DeviceID) -> ^DeviceInfo ---
 	
 	/**
 	    OpenInput() and OpenOutput() open devices.

From ca6951d05e845f6e141a3436307d362a490c7a01 Mon Sep 17 00:00:00 2001
From: gingerBill <bill@gingerbill.org>
Date: Sat, 20 Nov 2021 20:20:12 +0000
Subject: [PATCH 32/38] Add `MessageDecompose`; Update the static library

---
 vendor/portmidi/portmidi.odin  | 296 +++++++++++++++++----------------
 vendor/portmidi/portmidi_s.lib | Bin 177524 -> 76430 bytes
 2 files changed, 152 insertions(+), 144 deletions(-)

diff --git a/vendor/portmidi/portmidi.odin b/vendor/portmidi/portmidi.odin
index 0bf3b4a42..08f78150c 100644
--- a/vendor/portmidi/portmidi.odin
+++ b/vendor/portmidi/portmidi.odin
@@ -21,17 +21,17 @@ Error :: enum c.int {
 	GotData = 1, /**< A "no error" return that also indicates data available */
 	HostError = -10000,
 	InvalidDeviceId, /** out of range or 
-		            * output device when input is requested or 
-		            * input device when output is requested or
-		            * device is already opened 
-		            */
+	                   * output device when input is requested or 
+	                   * input device when output is requested or
+	                   * device is already opened 
+	                   */
 	InsufficientMemory,
 	BufferTooSmall,
 	BufferOverflow,
 	BadPtr, /* Stream parameter is nil or
-		     * stream is not opened or
-		     * stream is output when input is required or
-		     * stream is input when output is required */
+	         * stream is not opened or
+	         * stream is output when input is required or
+	         * stream is input when output is required */
 	BadData, /** illegal midi data, e.g. missing EOX */
 	InternalError,
 	BufferMaxSize, /** buffer is already as large as it can be */
@@ -44,30 +44,30 @@ Stream :: distinct rawptr
 @(default_calling_convention="c", link_prefix="Pm_")
 foreign lib {
 	/**
-	    Initialize() is the library initialisation function - call this before
-	    using the library.
+		Initialize() is the library initialisation function - call this before
+		using the library.
 	*/
 	Initialize :: proc() -> Error ---
 	
 	/**
-	    Terminate() is the library termination function - call this after
-	    using the library.
+		Terminate() is the library termination function - call this after
+		using the library.
 	*/
 	Terminate  :: proc() -> Error ---
 	
 	/**
-	    Test whether stream has a pending host error. Normally, the client finds
-	    out about errors through returned error codes, but some errors can occur
-	    asynchronously where the client does not
-	    explicitly call a function, and therefore cannot receive an error code.
-	    The client can test for a pending error using HasHostError(). If true,
-	    the error can be accessed and cleared by calling GetErrorText(). 
-	    Errors are also cleared by calling other functions that can return
-	    errors, e.g. OpenInput(), OpenOutput(), Read(), Write(). The
-	    client does not need to call HasHostError(). Any pending error will be
-	    reported the next time the client performs an explicit function call on 
-	    the stream, e.g. an input or output operation. Until the error is cleared,
-	    no new error codes will be obtained, even for a different stream.
+		Test whether stream has a pending host error. Normally, the client finds
+		out about errors through returned error codes, but some errors can occur
+		asynchronously where the client does not
+		explicitly call a function, and therefore cannot receive an error code.
+		The client can test for a pending error using HasHostError(). If true,
+		the error can be accessed and cleared by calling GetErrorText(). 
+		Errors are also cleared by calling other functions that can return
+		errors, e.g. OpenInput(), OpenOutput(), Read(), Write(). The
+		client does not need to call HasHostError(). Any pending error will be
+		reported the next time the client performs an explicit function call on 
+		the stream, e.g. an input or output operation. Until the error is cleared,
+		no new error codes will be obtained, even for a different stream.
 	*/
 	HasHostError :: proc(stream: Stream) -> b32 ---	
 }
@@ -109,8 +109,8 @@ DeviceInfo :: struct {
 	structVersion: c.int,   /**< this internal structure version */ 
 	interf:        cstring, /**< underlying MIDI API, e.g. MMSystem or DirectX */
 	name:          cstring, /**< device name, e.g. USB MidiSport 1x1 */
-	input:         c.int,   /**< true iff input is available */
-	output:        c.int,   /**< true iff output is available */
+	input:         b32,     /**< true iff input is available */
+	output:        b32,     /**< true iff output is available */
 	opened:        b32,     /**< used by generic PortMidi code to do error checking on arguments */
 }
 
@@ -138,79 +138,78 @@ Before :: #force_inline proc "c" (t1, t2: Timestamp) -> b32 {
 @(default_calling_convention="c", link_prefix="Pm_")
 foreign lib {
 	/**
-	    GetDeviceInfo() returns a pointer to a DeviceInfo structure
-	    referring to the device specified by id.
-	    If id is out of range the function returns nil.
+		GetDeviceInfo() returns a pointer to a DeviceInfo structure
+		referring to the device specified by id.
+		If id is out of range the function returns nil.
 
-	    The returned structure is owned by the PortMidi implementation and must
-	    not be manipulated or freed. The pointer is guaranteed to be valid
-	    between calls to Initialize() and Terminate().
+		The returned structure is owned by the PortMidi implementation and must
+		not be manipulated or freed. The pointer is guaranteed to be valid
+		between calls to Initialize() and Terminate().
 	*/
 	GetDeviceInfo :: proc(id: DeviceID) -> ^DeviceInfo ---
 	
 	/**
-	    OpenInput() and OpenOutput() open devices.
+		OpenInput() and OpenOutput() open devices.
 
-	    stream is the address of a Stream pointer which will receive
-	    a pointer to the newly opened stream.
+		stream is the address of a Stream pointer which will receive
+		a pointer to the newly opened stream.
 
-	    inputDevice is the id of the device used for input (see DeviceID above).
+		inputDevice is the id of the device used for input (see DeviceID above).
 
-	    inputDriverInfo is a pointer to an optional driver specific data structure
-	    containing additional information for device setup or handle processing.
-	    inputDriverInfo is never required for correct operation. If not used
-	    inputDriverInfo should be nil.
+		inputDriverInfo is a pointer to an optional driver specific data structure
+		containing additional information for device setup or handle processing.
+		inputDriverInfo is never required for correct operation. If not used
+		inputDriverInfo should be nil.
 
-	    outputDevice is the id of the device used for output (see DeviceID above.)
+		outputDevice is the id of the device used for output (see DeviceID above.)
 
-	    outputDriverInfo is a pointer to an optional driver specific data structure
-	    containing additional information for device setup or handle processing.
-	    outputDriverInfo is never required for correct operation. If not used
-	    outputDriverInfo should be nil.
+		outputDriverInfo is a pointer to an optional driver specific data structure
+		containing additional information for device setup or handle processing.
+		outputDriverInfo is never required for correct operation. If not used
+		outputDriverInfo should be nil.
 
-	    For input, the buffersize specifies the number of input events to be 
-	    buffered waiting to be read using Read(). For output, buffersize 
-	    specifies the number of output events to be buffered waiting for output. 
-	    (In some cases -- see below -- PortMidi does not buffer output at all
-	    and merely passes data to a lower-level API, in which case buffersize
-	    is ignored.)
-	    
-	    latency is the delay in milliseconds applied to timestamps to determine 
-	    when the output should actually occur. (If latency is < 0, 0 is assumed.) 
-	    If latency is zero, timestamps are ignored and all output is delivered
-	    immediately. If latency is greater than zero, output is delayed until the
-	    message timestamp plus the latency. (NOTE: the time is measured relative 
-	    to the time source indicated by time_proc. Timestamps are absolute,
-	    not relative delays or offsets.) In some cases, PortMidi can obtain
-	    better timing than your application by passing timestamps along to the
-	    device driver or hardware. Latency may also help you to synchronize midi
-	    data to audio data by matching midi latency to the audio buffer latency.
+		For input, the buffersize specifies the number of input events to be 
+		buffered waiting to be read using Read(). For output, buffersize 
+		specifies the number of output events to be buffered waiting for output. 
+		(In some cases -- see below -- PortMidi does not buffer output at all
+		and merely passes data to a lower-level API, in which case buffersize
+		is ignored.)
 
-	    time_proc is a pointer to a procedure that returns time in milliseconds. It
-	    may be nil, in which case a default millisecond timebase (PortTime) is 
-	    used. If the application wants to use PortTime, it should start the timer
-	    (call Pt_Start) before calling OpenInput or OpenOutput. If the
-	    application tries to start the timer *after* OpenInput or OpenOutput,
-	    it may get a ptAlreadyStarted error from Pt_Start, and the application's
-	    preferred time resolution and callback function will be ignored.
-	    time_proc result values are appended to incoming MIDI data, and time_proc
-	    times are used to schedule outgoing MIDI data (when latency is non-zero).
+		latency is the delay in milliseconds applied to timestamps to determine 
+		when the output should actually occur. (If latency is < 0, 0 is assumed.) 
+		If latency is zero, timestamps are ignored and all output is delivered
+		immediately. If latency is greater than zero, output is delayed until the
+		message timestamp plus the latency. (NOTE: the time is measured relative 
+		to the time source indicated by time_proc. Timestamps are absolute,
+		not relative delays or offsets.) In some cases, PortMidi can obtain
+		better timing than your application by passing timestamps along to the
+		device driver or hardware. Latency may also help you to synchronize midi
+		data to audio data by matching midi latency to the audio buffer latency.
 
-	    time_info is a pointer passed to time_proc.
+		time_proc is a pointer to a procedure that returns time in milliseconds. It
+		may be nil, in which case a default millisecond timebase (PortTime) is 
+		used. If the application wants to use PortTime, it should start the timer
+		(call Pt_Start) before calling OpenInput or OpenOutput. If the
+		application tries to start the timer *after* OpenInput or OpenOutput,
+		it may get a ptAlreadyStarted error from Pt_Start, and the application's
+		preferred time resolution and callback function will be ignored.
+		time_proc result values are appended to incoming MIDI data, and time_proc
+		times are used to schedule outgoing MIDI data (when latency is non-zero).
 
-	    Example: If I provide a timestamp of 5000, latency is 1, and time_proc
-	    returns 4990, then the desired output time will be when time_proc returns
-	    timestamp+latency = 5001. This will be 5001-4990 = 11ms from now.
+		time_info is a pointer passed to time_proc.
 
-	    return value:
-	    Upon success Open() returns NoError and places a pointer to a
-	    valid Stream in the stream argument.
-	    If a call to Open() fails a nonzero error code is returned (see
-	    PMError above) and the value of port is invalid.
+		Example: If I provide a timestamp of 5000, latency is 1, and time_proc
+		returns 4990, then the desired output time will be when time_proc returns
+		timestamp+latency = 5001. This will be 5001-4990 = 11ms from now.
 
-	    Any stream that is successfully opened should eventually be closed
-	    by calling Close().
+		return value:
+		Upon success Open() returns NoError and places a pointer to a
+		valid Stream in the stream argument.
+		If a call to Open() fails a nonzero error code is returned (see
+		PMError above) and the value of port is invalid.
 
+		Any stream that is successfully opened should eventually be closed
+		by calling Close().
 	*/
 	OpenInput :: proc(stream: ^Stream,
 	                  inputDevice: DeviceID,
@@ -379,71 +378,80 @@ MessageData2  :: #force_inline proc "c" (msg: Message) -> c.int {
 	return c.int((msg >> 16) & 0xFF)
 }
 
+MessageCompose :: MessageMake
+MessageDecompose :: #force_inline proc "c" (msg: Message) -> (status, data1, data2: c.int) {
+	status = c.int(msg & 0xFF)
+	data1  = c.int((msg >> 8) & 0xFF)
+	data2  = c.int((msg >> 16) & 0xFF)
+	return
+}
+
+
 Message :: distinct i32
 /**
-   All midi data comes in the form of Event structures. A sysex
-   message is encoded as a sequence of Event structures, with each
-   structure carrying 4 bytes of the message, i.e. only the first
-   Event carries the status byte.
+	All midi data comes in the form of Event structures. A sysex
+	message is encoded as a sequence of Event structures, with each
+	structure carrying 4 bytes of the message, i.e. only the first
+	Event carries the status byte.
 
-   Note that MIDI allows nested messages: the so-called "real-time" MIDI 
-   messages can be inserted into the MIDI byte stream at any location, 
-   including within a sysex message. MIDI real-time messages are one-byte
-   messages used mainly for timing (see the MIDI spec). PortMidi retains 
-   the order of non-real-time MIDI messages on both input and output, but 
-   it does not specify exactly how real-time messages are processed. This
-   is particulary problematic for MIDI input, because the input parser 
-   must either prepare to buffer an unlimited number of sysex message 
-   bytes or to buffer an unlimited number of real-time messages that 
-   arrive embedded in a long sysex message. To simplify things, the input
-   parser is allowed to pass real-time MIDI messages embedded within a 
-   sysex message, and it is up to the client to detect, process, and 
-   remove these messages as they arrive.
+	Note that MIDI allows nested messages: the so-called "real-time" MIDI 
+	messages can be inserted into the MIDI byte stream at any location, 
+	including within a sysex message. MIDI real-time messages are one-byte
+	messages used mainly for timing (see the MIDI spec). PortMidi retains 
+	the order of non-real-time MIDI messages on both input and output, but 
+	it does not specify exactly how real-time messages are processed. This
+	is particulary problematic for MIDI input, because the input parser 
+	must either prepare to buffer an unlimited number of sysex message 
+	bytes or to buffer an unlimited number of real-time messages that 
+	arrive embedded in a long sysex message. To simplify things, the input
+	parser is allowed to pass real-time MIDI messages embedded within a 
+	sysex message, and it is up to the client to detect, process, and 
+	remove these messages as they arrive.
 
-   When receiving sysex messages, the sysex message is terminated
-   by either an EOX status byte (anywhere in the 4 byte messages) or
-   by a non-real-time status byte in the low order byte of the message.
-   If you get a non-real-time status byte but there was no EOX byte, it 
-   means the sysex message was somehow truncated. This is not
-   considered an error; e.g., a missing EOX can result from the user
-   disconnecting a MIDI cable during sysex transmission.
+	When receiving sysex messages, the sysex message is terminated
+	by either an EOX status byte (anywhere in the 4 byte messages) or
+	by a non-real-time status byte in the low order byte of the message.
+	If you get a non-real-time status byte but there was no EOX byte, it 
+	means the sysex message was somehow truncated. This is not
+	considered an error; e.g., a missing EOX can result from the user
+	disconnecting a MIDI cable during sysex transmission.
 
-   A real-time message can occur within a sysex message. A real-time 
-   message will always occupy a full Event with the status byte in 
-   the low-order byte of the Event message field. (This implies that
-   the byte-order of sysex bytes and real-time message bytes may not
-   be preserved -- for example, if a real-time message arrives after
-   3 bytes of a sysex message, the real-time message will be delivered
-   first. The first word of the sysex message will be delivered only
-   after the 4th byte arrives, filling the 4-byte Event message field.
-   
-   The timestamp field is observed when the output port is opened with
-   a non-zero latency. A timestamp of zero means "use the current time",
-   which in turn means to deliver the message with a delay of
-   latency (the latency parameter used when opening the output port.)
-   Do not expect PortMidi to sort data according to timestamps -- 
-   messages should be sent in the correct order, and timestamps MUST 
-   be non-decreasing. See also "Example" for OpenOutput() above.
+	A real-time message can occur within a sysex message. A real-time 
+	message will always occupy a full Event with the status byte in 
+	the low-order byte of the Event message field. (This implies that
+	the byte-order of sysex bytes and real-time message bytes may not
+	be preserved -- for example, if a real-time message arrives after
+	3 bytes of a sysex message, the real-time message will be delivered
+	first. The first word of the sysex message will be delivered only
+	after the 4th byte arrives, filling the 4-byte Event message field.
 
-   A sysex message will generally fill many Event structures. On 
-   output to a Stream with non-zero latency, the first timestamp
-   on sysex message data will determine the time to begin sending the 
-   message. PortMidi implementations may ignore timestamps for the 
-   remainder of the sysex message. 
-   
-   On input, the timestamp ideally denotes the arrival time of the 
-   status byte of the message. The first timestamp on sysex message 
-   data will be valid. Subsequent timestamps may denote 
-   when message bytes were actually received, or they may be simply 
-   copies of the first timestamp.
+	The timestamp field is observed when the output port is opened with
+	a non-zero latency. A timestamp of zero means "use the current time",
+	which in turn means to deliver the message with a delay of
+	latency (the latency parameter used when opening the output port.)
+	Do not expect PortMidi to sort data according to timestamps -- 
+	messages should be sent in the correct order, and timestamps MUST 
+	be non-decreasing. See also "Example" for OpenOutput() above.
 
-   Timestamps for nested messages: If a real-time message arrives in 
-   the middle of some other message, it is enqueued immediately with 
-   the timestamp corresponding to its arrival time. The interrupted 
-   non-real-time message or 4-byte packet of sysex data will be enqueued 
-   later. The timestamp of interrupted data will be equal to that of
-   the interrupting real-time message to insure that timestamps are
-   non-decreasing.
+	A sysex message will generally fill many Event structures. On 
+	output to a Stream with non-zero latency, the first timestamp
+	on sysex message data will determine the time to begin sending the 
+	message. PortMidi implementations may ignore timestamps for the 
+	remainder of the sysex message. 
+
+	On input, the timestamp ideally denotes the arrival time of the 
+	status byte of the message. The first timestamp on sysex message 
+	data will be valid. Subsequent timestamps may denote 
+	when message bytes were actually received, or they may be simply 
+	copies of the first timestamp.
+
+	Timestamps for nested messages: If a real-time message arrives in 
+	the middle of some other message, it is enqueued immediately with 
+	the timestamp corresponding to its arrival time. The interrupted 
+	non-real-time message or 4-byte packet of sysex data will be enqueued 
+	later. The timestamp of interrupted data will be equal to that of
+	the interrupting real-time message to insure that timestamps are
+	non-decreasing.
  */
 Event :: struct {
 	message:   Message,
@@ -486,18 +494,18 @@ foreign lib {
 	
 	/** 
 		Write() writes midi data from a buffer. This may contain:
-		    - short messages 
+			- short messages 
 		or 
-		    - sysex messages that are converted into a sequence of Event
-		      structures, e.g. sending data from a file or forwarding them
-		      from midi input.
+			- sysex messages that are converted into a sequence of Event
+			  structures, e.g. sending data from a file or forwarding them
+			  from midi input.
 
 		Use WriteSysEx() to write a sysex message stored as a contiguous 
 		array of bytes.
 
 		Sysex data may contain embedded real-time messages.
 	*/
-	Write      :: proc(stream: Stream, buffer: [^]Event, length: i32) -> Error ---
+	Write :: proc(stream: Stream, buffer: [^]Event, length: i32) -> Error ---
 	
 	/**
 		WriteShort() writes a timestamped non-system-exclusive midi message.
diff --git a/vendor/portmidi/portmidi_s.lib b/vendor/portmidi/portmidi_s.lib
index 7dd7de4a9566b81710c76a2c6c3c1e6911b6b2af..4f8b4f0e9e709db4fd07c479dc84a766170d239f 100644
GIT binary patch
literal 76430
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

literal 177524
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
Pf1?7rD>A&gH~;?t_}U@?


From 42b9ce636f72bcad6cb04817d42bb39ba952c1a7 Mon Sep 17 00:00:00 2001
From: gingerBill <bill@gingerbill.org>
Date: Sun, 21 Nov 2021 13:59:28 +0000
Subject: [PATCH 33/38] Remove `#force_inline` from all wrappers

---
 vendor/OpenGL/wrappers.odin | 2802 +++++++++++++++++------------------
 1 file changed, 1401 insertions(+), 1401 deletions(-)

diff --git a/vendor/OpenGL/wrappers.odin b/vendor/OpenGL/wrappers.odin
index 2d805d952..f3bd9166b 100644
--- a/vendor/OpenGL/wrappers.odin
+++ b/vendor/OpenGL/wrappers.odin
@@ -4,748 +4,748 @@ package odin_gl
 
 when !ODIN_DEBUG {
 	// VERSION_1_0
-	CullFace               :: #force_inline proc "c" (mode: u32)                                                                                         {        impl_CullFace(mode)                                                                         }
-	FrontFace              :: #force_inline proc "c" (mode: u32)                                                                                         {        impl_FrontFace(mode)                                                                        }
-	Hint                   :: #force_inline proc "c" (target, mode: u32)                                                                                 {        impl_Hint(target, mode)                                                                     }
-	LineWidth              :: #force_inline proc "c" (width: f32)                                                                                        {        impl_LineWidth(width)                                                                       }
-	PointSize              :: #force_inline proc "c" (size: f32)                                                                                         {        impl_PointSize(size)                                                                        }
-	PolygonMode            :: #force_inline proc "c" (face, mode: u32)                                                                                   {        impl_PolygonMode(face, mode)                                                                }
-	Scissor                :: #force_inline proc "c" (x, y, width, height: i32)                                                                          {        impl_Scissor(x, y, width, height)                                                           }
-	TexParameterf          :: #force_inline proc "c" (target, pname: u32, param: f32)                                                                    {        impl_TexParameterf(target, pname, param)                                                    }
-	TexParameterfv         :: #force_inline proc "c" (target, pname: u32, params: [^]f32)                                                                {        impl_TexParameterfv(target, pname, params)                                                  }
-	TexParameteri          :: #force_inline proc "c" (target, pname: u32, param: i32)                                                                    {        impl_TexParameteri(target, pname, param)                                                    }
-	TexParameteriv         :: #force_inline proc "c" (target, pname: u32, params: [^]i32)                                                                {        impl_TexParameteriv(target, pname, params)                                                  }
-	TexImage1D             :: #force_inline proc "c" (target: u32, level, internalformat, width, border: i32, format, type: u32, pixels: rawptr)         {        impl_TexImage1D(target, level, internalformat, width, border, format, type, pixels)         }
-	TexImage2D             :: #force_inline proc "c" (target: u32, level, internalformat, width, height, border: i32, format, type: u32, pixels: rawptr) {        impl_TexImage2D(target, level, internalformat, width, height, border, format, type, pixels) }
-	DrawBuffer             :: #force_inline proc "c" (buf: u32)                                                                                          {        impl_DrawBuffer(buf)                                                                        }
-	Clear                  :: #force_inline proc "c" (mask: u32)                                                                                         {        impl_Clear(mask)                                                                            }
-	ClearColor             :: #force_inline proc "c" (red, green, blue, alpha: f32)                                                                      {        impl_ClearColor(red, green, blue, alpha)                                                    }
-	ClearStencil           :: #force_inline proc "c" (s: i32)                                                                                            {        impl_ClearStencil(s)                                                                        }
-	ClearDepth             :: #force_inline proc "c" (depth: f64)                                                                                        {        impl_ClearDepth(depth)                                                                      }
-	StencilMask            :: #force_inline proc "c" (mask: u32)                                                                                         {        impl_StencilMask(mask)                                                                      }
-	ColorMask              :: #force_inline proc "c" (red, green, blue, alpha: bool)                                                                     {        impl_ColorMask(red, green, blue, alpha)                                                     }
-	DepthMask              :: #force_inline proc "c" (flag: bool)                                                                                        {        impl_DepthMask(flag)                                                                        }
-	Disable                :: #force_inline proc "c" (cap: u32)                                                                                          {        impl_Disable(cap)                                                                           }
-	Enable                 :: #force_inline proc "c" (cap: u32)                                                                                          {        impl_Enable(cap)                                                                            }
-	Finish                 :: #force_inline proc "c" ()                                                                                                  {        impl_Finish()                                                                               }
-	Flush                  :: #force_inline proc "c" ()                                                                                                  {        impl_Flush()                                                                                }
-	BlendFunc              :: #force_inline proc "c" (sfactor, dfactor: u32)                                                                             {        impl_BlendFunc(sfactor, dfactor)                                                            }
-	LogicOp                :: #force_inline proc "c" (opcode: u32)                                                                                       {        impl_LogicOp(opcode)                                                                        }
-	StencilFunc            :: #force_inline proc "c" (func: u32, ref: i32, mask: u32)                                                                    {        impl_StencilFunc(func, ref, mask)                                                           }
-	StencilOp              :: #force_inline proc "c" (fail, zfail, zpass: u32)                                                                           {        impl_StencilOp(fail, zfail, zpass)                                                          }
-	DepthFunc              :: #force_inline proc "c" (func: u32)                                                                                         {        impl_DepthFunc(func)                                                                        }
-	PixelStoref            :: #force_inline proc "c" (pname: u32, param: f32)                                                                            {        impl_PixelStoref(pname, param)                                                              }
-	PixelStorei            :: #force_inline proc "c" (pname: u32, param: i32)                                                                            {        impl_PixelStorei(pname, param)                                                              }
-	ReadBuffer             :: #force_inline proc "c" (src: u32)                                                                                          {        impl_ReadBuffer(src)                                                                        }
-	ReadPixels             :: #force_inline proc "c" (x, y, width, height: i32, format, type: u32, pixels: rawptr)                                       {        impl_ReadPixels(x, y, width, height, format, type, pixels)                                  }
-	GetBooleanv            :: #force_inline proc "c" (pname: u32, data: ^bool)                                                                           {        impl_GetBooleanv(pname, data)                                                               }
-	GetDoublev             :: #force_inline proc "c" (pname: u32, data: ^f64)                                                                            {        impl_GetDoublev(pname, data)                                                                }
-	GetError               :: #force_inline proc "c" () -> u32                                                                                           { return impl_GetError()                                                                             }
-	GetFloatv              :: #force_inline proc "c" (pname: u32, data: ^f32)                                                                            {        impl_GetFloatv(pname, data)                                                                 }
-	GetIntegerv            :: #force_inline proc "c" (pname: u32, data: ^i32)                                                                            {        impl_GetIntegerv(pname, data)                                                               }
-	GetString              :: #force_inline proc "c" (name: u32) -> cstring                                                                              { return impl_GetString(name)                                                                        }
-	GetTexImage            :: #force_inline proc "c" (target: u32,  level: i32, format, type: u32, pixels: rawptr)                                       {        impl_GetTexImage(target,  level, format, type, pixels)                                      }
-	GetTexParameterfv      :: #force_inline proc "c" (target, pname: u32, params: [^]f32)                                                                {        impl_GetTexParameterfv(target, pname, params)                                               }
-	GetTexParameteriv      :: #force_inline proc "c" (target, pname: u32, params: [^]i32)                                                                {        impl_GetTexParameteriv(target, pname, params)                                               }
-	GetTexLevelParameterfv :: #force_inline proc "c" (target: u32, level: i32, pname: u32, params: [^]f32)                                               {        impl_GetTexLevelParameterfv(target, level, pname, params)                                   }
-	GetTexLevelParameteriv :: #force_inline proc "c" (target: u32, level: i32, pname: u32, params: [^]i32)                                               {        impl_GetTexLevelParameteriv(target, level, pname, params)                                   }
-	IsEnabled              :: #force_inline proc "c" (cap: u32) -> bool                                                                                  { return impl_IsEnabled(cap)                                                                         }
-	DepthRange             :: #force_inline proc "c" (near, far: f64)                                                                                    {        impl_DepthRange(near, far)                                                                  }
-	Viewport               :: #force_inline proc "c" (x, y, width, height: i32)                                                                          {        impl_Viewport(x, y, width, height)                                                          }
+	CullFace               :: proc "c" (mode: u32)                                                                                         {        impl_CullFace(mode)                                                                         }
+	FrontFace              :: proc "c" (mode: u32)                                                                                         {        impl_FrontFace(mode)                                                                        }
+	Hint                   :: proc "c" (target, mode: u32)                                                                                 {        impl_Hint(target, mode)                                                                     }
+	LineWidth              :: proc "c" (width: f32)                                                                                        {        impl_LineWidth(width)                                                                       }
+	PointSize              :: proc "c" (size: f32)                                                                                         {        impl_PointSize(size)                                                                        }
+	PolygonMode            :: proc "c" (face, mode: u32)                                                                                   {        impl_PolygonMode(face, mode)                                                                }
+	Scissor                :: proc "c" (x, y, width, height: i32)                                                                          {        impl_Scissor(x, y, width, height)                                                           }
+	TexParameterf          :: proc "c" (target, pname: u32, param: f32)                                                                    {        impl_TexParameterf(target, pname, param)                                                    }
+	TexParameterfv         :: proc "c" (target, pname: u32, params: [^]f32)                                                                {        impl_TexParameterfv(target, pname, params)                                                  }
+	TexParameteri          :: proc "c" (target, pname: u32, param: i32)                                                                    {        impl_TexParameteri(target, pname, param)                                                    }
+	TexParameteriv         :: proc "c" (target, pname: u32, params: [^]i32)                                                                {        impl_TexParameteriv(target, pname, params)                                                  }
+	TexImage1D             :: proc "c" (target: u32, level, internalformat, width, border: i32, format, type: u32, pixels: rawptr)         {        impl_TexImage1D(target, level, internalformat, width, border, format, type, pixels)         }
+	TexImage2D             :: proc "c" (target: u32, level, internalformat, width, height, border: i32, format, type: u32, pixels: rawptr) {        impl_TexImage2D(target, level, internalformat, width, height, border, format, type, pixels) }
+	DrawBuffer             :: proc "c" (buf: u32)                                                                                          {        impl_DrawBuffer(buf)                                                                        }
+	Clear                  :: proc "c" (mask: u32)                                                                                         {        impl_Clear(mask)                                                                            }
+	ClearColor             :: proc "c" (red, green, blue, alpha: f32)                                                                      {        impl_ClearColor(red, green, blue, alpha)                                                    }
+	ClearStencil           :: proc "c" (s: i32)                                                                                            {        impl_ClearStencil(s)                                                                        }
+	ClearDepth             :: proc "c" (depth: f64)                                                                                        {        impl_ClearDepth(depth)                                                                      }
+	StencilMask            :: proc "c" (mask: u32)                                                                                         {        impl_StencilMask(mask)                                                                      }
+	ColorMask              :: proc "c" (red, green, blue, alpha: bool)                                                                     {        impl_ColorMask(red, green, blue, alpha)                                                     }
+	DepthMask              :: proc "c" (flag: bool)                                                                                        {        impl_DepthMask(flag)                                                                        }
+	Disable                :: proc "c" (cap: u32)                                                                                          {        impl_Disable(cap)                                                                           }
+	Enable                 :: proc "c" (cap: u32)                                                                                          {        impl_Enable(cap)                                                                            }
+	Finish                 :: proc "c" ()                                                                                                  {        impl_Finish()                                                                               }
+	Flush                  :: proc "c" ()                                                                                                  {        impl_Flush()                                                                                }
+	BlendFunc              :: proc "c" (sfactor, dfactor: u32)                                                                             {        impl_BlendFunc(sfactor, dfactor)                                                            }
+	LogicOp                :: proc "c" (opcode: u32)                                                                                       {        impl_LogicOp(opcode)                                                                        }
+	StencilFunc            :: proc "c" (func: u32, ref: i32, mask: u32)                                                                    {        impl_StencilFunc(func, ref, mask)                                                           }
+	StencilOp              :: proc "c" (fail, zfail, zpass: u32)                                                                           {        impl_StencilOp(fail, zfail, zpass)                                                          }
+	DepthFunc              :: proc "c" (func: u32)                                                                                         {        impl_DepthFunc(func)                                                                        }
+	PixelStoref            :: proc "c" (pname: u32, param: f32)                                                                            {        impl_PixelStoref(pname, param)                                                              }
+	PixelStorei            :: proc "c" (pname: u32, param: i32)                                                                            {        impl_PixelStorei(pname, param)                                                              }
+	ReadBuffer             :: proc "c" (src: u32)                                                                                          {        impl_ReadBuffer(src)                                                                        }
+	ReadPixels             :: proc "c" (x, y, width, height: i32, format, type: u32, pixels: rawptr)                                       {        impl_ReadPixels(x, y, width, height, format, type, pixels)                                  }
+	GetBooleanv            :: proc "c" (pname: u32, data: ^bool)                                                                           {        impl_GetBooleanv(pname, data)                                                               }
+	GetDoublev             :: proc "c" (pname: u32, data: ^f64)                                                                            {        impl_GetDoublev(pname, data)                                                                }
+	GetError               :: proc "c" () -> u32                                                                                           { return impl_GetError()                                                                             }
+	GetFloatv              :: proc "c" (pname: u32, data: ^f32)                                                                            {        impl_GetFloatv(pname, data)                                                                 }
+	GetIntegerv            :: proc "c" (pname: u32, data: ^i32)                                                                            {        impl_GetIntegerv(pname, data)                                                               }
+	GetString              :: proc "c" (name: u32) -> cstring                                                                              { return impl_GetString(name)                                                                        }
+	GetTexImage            :: proc "c" (target: u32,  level: i32, format, type: u32, pixels: rawptr)                                       {        impl_GetTexImage(target,  level, format, type, pixels)                                      }
+	GetTexParameterfv      :: proc "c" (target, pname: u32, params: [^]f32)                                                                {        impl_GetTexParameterfv(target, pname, params)                                               }
+	GetTexParameteriv      :: proc "c" (target, pname: u32, params: [^]i32)                                                                {        impl_GetTexParameteriv(target, pname, params)                                               }
+	GetTexLevelParameterfv :: proc "c" (target: u32, level: i32, pname: u32, params: [^]f32)                                               {        impl_GetTexLevelParameterfv(target, level, pname, params)                                   }
+	GetTexLevelParameteriv :: proc "c" (target: u32, level: i32, pname: u32, params: [^]i32)                                               {        impl_GetTexLevelParameteriv(target, level, pname, params)                                   }
+	IsEnabled              :: proc "c" (cap: u32) -> bool                                                                                  { return impl_IsEnabled(cap)                                                                         }
+	DepthRange             :: proc "c" (near, far: f64)                                                                                    {        impl_DepthRange(near, far)                                                                  }
+	Viewport               :: proc "c" (x, y, width, height: i32)                                                                          {        impl_Viewport(x, y, width, height)                                                          }
 
 	// VERSION_1_1
-	DrawArrays        :: #force_inline proc "c" (mode: u32, first: i32, count: i32)                                                                                    {        impl_DrawArrays(mode, first, count)                                                      }
-	DrawElements      :: #force_inline proc "c" (mode: u32, count: i32, type: u32, indices: rawptr)                                                                    {        impl_DrawElements(mode, count, type, indices)                                            }
-	PolygonOffset     :: #force_inline proc "c" (factor: f32, units: f32)                                                                                              {        impl_PolygonOffset(factor, units)                                                        }
-	CopyTexImage1D    :: #force_inline proc "c" (target: u32, level: i32, internalformat: u32, x: i32, y: i32, width: i32, border: i32)                                {        impl_CopyTexImage1D(target, level, internalformat, x, y, width, border)                  }
-	CopyTexImage2D    :: #force_inline proc "c" (target: u32, level: i32, internalformat: u32, x: i32, y: i32, width: i32, height: i32, border: i32)                   {        impl_CopyTexImage2D(target, level, internalformat, x, y, width, height, border)          }
-	CopyTexSubImage1D :: #force_inline proc "c" (target: u32, level: i32, xoffset: i32, x: i32, y: i32, width: i32)                                                    {        impl_CopyTexSubImage1D(target, level, xoffset, x, y, width)                              }
-	CopyTexSubImage2D :: #force_inline proc "c" (target: u32, level: i32, xoffset: i32, yoffset: i32, x: i32, y: i32, width: i32, height: i32)                         {        impl_CopyTexSubImage2D(target, level, xoffset, yoffset, x, y, width, height)             }
-	TexSubImage1D     :: #force_inline proc "c" (target: u32, level: i32, xoffset: i32, width: i32, format: u32, type: u32, pixels: rawptr)                            {        impl_TexSubImage1D(target, level, xoffset, width, format, type, pixels)                  }
-	TexSubImage2D     :: #force_inline proc "c" (target: u32, level: i32, xoffset: i32, yoffset: i32, width: i32, height: i32, format: u32, type: u32, pixels: rawptr) {        impl_TexSubImage2D(target, level, xoffset, yoffset, width, height, format, type, pixels) }
-	BindTexture       :: #force_inline proc "c" (target: u32, texture: u32)                                                                                            {        impl_BindTexture(target, texture)                                                        }
-	DeleteTextures    :: #force_inline proc "c" (n: i32, textures: [^]u32)                                                                                             {        impl_DeleteTextures(n, textures)                                                         }
-	GenTextures       :: #force_inline proc "c" (n: i32, textures: [^]u32)                                                                                             {        impl_GenTextures(n, textures)                                                            }
-	IsTexture         :: #force_inline proc "c" (texture: u32) -> bool                                                                                                 { return impl_IsTexture(texture)                                                                  }
+	DrawArrays        :: proc "c" (mode: u32, first: i32, count: i32)                                                                                    {        impl_DrawArrays(mode, first, count)                                                      }
+	DrawElements      :: proc "c" (mode: u32, count: i32, type: u32, indices: rawptr)                                                                    {        impl_DrawElements(mode, count, type, indices)                                            }
+	PolygonOffset     :: proc "c" (factor: f32, units: f32)                                                                                              {        impl_PolygonOffset(factor, units)                                                        }
+	CopyTexImage1D    :: proc "c" (target: u32, level: i32, internalformat: u32, x: i32, y: i32, width: i32, border: i32)                                {        impl_CopyTexImage1D(target, level, internalformat, x, y, width, border)                  }
+	CopyTexImage2D    :: proc "c" (target: u32, level: i32, internalformat: u32, x: i32, y: i32, width: i32, height: i32, border: i32)                   {        impl_CopyTexImage2D(target, level, internalformat, x, y, width, height, border)          }
+	CopyTexSubImage1D :: proc "c" (target: u32, level: i32, xoffset: i32, x: i32, y: i32, width: i32)                                                    {        impl_CopyTexSubImage1D(target, level, xoffset, x, y, width)                              }
+	CopyTexSubImage2D :: proc "c" (target: u32, level: i32, xoffset: i32, yoffset: i32, x: i32, y: i32, width: i32, height: i32)                         {        impl_CopyTexSubImage2D(target, level, xoffset, yoffset, x, y, width, height)             }
+	TexSubImage1D     :: proc "c" (target: u32, level: i32, xoffset: i32, width: i32, format: u32, type: u32, pixels: rawptr)                            {        impl_TexSubImage1D(target, level, xoffset, width, format, type, pixels)                  }
+	TexSubImage2D     :: proc "c" (target: u32, level: i32, xoffset: i32, yoffset: i32, width: i32, height: i32, format: u32, type: u32, pixels: rawptr) {        impl_TexSubImage2D(target, level, xoffset, yoffset, width, height, format, type, pixels) }
+	BindTexture       :: proc "c" (target: u32, texture: u32)                                                                                            {        impl_BindTexture(target, texture)                                                        }
+	DeleteTextures    :: proc "c" (n: i32, textures: [^]u32)                                                                                             {        impl_DeleteTextures(n, textures)                                                         }
+	GenTextures       :: proc "c" (n: i32, textures: [^]u32)                                                                                             {        impl_GenTextures(n, textures)                                                            }
+	IsTexture         :: proc "c" (texture: u32) -> bool                                                                                                 { return impl_IsTexture(texture)                                                                  }
 
 	// VERSION_1_2
-	DrawRangeElements :: #force_inline proc "c" (mode, start, end: u32, count: i32, type: u32, indices: rawptr)                                               { impl_DrawRangeElements(mode, start, end, count, type, indices)                                           }
-	TexImage3D        :: #force_inline proc "c" (target: u32, level, internalformat, width, height, depth, border: i32, format, type: u32, pixels: rawptr)    { impl_TexImage3D(target, level, internalformat, width, height, depth, border, format, type, pixels)       }
-	TexSubImage3D     :: #force_inline proc "c" (target: u32, level, xoffset, yoffset, zoffset, width, height, depth: i32, format, type: u32, pixels: rawptr) { impl_TexSubImage3D(target, level, xoffset, yoffset, zoffset, width, height, depth, format, type, pixels) }
-	CopyTexSubImage3D :: #force_inline proc "c" (target: u32, level, xoffset, yoffset, zoffset, x, y, width, height: i32)                                     { impl_CopyTexSubImage3D(target, level, xoffset, yoffset, zoffset, x, y, width, height)                    }
+	DrawRangeElements :: proc "c" (mode, start, end: u32, count: i32, type: u32, indices: rawptr)                                               { impl_DrawRangeElements(mode, start, end, count, type, indices)                                           }
+	TexImage3D        :: proc "c" (target: u32, level, internalformat, width, height, depth, border: i32, format, type: u32, pixels: rawptr)    { impl_TexImage3D(target, level, internalformat, width, height, depth, border, format, type, pixels)       }
+	TexSubImage3D     :: proc "c" (target: u32, level, xoffset, yoffset, zoffset, width, height, depth: i32, format, type: u32, pixels: rawptr) { impl_TexSubImage3D(target, level, xoffset, yoffset, zoffset, width, height, depth, format, type, pixels) }
+	CopyTexSubImage3D :: proc "c" (target: u32, level, xoffset, yoffset, zoffset, x, y, width, height: i32)                                     { impl_CopyTexSubImage3D(target, level, xoffset, yoffset, zoffset, x, y, width, height)                    }
 
 	// VERSION_1_3
-	ActiveTexture           :: #force_inline proc "c" (texture: u32)                                                                                                                                      { impl_ActiveTexture(texture)                                                                                           }
-	SampleCoverage          :: #force_inline proc "c" (value: f32, invert: bool)                                                                                                                          { impl_SampleCoverage(value, invert)                                                                                    }
-	CompressedTexImage3D    :: #force_inline proc "c" (target: u32, level: i32, internalformat: u32, width: i32, height: i32, depth: i32, border: i32, imageSize: i32, data: rawptr)                      { impl_CompressedTexImage3D(target, level, internalformat, width, height, depth, border, imageSize, data)               }
-	CompressedTexImage2D    :: #force_inline proc "c" (target: u32, level: i32, internalformat: u32, width: i32, height: i32, border: i32, imageSize: i32, data: rawptr)                                  { impl_CompressedTexImage2D(target, level, internalformat, width, height, border, imageSize, data)                      }
-	CompressedTexImage1D    :: #force_inline proc "c" (target: u32, level: i32, internalformat: u32, width: i32, border: i32, imageSize: i32, data: rawptr)                                               { impl_CompressedTexImage1D(target, level, internalformat, width, border, imageSize, data)                              }
-	CompressedTexSubImage3D :: #force_inline proc "c" (target: u32, level: i32, xoffset: i32, yoffset: i32, zoffset: i32, width: i32, height: i32, depth: i32, format: u32, imageSize: i32, data: rawptr) { impl_CompressedTexSubImage3D(target, level, xoffset, yoffset, zoffset, width, height, depth, format, imageSize, data) }
-	CompressedTexSubImage2D :: #force_inline proc "c" (target: u32, level: i32, xoffset: i32, yoffset: i32, width: i32, height: i32, format: u32, imageSize: i32, data: rawptr)                           { impl_CompressedTexSubImage2D(target, level, xoffset, yoffset, width, height, format, imageSize, data)                 }
-	CompressedTexSubImage1D :: #force_inline proc "c" (target: u32, level: i32, xoffset: i32, width: i32, format: u32, imageSize: i32, data: rawptr)                                                      { impl_CompressedTexSubImage1D(target, level, xoffset, width, format, imageSize, data)                                  }
-	GetCompressedTexImage   :: #force_inline proc "c" (target: u32, level: i32, img: rawptr)                                                                                                              { impl_GetCompressedTexImage(target, level, img)                                                                        }
+	ActiveTexture           :: proc "c" (texture: u32)                                                                                                                                      { impl_ActiveTexture(texture)                                                                                           }
+	SampleCoverage          :: proc "c" (value: f32, invert: bool)                                                                                                                          { impl_SampleCoverage(value, invert)                                                                                    }
+	CompressedTexImage3D    :: proc "c" (target: u32, level: i32, internalformat: u32, width: i32, height: i32, depth: i32, border: i32, imageSize: i32, data: rawptr)                      { impl_CompressedTexImage3D(target, level, internalformat, width, height, depth, border, imageSize, data)               }
+	CompressedTexImage2D    :: proc "c" (target: u32, level: i32, internalformat: u32, width: i32, height: i32, border: i32, imageSize: i32, data: rawptr)                                  { impl_CompressedTexImage2D(target, level, internalformat, width, height, border, imageSize, data)                      }
+	CompressedTexImage1D    :: proc "c" (target: u32, level: i32, internalformat: u32, width: i32, border: i32, imageSize: i32, data: rawptr)                                               { impl_CompressedTexImage1D(target, level, internalformat, width, border, imageSize, data)                              }
+	CompressedTexSubImage3D :: proc "c" (target: u32, level: i32, xoffset: i32, yoffset: i32, zoffset: i32, width: i32, height: i32, depth: i32, format: u32, imageSize: i32, data: rawptr) { impl_CompressedTexSubImage3D(target, level, xoffset, yoffset, zoffset, width, height, depth, format, imageSize, data) }
+	CompressedTexSubImage2D :: proc "c" (target: u32, level: i32, xoffset: i32, yoffset: i32, width: i32, height: i32, format: u32, imageSize: i32, data: rawptr)                           { impl_CompressedTexSubImage2D(target, level, xoffset, yoffset, width, height, format, imageSize, data)                 }
+	CompressedTexSubImage1D :: proc "c" (target: u32, level: i32, xoffset: i32, width: i32, format: u32, imageSize: i32, data: rawptr)                                                      { impl_CompressedTexSubImage1D(target, level, xoffset, width, format, imageSize, data)                                  }
+	GetCompressedTexImage   :: proc "c" (target: u32, level: i32, img: rawptr)                                                                                                              { impl_GetCompressedTexImage(target, level, img)                                                                        }
 
 	// VERSION_1_4
-	BlendFuncSeparate :: #force_inline proc "c" (sfactorRGB: u32, dfactorRGB: u32, sfactorAlpha: u32, dfactorAlpha: u32)  { impl_BlendFuncSeparate(sfactorRGB, dfactorRGB, sfactorAlpha, dfactorAlpha) }
-	MultiDrawArrays   :: #force_inline proc "c" (mode: u32, first: [^]i32, count: [^]i32, drawcount: i32)                 { impl_MultiDrawArrays(mode, first, count, drawcount)                    }
-	MultiDrawElements :: #force_inline proc "c" (mode: u32, count: [^]i32, type: u32, indices: [^]rawptr, drawcount: i32) { impl_MultiDrawElements(mode, count, type, indices, drawcount)           }
-	PointParameterf   :: #force_inline proc "c" (pname: u32, param: f32)                                                  { impl_PointParameterf(pname, param)                                         }
-	PointParameterfv  :: #force_inline proc "c" (pname: u32, params: [^]f32)                                              { impl_PointParameterfv(pname, params)                                     }
-	PointParameteri   :: #force_inline proc "c" (pname: u32, param: i32)                                                  { impl_PointParameteri(pname, param)                                         }
-	PointParameteriv  :: #force_inline proc "c" (pname: u32, params: [^]i32)                                              { impl_PointParameteriv(pname, params)                                     }
-	BlendColor        :: #force_inline proc "c" (red: f32, green: f32, blue: f32, alpha: f32)                             { impl_BlendColor(red, green, blue, alpha)                                   }
-	BlendEquation     :: #force_inline proc "c" (mode: u32)                                                               { impl_BlendEquation(mode)                                                   }
+	BlendFuncSeparate :: proc "c" (sfactorRGB: u32, dfactorRGB: u32, sfactorAlpha: u32, dfactorAlpha: u32)  { impl_BlendFuncSeparate(sfactorRGB, dfactorRGB, sfactorAlpha, dfactorAlpha) }
+	MultiDrawArrays   :: proc "c" (mode: u32, first: [^]i32, count: [^]i32, drawcount: i32)                 { impl_MultiDrawArrays(mode, first, count, drawcount)                    }
+	MultiDrawElements :: proc "c" (mode: u32, count: [^]i32, type: u32, indices: [^]rawptr, drawcount: i32) { impl_MultiDrawElements(mode, count, type, indices, drawcount)           }
+	PointParameterf   :: proc "c" (pname: u32, param: f32)                                                  { impl_PointParameterf(pname, param)                                         }
+	PointParameterfv  :: proc "c" (pname: u32, params: [^]f32)                                              { impl_PointParameterfv(pname, params)                                     }
+	PointParameteri   :: proc "c" (pname: u32, param: i32)                                                  { impl_PointParameteri(pname, param)                                         }
+	PointParameteriv  :: proc "c" (pname: u32, params: [^]i32)                                              { impl_PointParameteriv(pname, params)                                     }
+	BlendColor        :: proc "c" (red: f32, green: f32, blue: f32, alpha: f32)                             { impl_BlendColor(red, green, blue, alpha)                                   }
+	BlendEquation     :: proc "c" (mode: u32)                                                               { impl_BlendEquation(mode)                                                   }
 
 	// VERSION_1_5
-	GenQueries           :: #force_inline proc "c" (n: i32, ids: [^]u32)                               {        impl_GenQueries(n, ids)                                       }
-	DeleteQueries        :: #force_inline proc "c" (n: i32, ids: [^]u32)                               {        impl_DeleteQueries(n, ids)                                    }
-	IsQuery              :: #force_inline proc "c" (id: u32) -> bool                                   { ret := impl_IsQuery(id);                                  return ret }
-	BeginQuery           :: #force_inline proc "c" (target: u32, id: u32)                              {        impl_BeginQuery(target, id)                                   }
-	EndQuery             :: #force_inline proc "c" (target: u32)                                       {        impl_EndQuery(target)                                         }
-	GetQueryiv           :: #force_inline proc "c" (target: u32, pname: u32, params: [^]i32)           {        impl_GetQueryiv(target, pname, params)                        }
-	GetQueryObjectiv     :: #force_inline proc "c" (id: u32, pname: u32, params: [^]i32)               {        impl_GetQueryObjectiv(id, pname, params)                      }
-	GetQueryObjectuiv    :: #force_inline proc "c" (id: u32, pname: u32, params: [^]u32)               {        impl_GetQueryObjectuiv(id, pname, params)                     }
-	BindBuffer           :: #force_inline proc "c" (target: u32, buffer: u32)                          {        impl_BindBuffer(target, buffer)                               }
-	DeleteBuffers        :: #force_inline proc "c" (n: i32, buffers: [^]u32)                           {        impl_DeleteBuffers(n, buffers)                                }
-	GenBuffers           :: #force_inline proc "c" (n: i32, buffers: [^]u32)                           {        impl_GenBuffers(n, buffers)                                   }
-	IsBuffer             :: #force_inline proc "c" (buffer: u32) -> bool                               { ret := impl_IsBuffer(buffer);                             return ret }
-	BufferData           :: #force_inline proc "c" (target: u32, size: int, data: rawptr, usage: u32)  {        impl_BufferData(target, size, data, usage)                    }
-	BufferSubData        :: #force_inline proc "c" (target: u32, offset: int, size: int, data: rawptr) {        impl_BufferSubData(target, offset, size, data)                }
-	GetBufferSubData     :: #force_inline proc "c" (target: u32, offset: int, size: int, data: rawptr) {        impl_GetBufferSubData(target, offset, size, data)             }
-	MapBuffer            :: #force_inline proc "c" (target: u32, access: u32) -> rawptr                { ret := impl_MapBuffer(target, access);                    return ret }
-	UnmapBuffer          :: #force_inline proc "c" (target: u32) -> bool                               { ret := impl_UnmapBuffer(target);                          return ret }
-	GetBufferParameteriv :: #force_inline proc "c" (target: u32, pname: u32, params: [^]i32)           {        impl_GetBufferParameteriv(target, pname, params)              }
-	GetBufferPointerv    :: #force_inline proc "c" (target: u32, pname: u32, params: [^]rawptr)        {        impl_GetBufferPointerv(target, pname, params)                 }
+	GenQueries           :: proc "c" (n: i32, ids: [^]u32)                               {        impl_GenQueries(n, ids)                                       }
+	DeleteQueries        :: proc "c" (n: i32, ids: [^]u32)                               {        impl_DeleteQueries(n, ids)                                    }
+	IsQuery              :: proc "c" (id: u32) -> bool                                   { ret := impl_IsQuery(id);                                  return ret }
+	BeginQuery           :: proc "c" (target: u32, id: u32)                              {        impl_BeginQuery(target, id)                                   }
+	EndQuery             :: proc "c" (target: u32)                                       {        impl_EndQuery(target)                                         }
+	GetQueryiv           :: proc "c" (target: u32, pname: u32, params: [^]i32)           {        impl_GetQueryiv(target, pname, params)                        }
+	GetQueryObjectiv     :: proc "c" (id: u32, pname: u32, params: [^]i32)               {        impl_GetQueryObjectiv(id, pname, params)                      }
+	GetQueryObjectuiv    :: proc "c" (id: u32, pname: u32, params: [^]u32)               {        impl_GetQueryObjectuiv(id, pname, params)                     }
+	BindBuffer           :: proc "c" (target: u32, buffer: u32)                          {        impl_BindBuffer(target, buffer)                               }
+	DeleteBuffers        :: proc "c" (n: i32, buffers: [^]u32)                           {        impl_DeleteBuffers(n, buffers)                                }
+	GenBuffers           :: proc "c" (n: i32, buffers: [^]u32)                           {        impl_GenBuffers(n, buffers)                                   }
+	IsBuffer             :: proc "c" (buffer: u32) -> bool                               { ret := impl_IsBuffer(buffer);                             return ret }
+	BufferData           :: proc "c" (target: u32, size: int, data: rawptr, usage: u32)  {        impl_BufferData(target, size, data, usage)                    }
+	BufferSubData        :: proc "c" (target: u32, offset: int, size: int, data: rawptr) {        impl_BufferSubData(target, offset, size, data)                }
+	GetBufferSubData     :: proc "c" (target: u32, offset: int, size: int, data: rawptr) {        impl_GetBufferSubData(target, offset, size, data)             }
+	MapBuffer            :: proc "c" (target: u32, access: u32) -> rawptr                { ret := impl_MapBuffer(target, access);                    return ret }
+	UnmapBuffer          :: proc "c" (target: u32) -> bool                               { ret := impl_UnmapBuffer(target);                          return ret }
+	GetBufferParameteriv :: proc "c" (target: u32, pname: u32, params: [^]i32)           {        impl_GetBufferParameteriv(target, pname, params)              }
+	GetBufferPointerv    :: proc "c" (target: u32, pname: u32, params: [^]rawptr)        {        impl_GetBufferPointerv(target, pname, params)                 }
 
 	// VERSION_2_0
-	BlendEquationSeparate    :: #force_inline proc "c" (modeRGB: u32, modeAlpha: u32)                                                               {        impl_BlendEquationSeparate(modeRGB, modeAlpha)                                        }
-	DrawBuffers              :: #force_inline proc "c" (n: i32, bufs: [^]u32)                                                                       {        impl_DrawBuffers(n, bufs)                                                             }
-	StencilOpSeparate        :: #force_inline proc "c" (face: u32, sfail: u32, dpfail: u32, dppass: u32)                                            {        impl_StencilOpSeparate(face, sfail, dpfail, dppass)                                   }
-	StencilFuncSeparate      :: #force_inline proc "c" (face: u32, func: u32, ref: i32, mask: u32)                                                  {        impl_StencilFuncSeparate(face, func, ref, mask)                                       }
-	StencilMaskSeparate      :: #force_inline proc "c" (face: u32, mask: u32)                                                                       {        impl_StencilMaskSeparate(face, mask)                                                  }
-	AttachShader             :: #force_inline proc "c" (program: u32, shader: u32)                                                                  {        impl_AttachShader(program, shader)                                                    }
-	BindAttribLocation       :: #force_inline proc "c" (program: u32, index: u32, name: cstring)                                                    {        impl_BindAttribLocation(program, index, name)                                         }
-	CompileShader            :: #force_inline proc "c" (shader: u32)                                                                                {        impl_CompileShader(shader)                                                            }
-	CreateProgram            :: #force_inline proc "c" () -> u32                                                                                    { ret := impl_CreateProgram();                                                      return ret }
-	CreateShader             :: #force_inline proc "c" (type: u32) -> u32                                                                           { ret := impl_CreateShader(type);                                                  return ret }
-	DeleteProgram            :: #force_inline proc "c" (program: u32)                                                                               {        impl_DeleteProgram(program)                                                           }
-	DeleteShader             :: #force_inline proc "c" (shader: u32)                                                                                {        impl_DeleteShader(shader)                                                             }
-	DetachShader             :: #force_inline proc "c" (program: u32, shader: u32)                                                                  {        impl_DetachShader(program, shader)                                                    }
-	DisableVertexAttribArray :: #force_inline proc "c" (index: u32)                                                                                 {        impl_DisableVertexAttribArray(index)                                                  }
-	EnableVertexAttribArray  :: #force_inline proc "c" (index: u32)                                                                                 {        impl_EnableVertexAttribArray(index)                                                   }
-	GetActiveAttrib          :: #force_inline proc "c" (program: u32, index: u32, bufSize: i32, length: ^i32, size: ^i32, type: ^u32, name: [^]u8)  {        impl_GetActiveAttrib(program, index, bufSize, length, size, type, name)              }
-	GetActiveUniform         :: #force_inline proc "c" (program: u32, index: u32, bufSize: i32, length: ^i32, size: ^i32, type: ^u32, name: [^]u8)  {        impl_GetActiveUniform(program, index, bufSize, length, size, type, name)             }
-	GetAttachedShaders       :: #force_inline proc "c" (program: u32, maxCount: i32, count: [^]i32, shaders: [^]u32)                                {        impl_GetAttachedShaders(program, maxCount, count, shaders)                            }
-	GetAttribLocation        :: #force_inline proc "c" (program: u32, name: cstring) -> i32                                                         { ret := impl_GetAttribLocation(program, name);                                     return ret }
-	GetProgramiv             :: #force_inline proc "c" (program: u32, pname: u32, params: [^]i32)                                                   {        impl_GetProgramiv(program, pname, params)                                             }
-	GetProgramInfoLog        :: #force_inline proc "c" (program: u32, bufSize: i32, length: ^i32, infoLog: [^]u8)                                   {        impl_GetProgramInfoLog(program, bufSize, length, infoLog)                             }
-	GetShaderiv              :: #force_inline proc "c" (shader: u32, pname: u32, params: [^]i32)                                                    {        impl_GetShaderiv(shader, pname, params)                                               }
-	GetShaderInfoLog         :: #force_inline proc "c" (shader: u32, bufSize: i32, length: ^i32, infoLog: [^]u8)                                    {        impl_GetShaderInfoLog(shader, bufSize, length, infoLog)                               }
-	GetShaderSource          :: #force_inline proc "c" (shader: u32, bufSize: i32, length: ^i32, source: [^]u8)                                     {        impl_GetShaderSource(shader, bufSize, length, source)                                 }
-	GetUniformLocation       :: #force_inline proc "c" (program: u32, name: cstring) -> i32                                                         { ret := impl_GetUniformLocation(program, name);                                    return ret }
-	GetUniformfv             :: #force_inline proc "c" (program: u32, location: i32, params: [^]f32)                                                {        impl_GetUniformfv(program, location, params)                                          }
-	GetUniformiv             :: #force_inline proc "c" (program: u32, location: i32, params: [^]i32)                                                {        impl_GetUniformiv(program, location, params)                                          }
-	GetVertexAttribdv        :: #force_inline proc "c" (index: u32, pname: u32, params: [^]f64)                                                     {        impl_GetVertexAttribdv(index, pname, params)                                          }
-	GetVertexAttribfv        :: #force_inline proc "c" (index: u32, pname: u32, params: [^]f32)                                                     {        impl_GetVertexAttribfv(index, pname, params)                                          }
-	GetVertexAttribiv        :: #force_inline proc "c" (index: u32, pname: u32, params: [^]i32)                                                     {        impl_GetVertexAttribiv(index, pname, params)                                          }
-	GetVertexAttribPointerv  :: #force_inline proc "c" (index: u32, pname: u32, pointer: ^uintptr)                                                   {        impl_GetVertexAttribPointerv(index, pname, pointer)                                   }
-	IsProgram                :: #force_inline proc "c" (program: u32) -> bool                                                                       { ret := impl_IsProgram(program);                                                   return ret }
-	IsShader                 :: #force_inline proc "c" (shader: u32) -> bool                                                                        { ret := impl_IsShader(shader);                                                     return ret }
-	LinkProgram              :: #force_inline proc "c" (program: u32)                                                                               {        impl_LinkProgram(program)                                                             }
-	ShaderSource             :: #force_inline proc "c" (shader: u32, count: i32, string: [^]cstring, length: [^]i32)                                {        impl_ShaderSource(shader, count, string, length)                                      }
-	UseProgram               :: #force_inline proc "c" (program: u32)                                                                               {        impl_UseProgram(program)                                                              }
-	Uniform1f                :: #force_inline proc "c" (location: i32, v0: f32)                                                                     {        impl_Uniform1f(location, v0)                                                          }
-	Uniform2f                :: #force_inline proc "c" (location: i32, v0: f32, v1: f32)                                                            {        impl_Uniform2f(location, v0, v1)                                                      }
-	Uniform3f                :: #force_inline proc "c" (location: i32, v0: f32, v1: f32, v2: f32)                                                   {        impl_Uniform3f(location, v0, v1, v2)                                                  }
-	Uniform4f                :: #force_inline proc "c" (location: i32, v0: f32, v1: f32, v2: f32, v3: f32)                                          {        impl_Uniform4f(location, v0, v1, v2, v3)                                              }
-	Uniform1i                :: #force_inline proc "c" (location: i32, v0: i32)                                                                     {        impl_Uniform1i(location, v0)                                                          }
-	Uniform2i                :: #force_inline proc "c" (location: i32, v0: i32, v1: i32)                                                            {        impl_Uniform2i(location, v0, v1)                                                      }
-	Uniform3i                :: #force_inline proc "c" (location: i32, v0: i32, v1: i32, v2: i32)                                                   {        impl_Uniform3i(location, v0, v1, v2)                                                  }
-	Uniform4i                :: #force_inline proc "c" (location: i32, v0: i32, v1: i32, v2: i32, v3: i32)                                          {        impl_Uniform4i(location, v0, v1, v2, v3)                                              }
-	Uniform1fv               :: #force_inline proc "c" (location: i32, count: i32, value: [^]f32)                                                {        impl_Uniform1fv(location, count, value)                                               }
-	Uniform2fv               :: #force_inline proc "c" (location: i32, count: i32, value: [^]f32)                                                {        impl_Uniform2fv(location, count, value)                                               }
-	Uniform3fv               :: #force_inline proc "c" (location: i32, count: i32, value: [^]f32)                                                {        impl_Uniform3fv(location, count, value)                                               }
-	Uniform4fv               :: #force_inline proc "c" (location: i32, count: i32, value: [^]f32)                                                {        impl_Uniform4fv(location, count, value)                                               }
-	Uniform1iv               :: #force_inline proc "c" (location: i32, count: i32, value: [^]i32)                                                {        impl_Uniform1iv(location, count, value)                                               }
-	Uniform2iv               :: #force_inline proc "c" (location: i32, count: i32, value: [^]i32)                                                {        impl_Uniform2iv(location, count, value)                                               }
-	Uniform3iv               :: #force_inline proc "c" (location: i32, count: i32, value: [^]i32)                                                {        impl_Uniform3iv(location, count, value)                                               }
-	Uniform4iv               :: #force_inline proc "c" (location: i32, count: i32, value: [^]i32)                                                {        impl_Uniform4iv(location, count, value)                                               }
-	UniformMatrix2fv         :: #force_inline proc "c" (location: i32, count: i32, transpose: bool, value: [^]f32)                               {        impl_UniformMatrix2fv(location, count, transpose, value)                              }
-	UniformMatrix3fv         :: #force_inline proc "c" (location: i32, count: i32, transpose: bool, value: [^]f32)                               {        impl_UniformMatrix3fv(location, count, transpose, value)                              }
-	UniformMatrix4fv         :: #force_inline proc "c" (location: i32, count: i32, transpose: bool, value: [^]f32)                               {        impl_UniformMatrix4fv(location, count, transpose, value)                              }
-	ValidateProgram          :: #force_inline proc "c" (program: u32)                                                                               {        impl_ValidateProgram(program)                                                         }
-	VertexAttrib1d           :: #force_inline proc "c" (index: u32, x: f64)                                                                         {        impl_VertexAttrib1d(index, x)                                                         }
-	VertexAttrib1dv          :: #force_inline proc "c" (index: u32, v: ^f64)                                                                        {        impl_VertexAttrib1dv(index, v)                                                        }
-	VertexAttrib1f           :: #force_inline proc "c" (index: u32, x: f32)                                                                         {        impl_VertexAttrib1f(index, x)                                                         }
-	VertexAttrib1fv          :: #force_inline proc "c" (index: u32, v: ^f32)                                                                        {        impl_VertexAttrib1fv(index, v)                                                        }
-	VertexAttrib1s           :: #force_inline proc "c" (index: u32, x: i16)                                                                         {        impl_VertexAttrib1s(index, x)                                                         }
-	VertexAttrib1sv          :: #force_inline proc "c" (index: u32, v: ^i16)                                                                      {        impl_VertexAttrib1sv(index, v)                                                        }
-	VertexAttrib2d           :: #force_inline proc "c" (index: u32, x: f64, y: f64)                                                                 {        impl_VertexAttrib2d(index, x, y)                                                      }
-	VertexAttrib2dv          :: #force_inline proc "c" (index: u32, v: ^[2]f64)                                                                      {        impl_VertexAttrib2dv(index, v)                                                        }
-	VertexAttrib2f           :: #force_inline proc "c" (index: u32, x: f32, y: f32)                                                                 {        impl_VertexAttrib2f(index, x, y)                                                      }
-	VertexAttrib2fv          :: #force_inline proc "c" (index: u32, v: ^[2]f32)                                                                      {        impl_VertexAttrib2fv(index, v)                                                        }
-	VertexAttrib2s           :: #force_inline proc "c" (index: u32, x: i16, y: i16)                                                                 {        impl_VertexAttrib2s(index, x, y)                                                      }
-	VertexAttrib2sv          :: #force_inline proc "c" (index: u32, v: ^[2]i16)                                                                      {        impl_VertexAttrib2sv(index, v)                                                        }
-	VertexAttrib3d           :: #force_inline proc "c" (index: u32, x: f64, y: f64, z: f64)                                                         {        impl_VertexAttrib3d(index, x, y, z)                                                   }
-	VertexAttrib3dv          :: #force_inline proc "c" (index: u32, v: ^[3]f64)                                                                      {        impl_VertexAttrib3dv(index, v)                                                        }
-	VertexAttrib3f           :: #force_inline proc "c" (index: u32, x: f32, y: f32, z: f32)                                                         {        impl_VertexAttrib3f(index, x, y, z)                                                   }
-	VertexAttrib3fv          :: #force_inline proc "c" (index: u32, v: ^[3]f32)                                                                      {        impl_VertexAttrib3fv(index, v)                                                        }
-	VertexAttrib3s           :: #force_inline proc "c" (index: u32, x: i16, y: i16, z: i16)                                                         {        impl_VertexAttrib3s(index, x, y, z)                                                   }
-	VertexAttrib3sv          :: #force_inline proc "c" (index: u32, v: ^[3]i16)                                                                      {        impl_VertexAttrib3sv(index, v)                                                        }
-	VertexAttrib4Nbv         :: #force_inline proc "c" (index: u32, v: ^[4]i8)                                                                       {        impl_VertexAttrib4Nbv(index, v)                                                       }
-	VertexAttrib4Niv         :: #force_inline proc "c" (index: u32, v: ^[4]i32)                                                                      {        impl_VertexAttrib4Niv(index, v)                                                       }
-	VertexAttrib4Nsv         :: #force_inline proc "c" (index: u32, v: ^[4]i16)                                                                      {        impl_VertexAttrib4Nsv(index, v)                                                       }
-	VertexAttrib4Nub         :: #force_inline proc "c" (index: u32, x: u8, y: u8, z: u8, w: u8)                                                     {        impl_VertexAttrib4Nub(index, x, y, z, w)                                              }
-	VertexAttrib4Nubv        :: #force_inline proc "c" (index: u32, v: ^[4]u8)                                                                       {        impl_VertexAttrib4Nubv(index, v)                                                      }
-	VertexAttrib4Nuiv        :: #force_inline proc "c" (index: u32, v: ^[4]u32)                                                                      {        impl_VertexAttrib4Nuiv(index, v)                                                      }
-	VertexAttrib4Nusv        :: #force_inline proc "c" (index: u32, v: ^[4]u16)                                                                      {        impl_VertexAttrib4Nusv(index, v)                                                      }
-	VertexAttrib4bv          :: #force_inline proc "c" (index: u32, v: ^[4]i8)                                                                       {        impl_VertexAttrib4bv(index, v)                                                        }
-	VertexAttrib4d           :: #force_inline proc "c" (index: u32, x: f64, y: f64, z: f64, w: f64)                                                 {        impl_VertexAttrib4d(index, x, y, z, w)                                                }
-	VertexAttrib4dv          :: #force_inline proc "c" (index: u32, v: ^[4]f64)                                                                      {        impl_VertexAttrib4dv(index, v)                                                        }
-	VertexAttrib4f           :: #force_inline proc "c" (index: u32, x: f32, y: f32, z: f32, w: f32)                                                 {        impl_VertexAttrib4f(index, x, y, z, w)                                                }
-	VertexAttrib4fv          :: #force_inline proc "c" (index: u32, v: ^[4]f32)                                                                      {        impl_VertexAttrib4fv(index, v)                                                        }
-	VertexAttrib4iv          :: #force_inline proc "c" (index: u32, v: ^[4]i32)                                                                      {        impl_VertexAttrib4iv(index, v)                                                        }
-	VertexAttrib4s           :: #force_inline proc "c" (index: u32, x: i16, y: i16, z: i16, w: i16)                                                 {        impl_VertexAttrib4s(index, x, y, z, w)                                                }
-	VertexAttrib4sv          :: #force_inline proc "c" (index: u32, v: ^[4]i16)                                                                      {        impl_VertexAttrib4sv(index, v)                                                        }
-	VertexAttrib4ubv         :: #force_inline proc "c" (index: u32, v: ^[4]u8)                                                                       {        impl_VertexAttrib4ubv(index, v)                                                       }
-	VertexAttrib4uiv         :: #force_inline proc "c" (index: u32, v: ^[4]u32)                                                                      {        impl_VertexAttrib4uiv(index, v)                                                       }
-	VertexAttrib4usv         :: #force_inline proc "c" (index: u32, v: ^[4]u16)                                                                      {        impl_VertexAttrib4usv(index, v)                                                       }
-	VertexAttribPointer      :: #force_inline proc "c" (index: u32, size: i32, type: u32, normalized: bool, stride: i32, pointer: uintptr)           {        impl_VertexAttribPointer(index, size, type, normalized, stride, pointer)             }
+	BlendEquationSeparate    :: proc "c" (modeRGB: u32, modeAlpha: u32)                                                               {        impl_BlendEquationSeparate(modeRGB, modeAlpha)                                        }
+	DrawBuffers              :: proc "c" (n: i32, bufs: [^]u32)                                                                       {        impl_DrawBuffers(n, bufs)                                                             }
+	StencilOpSeparate        :: proc "c" (face: u32, sfail: u32, dpfail: u32, dppass: u32)                                            {        impl_StencilOpSeparate(face, sfail, dpfail, dppass)                                   }
+	StencilFuncSeparate      :: proc "c" (face: u32, func: u32, ref: i32, mask: u32)                                                  {        impl_StencilFuncSeparate(face, func, ref, mask)                                       }
+	StencilMaskSeparate      :: proc "c" (face: u32, mask: u32)                                                                       {        impl_StencilMaskSeparate(face, mask)                                                  }
+	AttachShader             :: proc "c" (program: u32, shader: u32)                                                                  {        impl_AttachShader(program, shader)                                                    }
+	BindAttribLocation       :: proc "c" (program: u32, index: u32, name: cstring)                                                    {        impl_BindAttribLocation(program, index, name)                                         }
+	CompileShader            :: proc "c" (shader: u32)                                                                                {        impl_CompileShader(shader)                                                            }
+	CreateProgram            :: proc "c" () -> u32                                                                                    { ret := impl_CreateProgram();                                                      return ret }
+	CreateShader             :: proc "c" (type: u32) -> u32                                                                           { ret := impl_CreateShader(type);                                                  return ret }
+	DeleteProgram            :: proc "c" (program: u32)                                                                               {        impl_DeleteProgram(program)                                                           }
+	DeleteShader             :: proc "c" (shader: u32)                                                                                {        impl_DeleteShader(shader)                                                             }
+	DetachShader             :: proc "c" (program: u32, shader: u32)                                                                  {        impl_DetachShader(program, shader)                                                    }
+	DisableVertexAttribArray :: proc "c" (index: u32)                                                                                 {        impl_DisableVertexAttribArray(index)                                                  }
+	EnableVertexAttribArray  :: proc "c" (index: u32)                                                                                 {        impl_EnableVertexAttribArray(index)                                                   }
+	GetActiveAttrib          :: proc "c" (program: u32, index: u32, bufSize: i32, length: ^i32, size: ^i32, type: ^u32, name: [^]u8)  {        impl_GetActiveAttrib(program, index, bufSize, length, size, type, name)              }
+	GetActiveUniform         :: proc "c" (program: u32, index: u32, bufSize: i32, length: ^i32, size: ^i32, type: ^u32, name: [^]u8)  {        impl_GetActiveUniform(program, index, bufSize, length, size, type, name)             }
+	GetAttachedShaders       :: proc "c" (program: u32, maxCount: i32, count: [^]i32, shaders: [^]u32)                                {        impl_GetAttachedShaders(program, maxCount, count, shaders)                            }
+	GetAttribLocation        :: proc "c" (program: u32, name: cstring) -> i32                                                         { ret := impl_GetAttribLocation(program, name);                                     return ret }
+	GetProgramiv             :: proc "c" (program: u32, pname: u32, params: [^]i32)                                                   {        impl_GetProgramiv(program, pname, params)                                             }
+	GetProgramInfoLog        :: proc "c" (program: u32, bufSize: i32, length: ^i32, infoLog: [^]u8)                                   {        impl_GetProgramInfoLog(program, bufSize, length, infoLog)                             }
+	GetShaderiv              :: proc "c" (shader: u32, pname: u32, params: [^]i32)                                                    {        impl_GetShaderiv(shader, pname, params)                                               }
+	GetShaderInfoLog         :: proc "c" (shader: u32, bufSize: i32, length: ^i32, infoLog: [^]u8)                                    {        impl_GetShaderInfoLog(shader, bufSize, length, infoLog)                               }
+	GetShaderSource          :: proc "c" (shader: u32, bufSize: i32, length: ^i32, source: [^]u8)                                     {        impl_GetShaderSource(shader, bufSize, length, source)                                 }
+	GetUniformLocation       :: proc "c" (program: u32, name: cstring) -> i32                                                         { ret := impl_GetUniformLocation(program, name);                                    return ret }
+	GetUniformfv             :: proc "c" (program: u32, location: i32, params: [^]f32)                                                {        impl_GetUniformfv(program, location, params)                                          }
+	GetUniformiv             :: proc "c" (program: u32, location: i32, params: [^]i32)                                                {        impl_GetUniformiv(program, location, params)                                          }
+	GetVertexAttribdv        :: proc "c" (index: u32, pname: u32, params: [^]f64)                                                     {        impl_GetVertexAttribdv(index, pname, params)                                          }
+	GetVertexAttribfv        :: proc "c" (index: u32, pname: u32, params: [^]f32)                                                     {        impl_GetVertexAttribfv(index, pname, params)                                          }
+	GetVertexAttribiv        :: proc "c" (index: u32, pname: u32, params: [^]i32)                                                     {        impl_GetVertexAttribiv(index, pname, params)                                          }
+	GetVertexAttribPointerv  :: proc "c" (index: u32, pname: u32, pointer: ^uintptr)                                                   {        impl_GetVertexAttribPointerv(index, pname, pointer)                                   }
+	IsProgram                :: proc "c" (program: u32) -> bool                                                                       { ret := impl_IsProgram(program);                                                   return ret }
+	IsShader                 :: proc "c" (shader: u32) -> bool                                                                        { ret := impl_IsShader(shader);                                                     return ret }
+	LinkProgram              :: proc "c" (program: u32)                                                                               {        impl_LinkProgram(program)                                                             }
+	ShaderSource             :: proc "c" (shader: u32, count: i32, string: [^]cstring, length: [^]i32)                                {        impl_ShaderSource(shader, count, string, length)                                      }
+	UseProgram               :: proc "c" (program: u32)                                                                               {        impl_UseProgram(program)                                                              }
+	Uniform1f                :: proc "c" (location: i32, v0: f32)                                                                     {        impl_Uniform1f(location, v0)                                                          }
+	Uniform2f                :: proc "c" (location: i32, v0: f32, v1: f32)                                                            {        impl_Uniform2f(location, v0, v1)                                                      }
+	Uniform3f                :: proc "c" (location: i32, v0: f32, v1: f32, v2: f32)                                                   {        impl_Uniform3f(location, v0, v1, v2)                                                  }
+	Uniform4f                :: proc "c" (location: i32, v0: f32, v1: f32, v2: f32, v3: f32)                                          {        impl_Uniform4f(location, v0, v1, v2, v3)                                              }
+	Uniform1i                :: proc "c" (location: i32, v0: i32)                                                                     {        impl_Uniform1i(location, v0)                                                          }
+	Uniform2i                :: proc "c" (location: i32, v0: i32, v1: i32)                                                            {        impl_Uniform2i(location, v0, v1)                                                      }
+	Uniform3i                :: proc "c" (location: i32, v0: i32, v1: i32, v2: i32)                                                   {        impl_Uniform3i(location, v0, v1, v2)                                                  }
+	Uniform4i                :: proc "c" (location: i32, v0: i32, v1: i32, v2: i32, v3: i32)                                          {        impl_Uniform4i(location, v0, v1, v2, v3)                                              }
+	Uniform1fv               :: proc "c" (location: i32, count: i32, value: [^]f32)                                                {        impl_Uniform1fv(location, count, value)                                               }
+	Uniform2fv               :: proc "c" (location: i32, count: i32, value: [^]f32)                                                {        impl_Uniform2fv(location, count, value)                                               }
+	Uniform3fv               :: proc "c" (location: i32, count: i32, value: [^]f32)                                                {        impl_Uniform3fv(location, count, value)                                               }
+	Uniform4fv               :: proc "c" (location: i32, count: i32, value: [^]f32)                                                {        impl_Uniform4fv(location, count, value)                                               }
+	Uniform1iv               :: proc "c" (location: i32, count: i32, value: [^]i32)                                                {        impl_Uniform1iv(location, count, value)                                               }
+	Uniform2iv               :: proc "c" (location: i32, count: i32, value: [^]i32)                                                {        impl_Uniform2iv(location, count, value)                                               }
+	Uniform3iv               :: proc "c" (location: i32, count: i32, value: [^]i32)                                                {        impl_Uniform3iv(location, count, value)                                               }
+	Uniform4iv               :: proc "c" (location: i32, count: i32, value: [^]i32)                                                {        impl_Uniform4iv(location, count, value)                                               }
+	UniformMatrix2fv         :: proc "c" (location: i32, count: i32, transpose: bool, value: [^]f32)                               {        impl_UniformMatrix2fv(location, count, transpose, value)                              }
+	UniformMatrix3fv         :: proc "c" (location: i32, count: i32, transpose: bool, value: [^]f32)                               {        impl_UniformMatrix3fv(location, count, transpose, value)                              }
+	UniformMatrix4fv         :: proc "c" (location: i32, count: i32, transpose: bool, value: [^]f32)                               {        impl_UniformMatrix4fv(location, count, transpose, value)                              }
+	ValidateProgram          :: proc "c" (program: u32)                                                                               {        impl_ValidateProgram(program)                                                         }
+	VertexAttrib1d           :: proc "c" (index: u32, x: f64)                                                                         {        impl_VertexAttrib1d(index, x)                                                         }
+	VertexAttrib1dv          :: proc "c" (index: u32, v: ^f64)                                                                        {        impl_VertexAttrib1dv(index, v)                                                        }
+	VertexAttrib1f           :: proc "c" (index: u32, x: f32)                                                                         {        impl_VertexAttrib1f(index, x)                                                         }
+	VertexAttrib1fv          :: proc "c" (index: u32, v: ^f32)                                                                        {        impl_VertexAttrib1fv(index, v)                                                        }
+	VertexAttrib1s           :: proc "c" (index: u32, x: i16)                                                                         {        impl_VertexAttrib1s(index, x)                                                         }
+	VertexAttrib1sv          :: proc "c" (index: u32, v: ^i16)                                                                      {        impl_VertexAttrib1sv(index, v)                                                        }
+	VertexAttrib2d           :: proc "c" (index: u32, x: f64, y: f64)                                                                 {        impl_VertexAttrib2d(index, x, y)                                                      }
+	VertexAttrib2dv          :: proc "c" (index: u32, v: ^[2]f64)                                                                      {        impl_VertexAttrib2dv(index, v)                                                        }
+	VertexAttrib2f           :: proc "c" (index: u32, x: f32, y: f32)                                                                 {        impl_VertexAttrib2f(index, x, y)                                                      }
+	VertexAttrib2fv          :: proc "c" (index: u32, v: ^[2]f32)                                                                      {        impl_VertexAttrib2fv(index, v)                                                        }
+	VertexAttrib2s           :: proc "c" (index: u32, x: i16, y: i16)                                                                 {        impl_VertexAttrib2s(index, x, y)                                                      }
+	VertexAttrib2sv          :: proc "c" (index: u32, v: ^[2]i16)                                                                      {        impl_VertexAttrib2sv(index, v)                                                        }
+	VertexAttrib3d           :: proc "c" (index: u32, x: f64, y: f64, z: f64)                                                         {        impl_VertexAttrib3d(index, x, y, z)                                                   }
+	VertexAttrib3dv          :: proc "c" (index: u32, v: ^[3]f64)                                                                      {        impl_VertexAttrib3dv(index, v)                                                        }
+	VertexAttrib3f           :: proc "c" (index: u32, x: f32, y: f32, z: f32)                                                         {        impl_VertexAttrib3f(index, x, y, z)                                                   }
+	VertexAttrib3fv          :: proc "c" (index: u32, v: ^[3]f32)                                                                      {        impl_VertexAttrib3fv(index, v)                                                        }
+	VertexAttrib3s           :: proc "c" (index: u32, x: i16, y: i16, z: i16)                                                         {        impl_VertexAttrib3s(index, x, y, z)                                                   }
+	VertexAttrib3sv          :: proc "c" (index: u32, v: ^[3]i16)                                                                      {        impl_VertexAttrib3sv(index, v)                                                        }
+	VertexAttrib4Nbv         :: proc "c" (index: u32, v: ^[4]i8)                                                                       {        impl_VertexAttrib4Nbv(index, v)                                                       }
+	VertexAttrib4Niv         :: proc "c" (index: u32, v: ^[4]i32)                                                                      {        impl_VertexAttrib4Niv(index, v)                                                       }
+	VertexAttrib4Nsv         :: proc "c" (index: u32, v: ^[4]i16)                                                                      {        impl_VertexAttrib4Nsv(index, v)                                                       }
+	VertexAttrib4Nub         :: proc "c" (index: u32, x: u8, y: u8, z: u8, w: u8)                                                     {        impl_VertexAttrib4Nub(index, x, y, z, w)                                              }
+	VertexAttrib4Nubv        :: proc "c" (index: u32, v: ^[4]u8)                                                                       {        impl_VertexAttrib4Nubv(index, v)                                                      }
+	VertexAttrib4Nuiv        :: proc "c" (index: u32, v: ^[4]u32)                                                                      {        impl_VertexAttrib4Nuiv(index, v)                                                      }
+	VertexAttrib4Nusv        :: proc "c" (index: u32, v: ^[4]u16)                                                                      {        impl_VertexAttrib4Nusv(index, v)                                                      }
+	VertexAttrib4bv          :: proc "c" (index: u32, v: ^[4]i8)                                                                       {        impl_VertexAttrib4bv(index, v)                                                        }
+	VertexAttrib4d           :: proc "c" (index: u32, x: f64, y: f64, z: f64, w: f64)                                                 {        impl_VertexAttrib4d(index, x, y, z, w)                                                }
+	VertexAttrib4dv          :: proc "c" (index: u32, v: ^[4]f64)                                                                      {        impl_VertexAttrib4dv(index, v)                                                        }
+	VertexAttrib4f           :: proc "c" (index: u32, x: f32, y: f32, z: f32, w: f32)                                                 {        impl_VertexAttrib4f(index, x, y, z, w)                                                }
+	VertexAttrib4fv          :: proc "c" (index: u32, v: ^[4]f32)                                                                      {        impl_VertexAttrib4fv(index, v)                                                        }
+	VertexAttrib4iv          :: proc "c" (index: u32, v: ^[4]i32)                                                                      {        impl_VertexAttrib4iv(index, v)                                                        }
+	VertexAttrib4s           :: proc "c" (index: u32, x: i16, y: i16, z: i16, w: i16)                                                 {        impl_VertexAttrib4s(index, x, y, z, w)                                                }
+	VertexAttrib4sv          :: proc "c" (index: u32, v: ^[4]i16)                                                                      {        impl_VertexAttrib4sv(index, v)                                                        }
+	VertexAttrib4ubv         :: proc "c" (index: u32, v: ^[4]u8)                                                                       {        impl_VertexAttrib4ubv(index, v)                                                       }
+	VertexAttrib4uiv         :: proc "c" (index: u32, v: ^[4]u32)                                                                      {        impl_VertexAttrib4uiv(index, v)                                                       }
+	VertexAttrib4usv         :: proc "c" (index: u32, v: ^[4]u16)                                                                      {        impl_VertexAttrib4usv(index, v)                                                       }
+	VertexAttribPointer      :: proc "c" (index: u32, size: i32, type: u32, normalized: bool, stride: i32, pointer: uintptr)           {        impl_VertexAttribPointer(index, size, type, normalized, stride, pointer)             }
 
 	// VERSION_2_1
-	UniformMatrix2x3fv :: #force_inline proc "c" (location: i32, count: i32, transpose: bool, value: [^]f32) { impl_UniformMatrix2x3fv(location, count, transpose, value) }
-	UniformMatrix3x2fv :: #force_inline proc "c" (location: i32, count: i32, transpose: bool, value: [^]f32) { impl_UniformMatrix3x2fv(location, count, transpose, value) }
-	UniformMatrix2x4fv :: #force_inline proc "c" (location: i32, count: i32, transpose: bool, value: [^]f32) { impl_UniformMatrix2x4fv(location, count, transpose, value) }
-	UniformMatrix4x2fv :: #force_inline proc "c" (location: i32, count: i32, transpose: bool, value: [^]f32) { impl_UniformMatrix4x2fv(location, count, transpose, value) }
-	UniformMatrix3x4fv :: #force_inline proc "c" (location: i32, count: i32, transpose: bool, value: [^]f32) { impl_UniformMatrix3x4fv(location, count, transpose, value) }
-	UniformMatrix4x3fv :: #force_inline proc "c" (location: i32, count: i32, transpose: bool, value: [^]f32) { impl_UniformMatrix4x3fv(location, count, transpose, value) }
+	UniformMatrix2x3fv :: proc "c" (location: i32, count: i32, transpose: bool, value: [^]f32) { impl_UniformMatrix2x3fv(location, count, transpose, value) }
+	UniformMatrix3x2fv :: proc "c" (location: i32, count: i32, transpose: bool, value: [^]f32) { impl_UniformMatrix3x2fv(location, count, transpose, value) }
+	UniformMatrix2x4fv :: proc "c" (location: i32, count: i32, transpose: bool, value: [^]f32) { impl_UniformMatrix2x4fv(location, count, transpose, value) }
+	UniformMatrix4x2fv :: proc "c" (location: i32, count: i32, transpose: bool, value: [^]f32) { impl_UniformMatrix4x2fv(location, count, transpose, value) }
+	UniformMatrix3x4fv :: proc "c" (location: i32, count: i32, transpose: bool, value: [^]f32) { impl_UniformMatrix3x4fv(location, count, transpose, value) }
+	UniformMatrix4x3fv :: proc "c" (location: i32, count: i32, transpose: bool, value: [^]f32) { impl_UniformMatrix4x3fv(location, count, transpose, value) }
 
 
 	// VERSION_3_0
-	ColorMaski                          :: #force_inline proc "c" (index: u32, r: bool, g: bool, b: bool, a: bool)                                                                         {        impl_ColorMaski(index, r, g, b, a)                                                                     }
-	GetBooleani_v                       :: #force_inline proc "c" (target: u32, index: u32, data: ^bool)                                                                                   {        impl_GetBooleani_v(target, index, data)                                                                }
-	GetIntegeri_v                       :: #force_inline proc "c" (target: u32, index: u32, data: ^i32)                                                                                    {        impl_GetIntegeri_v(target, index, data)                                                                }
-	Enablei                             :: #force_inline proc "c" (target: u32, index: u32)                                                                                                {        impl_Enablei(target, index)                                                                            }
-	Disablei                            :: #force_inline proc "c" (target: u32, index: u32)                                                                                                {        impl_Disablei(target, index)                                                                           }
-	IsEnabledi                          :: #force_inline proc "c" (target: u32, index: u32) -> bool                                                                                        { ret := impl_IsEnabledi(target, index);                                                             return ret }
-	BeginTransformFeedback              :: #force_inline proc "c" (primitiveMode: u32)                                                                                                     {        impl_BeginTransformFeedback(primitiveMode)                                                             }
-	EndTransformFeedback                :: #force_inline proc "c" ()                                                                                                                       {        impl_EndTransformFeedback()                                                                            }
-	BindBufferRange                     :: #force_inline proc "c" (target: u32, index: u32, buffer: u32, offset: int, size: int)                                                           {        impl_BindBufferRange(target, index, buffer, offset, size)                                              }
-	BindBufferBase                      :: #force_inline proc "c" (target: u32, index: u32, buffer: u32)                                                                                   {        impl_BindBufferBase(target, index, buffer)                                                             }
-	TransformFeedbackVaryings           :: #force_inline proc "c" (program: u32, count: i32, varyings: [^]cstring, bufferMode: u32)                                                        {        impl_TransformFeedbackVaryings(program, count, varyings, bufferMode)                                   }
-	GetTransformFeedbackVarying         :: #force_inline proc "c" (program: u32, index: u32, bufSize: i32, length: ^i32, size: ^i32, type: ^u32, name: [^]u8)                              {        impl_GetTransformFeedbackVarying(program, index, bufSize, length, size, type, name)                   }
-	ClampColor                          :: #force_inline proc "c" (target: u32, clamp: u32)                                                                                                {        impl_ClampColor(target, clamp)                                                                         }
-	BeginConditionalRender              :: #force_inline proc "c" (id: u32, mode: u32)                                                                                                     {        impl_BeginConditionalRender(id, mode)                                                                  }
-	EndConditionalRender                :: #force_inline proc "c" ()                                                                                                                       {        impl_EndConditionalRender()                                                                            }
-	VertexAttribIPointer                :: #force_inline proc "c" (index: u32, size: i32, type: u32, stride: i32, pointer: uintptr)                                                         {        impl_VertexAttribIPointer(index, size, type, stride, pointer)                                         }
-	GetVertexAttribIiv                  :: #force_inline proc "c" (index: u32, pname: u32, params: [^]i32)                                                                                 {        impl_GetVertexAttribIiv(index, pname, params)                                                          }
-	GetVertexAttribIuiv                 :: #force_inline proc "c" (index: u32, pname: u32, params: [^]u32)                                                                                 {        impl_GetVertexAttribIuiv(index, pname, params)                                                         }
-	VertexAttribI1i                     :: #force_inline proc "c" (index: u32, x: i32)                                                                                                     {        impl_VertexAttribI1i(index, x)                                                                         }
-	VertexAttribI2i                     :: #force_inline proc "c" (index: u32, x: i32, y: i32)                                                                                             {        impl_VertexAttribI2i(index, x, y)                                                                      }
-	VertexAttribI3i                     :: #force_inline proc "c" (index: u32, x: i32, y: i32, z: i32)                                                                                     {        impl_VertexAttribI3i(index, x, y, z)                                                                   }
-	VertexAttribI4i                     :: #force_inline proc "c" (index: u32, x: i32, y: i32, z: i32, w: i32)                                                                             {        impl_VertexAttribI4i(index, x, y, z, w)                                                                }
-	VertexAttribI1ui                    :: #force_inline proc "c" (index: u32, x: u32)                                                                                                     {        impl_VertexAttribI1ui(index, x)                                                                        }
-	VertexAttribI2ui                    :: #force_inline proc "c" (index: u32, x: u32, y: u32)                                                                                             {        impl_VertexAttribI2ui(index, x, y)                                                                     }
-	VertexAttribI3ui                    :: #force_inline proc "c" (index: u32, x: u32, y: u32, z: u32)                                                                                     {        impl_VertexAttribI3ui(index, x, y, z)                                                                  }
-	VertexAttribI4ui                    :: #force_inline proc "c" (index: u32, x: u32, y: u32, z: u32, w: u32)                                                                             {        impl_VertexAttribI4ui(index, x, y, z, w)                                                               }
-	VertexAttribI1iv                    :: #force_inline proc "c" (index: u32, v: [^]i32)                                                                                                    {        impl_VertexAttribI1iv(index, v)                                                                        }
-	VertexAttribI2iv                    :: #force_inline proc "c" (index: u32, v: [^]i32)                                                                                                    {        impl_VertexAttribI2iv(index, v)                                                                        }
-	VertexAttribI3iv                    :: #force_inline proc "c" (index: u32, v: [^]i32)                                                                                                    {        impl_VertexAttribI3iv(index, v)                                                                        }
-	VertexAttribI4iv                    :: #force_inline proc "c" (index: u32, v: [^]i32)                                                                                                    {        impl_VertexAttribI4iv(index, v)                                                                        }
-	VertexAttribI1uiv                   :: #force_inline proc "c" (index: u32, v: [^]u32)                                                                                                    {        impl_VertexAttribI1uiv(index, v)                                                                       }
-	VertexAttribI2uiv                   :: #force_inline proc "c" (index: u32, v: [^]u32)                                                                                                    {        impl_VertexAttribI2uiv(index, v)                                                                       }
-	VertexAttribI3uiv                   :: #force_inline proc "c" (index: u32, v: [^]u32)                                                                                                    {        impl_VertexAttribI3uiv(index, v)                                                                       }
-	VertexAttribI4uiv                   :: #force_inline proc "c" (index: u32, v: [^]u32)                                                                                                    {        impl_VertexAttribI4uiv(index, v)                                                                       }
-	VertexAttribI4bv                    :: #force_inline proc "c" (index: u32, v: [^]i8)                                                                                                     {        impl_VertexAttribI4bv(index, v)                                                                        }
-	VertexAttribI4sv                    :: #force_inline proc "c" (index: u32, v: [^]i16)                                                                                                    {        impl_VertexAttribI4sv(index, v)                                                                        }
-	VertexAttribI4ubv                   :: #force_inline proc "c" (index: u32, v: [^]u8)                                                                                                     {        impl_VertexAttribI4ubv(index, v)                                                                       }
-	VertexAttribI4usv                   :: #force_inline proc "c" (index: u32, v: [^]u16)                                                                                                    {        impl_VertexAttribI4usv(index, v)                                                                       }
-	GetUniformuiv                       :: #force_inline proc "c" (program: u32, location: i32, params: [^]u32)                                                                            {        impl_GetUniformuiv(program, location, params)                                                          }
-	BindFragDataLocation                :: #force_inline proc "c" (program: u32, color: u32, name: cstring)                                                                                {        impl_BindFragDataLocation(program, color, name)                                                        }
-	GetFragDataLocation                 :: #force_inline proc "c" (program: u32, name: cstring) -> i32                                                                                     { ret := impl_GetFragDataLocation(program, name);                                                    return ret }
-	Uniform1ui                          :: #force_inline proc "c" (location: i32, v0: u32)                                                                                                 {        impl_Uniform1ui(location, v0)                                                                          }
-	Uniform2ui                          :: #force_inline proc "c" (location: i32, v0: u32, v1: u32)                                                                                        {        impl_Uniform2ui(location, v0, v1)                                                                      }
-	Uniform3ui                          :: #force_inline proc "c" (location: i32, v0: u32, v1: u32, v2: u32)                                                                               {        impl_Uniform3ui(location, v0, v1, v2)                                                                  }
-	Uniform4ui                          :: #force_inline proc "c" (location: i32, v0: u32, v1: u32, v2: u32, v3: u32)                                                                      {        impl_Uniform4ui(location, v0, v1, v2, v3)                                                              }
-	Uniform1uiv                         :: #force_inline proc "c" (location: i32, count: i32, value: [^]u32)                                                                               {        impl_Uniform1uiv(location, count, value)                                                               }
-	Uniform2uiv                         :: #force_inline proc "c" (location: i32, count: i32, value: [^]u32)                                                                               {        impl_Uniform2uiv(location, count, value)                                                               }
-	Uniform3uiv                         :: #force_inline proc "c" (location: i32, count: i32, value: [^]u32)                                                                               {        impl_Uniform3uiv(location, count, value)                                                               }
-	Uniform4uiv                         :: #force_inline proc "c" (location: i32, count: i32, value: [^]u32)                                                                               {        impl_Uniform4uiv(location, count, value)                                                               }
-	TexParameterIiv                     :: #force_inline proc "c" (target: u32, pname: u32, params: [^]i32)                                                                                {        impl_TexParameterIiv(target, pname, params)                                                            }
-	TexParameterIuiv                    :: #force_inline proc "c" (target: u32, pname: u32, params: [^]u32)                                                                                {        impl_TexParameterIuiv(target, pname, params)                                                           }
-	GetTexParameterIiv                  :: #force_inline proc "c" (target: u32, pname: u32, params: [^]i32)                                                                                {        impl_GetTexParameterIiv(target, pname, params)                                                         }
-	GetTexParameterIuiv                 :: #force_inline proc "c" (target: u32, pname: u32, params: [^]u32)                                                                                {        impl_GetTexParameterIuiv(target, pname, params)                                                        }
-	ClearBufferiv                       :: #force_inline proc "c" (buffer: u32, drawbuffer: i32, value: ^i32)                                                                              {        impl_ClearBufferiv(buffer, drawbuffer, value)                                                          }
-	ClearBufferuiv                      :: #force_inline proc "c" (buffer: u32, drawbuffer: i32, value: ^u32)                                                                              {        impl_ClearBufferuiv(buffer, drawbuffer, value)                                                         }
-	ClearBufferfv                       :: #force_inline proc "c" (buffer: u32, drawbuffer: i32, value: ^f32)                                                                              {        impl_ClearBufferfv(buffer, drawbuffer, value)                                                          }
-	ClearBufferfi                       :: #force_inline proc "c" (buffer: u32, drawbuffer: i32, depth: f32, stencil: i32) -> rawptr                                                       { ret := impl_ClearBufferfi(buffer, drawbuffer, depth, stencil);                                     return ret }
-	GetStringi                          :: #force_inline proc "c" (name: u32, index: u32) -> cstring                                                                                       { ret := impl_GetStringi(name, index);                                                               return ret }
-	IsRenderbuffer                      :: #force_inline proc "c" (renderbuffer: u32) -> bool                                                                                              { ret := impl_IsRenderbuffer(renderbuffer);                                                          return ret }
-	BindRenderbuffer                    :: #force_inline proc "c" (target: u32, renderbuffer: u32)                                                                                         {        impl_BindRenderbuffer(target, renderbuffer)                                                            }
-	DeleteRenderbuffers                 :: #force_inline proc "c" (n: i32, renderbuffers: [^]u32)                                                                                          {        impl_DeleteRenderbuffers(n, renderbuffers)                                                             }
-	GenRenderbuffers                    :: #force_inline proc "c" (n: i32, renderbuffers: [^]u32)                                                                                          {        impl_GenRenderbuffers(n, renderbuffers)                                                                }
-	RenderbufferStorage                 :: #force_inline proc "c" (target: u32, internalformat: u32, width: i32, height: i32)                                                              {        impl_RenderbufferStorage(target, internalformat, width, height)                                        }
-	GetRenderbufferParameteriv          :: #force_inline proc "c" (target: u32, pname: u32, params: [^]i32)                                                                                {        impl_GetRenderbufferParameteriv(target, pname, params)                                                 }
-	IsFramebuffer                       :: #force_inline proc "c" (framebuffer: u32) -> bool                                                                                               { ret := impl_IsFramebuffer(framebuffer);                                                            return ret }
-	BindFramebuffer                     :: #force_inline proc "c" (target: u32, framebuffer: u32)                                                                                          {        impl_BindFramebuffer(target, framebuffer)                                                              }
-	DeleteFramebuffers                  :: #force_inline proc "c" (n: i32, framebuffers: [^]u32)                                                                                           {        impl_DeleteFramebuffers(n, framebuffers)                                                               }
-	GenFramebuffers                     :: #force_inline proc "c" (n: i32, framebuffers: [^]u32)                                                                                           {        impl_GenFramebuffers(n, framebuffers)                                                                  }
-	CheckFramebufferStatus              :: #force_inline proc "c" (target: u32) -> u32                                                                                                     { ret := impl_CheckFramebufferStatus(target);                                                        return ret }
-	FramebufferTexture1D                :: #force_inline proc "c" (target: u32, attachment: u32, textarget: u32, texture: u32, level: i32)                                                 {        impl_FramebufferTexture1D(target, attachment, textarget, texture, level)                               }
-	FramebufferTexture2D                :: #force_inline proc "c" (target: u32, attachment: u32, textarget: u32, texture: u32, level: i32)                                                 {        impl_FramebufferTexture2D(target, attachment, textarget, texture, level)                               }
-	FramebufferTexture3D                :: #force_inline proc "c" (target: u32, attachment: u32, textarget: u32, texture: u32, level: i32, zoffset: i32)                                   {        impl_FramebufferTexture3D(target, attachment, textarget, texture, level, zoffset)                      }
-	FramebufferRenderbuffer             :: #force_inline proc "c" (target: u32, attachment: u32, renderbuffertarget: u32, renderbuffer: u32)                                               {        impl_FramebufferRenderbuffer(target, attachment, renderbuffertarget, renderbuffer)                     }
-	GetFramebufferAttachmentParameteriv :: #force_inline proc "c" (target: u32, attachment: u32, pname: u32, params: [^]i32)                                                               {        impl_GetFramebufferAttachmentParameteriv(target, attachment, pname, params)                            }
-	GenerateMipmap                      :: #force_inline proc "c" (target: u32)                                                                                                            {        impl_GenerateMipmap(target)                                                                            }
-	BlitFramebuffer                     :: #force_inline proc "c" (srcX0: i32, srcY0: i32, srcX1: i32, srcY1: i32, dstX0: i32, dstY0: i32, dstX1: i32, dstY1: i32, mask: u32, filter: u32) {        impl_BlitFramebuffer(srcX0, srcY0, srcX1, srcY1, dstX0, dstY0, dstX1, dstY1, mask, filter)             }
-	RenderbufferStorageMultisample      :: #force_inline proc "c" (target: u32, samples: i32, internalformat: u32, width: i32, height: i32)                                                {        impl_RenderbufferStorageMultisample(target, samples, internalformat, width, height)                    }
-	FramebufferTextureLayer             :: #force_inline proc "c" (target: u32, attachment: u32, texture: u32, level: i32, layer: i32)                                                     {        impl_FramebufferTextureLayer(target, attachment, texture, level, layer)                                }
-	MapBufferRange                      :: #force_inline proc "c" (target: u32, offset: int, length: int, access: u32) -> rawptr                                                           { ret := impl_MapBufferRange(target, offset, length, access);                                        return ret }
-	FlushMappedBufferRange              :: #force_inline proc "c" (target: u32, offset: int, length: int)                                                                                  {        impl_FlushMappedBufferRange(target, offset, length)                                                    }
-	BindVertexArray                     :: #force_inline proc "c" (array: u32)                                                                                                             {        impl_BindVertexArray(array)                                                                            }
-	DeleteVertexArrays                  :: #force_inline proc "c" (n: i32, arrays: [^]u32)                                                                                                 {        impl_DeleteVertexArrays(n, arrays)                                                                     }
-	GenVertexArrays                     :: #force_inline proc "c" (n: i32, arrays: [^]u32)                                                                                                 {        impl_GenVertexArrays(n, arrays)                                                                        }
-	IsVertexArray                       :: #force_inline proc "c" (array: u32) -> bool                                                                                                     { ret := impl_IsVertexArray(array);                                                                  return ret }
+	ColorMaski                          :: proc "c" (index: u32, r: bool, g: bool, b: bool, a: bool)                                                                         {        impl_ColorMaski(index, r, g, b, a)                                                                     }
+	GetBooleani_v                       :: proc "c" (target: u32, index: u32, data: ^bool)                                                                                   {        impl_GetBooleani_v(target, index, data)                                                                }
+	GetIntegeri_v                       :: proc "c" (target: u32, index: u32, data: ^i32)                                                                                    {        impl_GetIntegeri_v(target, index, data)                                                                }
+	Enablei                             :: proc "c" (target: u32, index: u32)                                                                                                {        impl_Enablei(target, index)                                                                            }
+	Disablei                            :: proc "c" (target: u32, index: u32)                                                                                                {        impl_Disablei(target, index)                                                                           }
+	IsEnabledi                          :: proc "c" (target: u32, index: u32) -> bool                                                                                        { ret := impl_IsEnabledi(target, index);                                                             return ret }
+	BeginTransformFeedback              :: proc "c" (primitiveMode: u32)                                                                                                     {        impl_BeginTransformFeedback(primitiveMode)                                                             }
+	EndTransformFeedback                :: proc "c" ()                                                                                                                       {        impl_EndTransformFeedback()                                                                            }
+	BindBufferRange                     :: proc "c" (target: u32, index: u32, buffer: u32, offset: int, size: int)                                                           {        impl_BindBufferRange(target, index, buffer, offset, size)                                              }
+	BindBufferBase                      :: proc "c" (target: u32, index: u32, buffer: u32)                                                                                   {        impl_BindBufferBase(target, index, buffer)                                                             }
+	TransformFeedbackVaryings           :: proc "c" (program: u32, count: i32, varyings: [^]cstring, bufferMode: u32)                                                        {        impl_TransformFeedbackVaryings(program, count, varyings, bufferMode)                                   }
+	GetTransformFeedbackVarying         :: proc "c" (program: u32, index: u32, bufSize: i32, length: ^i32, size: ^i32, type: ^u32, name: [^]u8)                              {        impl_GetTransformFeedbackVarying(program, index, bufSize, length, size, type, name)                   }
+	ClampColor                          :: proc "c" (target: u32, clamp: u32)                                                                                                {        impl_ClampColor(target, clamp)                                                                         }
+	BeginConditionalRender              :: proc "c" (id: u32, mode: u32)                                                                                                     {        impl_BeginConditionalRender(id, mode)                                                                  }
+	EndConditionalRender                :: proc "c" ()                                                                                                                       {        impl_EndConditionalRender()                                                                            }
+	VertexAttribIPointer                :: proc "c" (index: u32, size: i32, type: u32, stride: i32, pointer: uintptr)                                                         {        impl_VertexAttribIPointer(index, size, type, stride, pointer)                                         }
+	GetVertexAttribIiv                  :: proc "c" (index: u32, pname: u32, params: [^]i32)                                                                                 {        impl_GetVertexAttribIiv(index, pname, params)                                                          }
+	GetVertexAttribIuiv                 :: proc "c" (index: u32, pname: u32, params: [^]u32)                                                                                 {        impl_GetVertexAttribIuiv(index, pname, params)                                                         }
+	VertexAttribI1i                     :: proc "c" (index: u32, x: i32)                                                                                                     {        impl_VertexAttribI1i(index, x)                                                                         }
+	VertexAttribI2i                     :: proc "c" (index: u32, x: i32, y: i32)                                                                                             {        impl_VertexAttribI2i(index, x, y)                                                                      }
+	VertexAttribI3i                     :: proc "c" (index: u32, x: i32, y: i32, z: i32)                                                                                     {        impl_VertexAttribI3i(index, x, y, z)                                                                   }
+	VertexAttribI4i                     :: proc "c" (index: u32, x: i32, y: i32, z: i32, w: i32)                                                                             {        impl_VertexAttribI4i(index, x, y, z, w)                                                                }
+	VertexAttribI1ui                    :: proc "c" (index: u32, x: u32)                                                                                                     {        impl_VertexAttribI1ui(index, x)                                                                        }
+	VertexAttribI2ui                    :: proc "c" (index: u32, x: u32, y: u32)                                                                                             {        impl_VertexAttribI2ui(index, x, y)                                                                     }
+	VertexAttribI3ui                    :: proc "c" (index: u32, x: u32, y: u32, z: u32)                                                                                     {        impl_VertexAttribI3ui(index, x, y, z)                                                                  }
+	VertexAttribI4ui                    :: proc "c" (index: u32, x: u32, y: u32, z: u32, w: u32)                                                                             {        impl_VertexAttribI4ui(index, x, y, z, w)                                                               }
+	VertexAttribI1iv                    :: proc "c" (index: u32, v: [^]i32)                                                                                                    {        impl_VertexAttribI1iv(index, v)                                                                        }
+	VertexAttribI2iv                    :: proc "c" (index: u32, v: [^]i32)                                                                                                    {        impl_VertexAttribI2iv(index, v)                                                                        }
+	VertexAttribI3iv                    :: proc "c" (index: u32, v: [^]i32)                                                                                                    {        impl_VertexAttribI3iv(index, v)                                                                        }
+	VertexAttribI4iv                    :: proc "c" (index: u32, v: [^]i32)                                                                                                    {        impl_VertexAttribI4iv(index, v)                                                                        }
+	VertexAttribI1uiv                   :: proc "c" (index: u32, v: [^]u32)                                                                                                    {        impl_VertexAttribI1uiv(index, v)                                                                       }
+	VertexAttribI2uiv                   :: proc "c" (index: u32, v: [^]u32)                                                                                                    {        impl_VertexAttribI2uiv(index, v)                                                                       }
+	VertexAttribI3uiv                   :: proc "c" (index: u32, v: [^]u32)                                                                                                    {        impl_VertexAttribI3uiv(index, v)                                                                       }
+	VertexAttribI4uiv                   :: proc "c" (index: u32, v: [^]u32)                                                                                                    {        impl_VertexAttribI4uiv(index, v)                                                                       }
+	VertexAttribI4bv                    :: proc "c" (index: u32, v: [^]i8)                                                                                                     {        impl_VertexAttribI4bv(index, v)                                                                        }
+	VertexAttribI4sv                    :: proc "c" (index: u32, v: [^]i16)                                                                                                    {        impl_VertexAttribI4sv(index, v)                                                                        }
+	VertexAttribI4ubv                   :: proc "c" (index: u32, v: [^]u8)                                                                                                     {        impl_VertexAttribI4ubv(index, v)                                                                       }
+	VertexAttribI4usv                   :: proc "c" (index: u32, v: [^]u16)                                                                                                    {        impl_VertexAttribI4usv(index, v)                                                                       }
+	GetUniformuiv                       :: proc "c" (program: u32, location: i32, params: [^]u32)                                                                            {        impl_GetUniformuiv(program, location, params)                                                          }
+	BindFragDataLocation                :: proc "c" (program: u32, color: u32, name: cstring)                                                                                {        impl_BindFragDataLocation(program, color, name)                                                        }
+	GetFragDataLocation                 :: proc "c" (program: u32, name: cstring) -> i32                                                                                     { ret := impl_GetFragDataLocation(program, name);                                                    return ret }
+	Uniform1ui                          :: proc "c" (location: i32, v0: u32)                                                                                                 {        impl_Uniform1ui(location, v0)                                                                          }
+	Uniform2ui                          :: proc "c" (location: i32, v0: u32, v1: u32)                                                                                        {        impl_Uniform2ui(location, v0, v1)                                                                      }
+	Uniform3ui                          :: proc "c" (location: i32, v0: u32, v1: u32, v2: u32)                                                                               {        impl_Uniform3ui(location, v0, v1, v2)                                                                  }
+	Uniform4ui                          :: proc "c" (location: i32, v0: u32, v1: u32, v2: u32, v3: u32)                                                                      {        impl_Uniform4ui(location, v0, v1, v2, v3)                                                              }
+	Uniform1uiv                         :: proc "c" (location: i32, count: i32, value: [^]u32)                                                                               {        impl_Uniform1uiv(location, count, value)                                                               }
+	Uniform2uiv                         :: proc "c" (location: i32, count: i32, value: [^]u32)                                                                               {        impl_Uniform2uiv(location, count, value)                                                               }
+	Uniform3uiv                         :: proc "c" (location: i32, count: i32, value: [^]u32)                                                                               {        impl_Uniform3uiv(location, count, value)                                                               }
+	Uniform4uiv                         :: proc "c" (location: i32, count: i32, value: [^]u32)                                                                               {        impl_Uniform4uiv(location, count, value)                                                               }
+	TexParameterIiv                     :: proc "c" (target: u32, pname: u32, params: [^]i32)                                                                                {        impl_TexParameterIiv(target, pname, params)                                                            }
+	TexParameterIuiv                    :: proc "c" (target: u32, pname: u32, params: [^]u32)                                                                                {        impl_TexParameterIuiv(target, pname, params)                                                           }
+	GetTexParameterIiv                  :: proc "c" (target: u32, pname: u32, params: [^]i32)                                                                                {        impl_GetTexParameterIiv(target, pname, params)                                                         }
+	GetTexParameterIuiv                 :: proc "c" (target: u32, pname: u32, params: [^]u32)                                                                                {        impl_GetTexParameterIuiv(target, pname, params)                                                        }
+	ClearBufferiv                       :: proc "c" (buffer: u32, drawbuffer: i32, value: ^i32)                                                                              {        impl_ClearBufferiv(buffer, drawbuffer, value)                                                          }
+	ClearBufferuiv                      :: proc "c" (buffer: u32, drawbuffer: i32, value: ^u32)                                                                              {        impl_ClearBufferuiv(buffer, drawbuffer, value)                                                         }
+	ClearBufferfv                       :: proc "c" (buffer: u32, drawbuffer: i32, value: ^f32)                                                                              {        impl_ClearBufferfv(buffer, drawbuffer, value)                                                          }
+	ClearBufferfi                       :: proc "c" (buffer: u32, drawbuffer: i32, depth: f32, stencil: i32) -> rawptr                                                       { ret := impl_ClearBufferfi(buffer, drawbuffer, depth, stencil);                                     return ret }
+	GetStringi                          :: proc "c" (name: u32, index: u32) -> cstring                                                                                       { ret := impl_GetStringi(name, index);                                                               return ret }
+	IsRenderbuffer                      :: proc "c" (renderbuffer: u32) -> bool                                                                                              { ret := impl_IsRenderbuffer(renderbuffer);                                                          return ret }
+	BindRenderbuffer                    :: proc "c" (target: u32, renderbuffer: u32)                                                                                         {        impl_BindRenderbuffer(target, renderbuffer)                                                            }
+	DeleteRenderbuffers                 :: proc "c" (n: i32, renderbuffers: [^]u32)                                                                                          {        impl_DeleteRenderbuffers(n, renderbuffers)                                                             }
+	GenRenderbuffers                    :: proc "c" (n: i32, renderbuffers: [^]u32)                                                                                          {        impl_GenRenderbuffers(n, renderbuffers)                                                                }
+	RenderbufferStorage                 :: proc "c" (target: u32, internalformat: u32, width: i32, height: i32)                                                              {        impl_RenderbufferStorage(target, internalformat, width, height)                                        }
+	GetRenderbufferParameteriv          :: proc "c" (target: u32, pname: u32, params: [^]i32)                                                                                {        impl_GetRenderbufferParameteriv(target, pname, params)                                                 }
+	IsFramebuffer                       :: proc "c" (framebuffer: u32) -> bool                                                                                               { ret := impl_IsFramebuffer(framebuffer);                                                            return ret }
+	BindFramebuffer                     :: proc "c" (target: u32, framebuffer: u32)                                                                                          {        impl_BindFramebuffer(target, framebuffer)                                                              }
+	DeleteFramebuffers                  :: proc "c" (n: i32, framebuffers: [^]u32)                                                                                           {        impl_DeleteFramebuffers(n, framebuffers)                                                               }
+	GenFramebuffers                     :: proc "c" (n: i32, framebuffers: [^]u32)                                                                                           {        impl_GenFramebuffers(n, framebuffers)                                                                  }
+	CheckFramebufferStatus              :: proc "c" (target: u32) -> u32                                                                                                     { ret := impl_CheckFramebufferStatus(target);                                                        return ret }
+	FramebufferTexture1D                :: proc "c" (target: u32, attachment: u32, textarget: u32, texture: u32, level: i32)                                                 {        impl_FramebufferTexture1D(target, attachment, textarget, texture, level)                               }
+	FramebufferTexture2D                :: proc "c" (target: u32, attachment: u32, textarget: u32, texture: u32, level: i32)                                                 {        impl_FramebufferTexture2D(target, attachment, textarget, texture, level)                               }
+	FramebufferTexture3D                :: proc "c" (target: u32, attachment: u32, textarget: u32, texture: u32, level: i32, zoffset: i32)                                   {        impl_FramebufferTexture3D(target, attachment, textarget, texture, level, zoffset)                      }
+	FramebufferRenderbuffer             :: proc "c" (target: u32, attachment: u32, renderbuffertarget: u32, renderbuffer: u32)                                               {        impl_FramebufferRenderbuffer(target, attachment, renderbuffertarget, renderbuffer)                     }
+	GetFramebufferAttachmentParameteriv :: proc "c" (target: u32, attachment: u32, pname: u32, params: [^]i32)                                                               {        impl_GetFramebufferAttachmentParameteriv(target, attachment, pname, params)                            }
+	GenerateMipmap                      :: proc "c" (target: u32)                                                                                                            {        impl_GenerateMipmap(target)                                                                            }
+	BlitFramebuffer                     :: proc "c" (srcX0: i32, srcY0: i32, srcX1: i32, srcY1: i32, dstX0: i32, dstY0: i32, dstX1: i32, dstY1: i32, mask: u32, filter: u32) {        impl_BlitFramebuffer(srcX0, srcY0, srcX1, srcY1, dstX0, dstY0, dstX1, dstY1, mask, filter)             }
+	RenderbufferStorageMultisample      :: proc "c" (target: u32, samples: i32, internalformat: u32, width: i32, height: i32)                                                {        impl_RenderbufferStorageMultisample(target, samples, internalformat, width, height)                    }
+	FramebufferTextureLayer             :: proc "c" (target: u32, attachment: u32, texture: u32, level: i32, layer: i32)                                                     {        impl_FramebufferTextureLayer(target, attachment, texture, level, layer)                                }
+	MapBufferRange                      :: proc "c" (target: u32, offset: int, length: int, access: u32) -> rawptr                                                           { ret := impl_MapBufferRange(target, offset, length, access);                                        return ret }
+	FlushMappedBufferRange              :: proc "c" (target: u32, offset: int, length: int)                                                                                  {        impl_FlushMappedBufferRange(target, offset, length)                                                    }
+	BindVertexArray                     :: proc "c" (array: u32)                                                                                                             {        impl_BindVertexArray(array)                                                                            }
+	DeleteVertexArrays                  :: proc "c" (n: i32, arrays: [^]u32)                                                                                                 {        impl_DeleteVertexArrays(n, arrays)                                                                     }
+	GenVertexArrays                     :: proc "c" (n: i32, arrays: [^]u32)                                                                                                 {        impl_GenVertexArrays(n, arrays)                                                                        }
+	IsVertexArray                       :: proc "c" (array: u32) -> bool                                                                                                     { ret := impl_IsVertexArray(array);                                                                  return ret }
 
 	// VERSION_3_1
-	DrawArraysInstanced       :: #force_inline proc "c" (mode: u32, first: i32, count: i32, instancecount: i32)                                     {        impl_DrawArraysInstanced(mode, first, count, instancecount)                                               }
-	DrawElementsInstanced     :: #force_inline proc "c" (mode: u32, count: i32, type: u32, indices: rawptr, instancecount: i32)                     {        impl_DrawElementsInstanced(mode, count, type, indices, instancecount)                                    }
-	TexBuffer                 :: #force_inline proc "c" (target: u32, internalformat: u32, buffer: u32)                                             {        impl_TexBuffer(target, internalformat, buffer)                                                            }
-	PrimitiveRestartIndex     :: #force_inline proc "c" (index: u32)                                                                                {        impl_PrimitiveRestartIndex(index)                                                                         }
-	CopyBufferSubData         :: #force_inline proc "c" (readTarget: u32, writeTarget: u32, readOffset: int, writeOffset: int, size: int)           {        impl_CopyBufferSubData(readTarget, writeTarget, readOffset, writeOffset, size)                            }
-	GetUniformIndices         :: #force_inline proc "c" (program: u32, uniformCount: i32, uniformNames: [^]cstring, uniformIndices: [^]u32)         {        impl_GetUniformIndices(program, uniformCount, uniformNames, uniformIndices)                               }
-	GetActiveUniformsiv       :: #force_inline proc "c" (program: u32, uniformCount: i32, uniformIndices: [^]u32, pname: u32, params: [^]i32)       {        impl_GetActiveUniformsiv(program, uniformCount, uniformIndices, pname, params)                            }
-	GetActiveUniformName      :: #force_inline proc "c" (program: u32, uniformIndex: u32, bufSize: i32, length: ^i32, uniformName: [^]u8)           {        impl_GetActiveUniformName(program, uniformIndex, bufSize, length, uniformName)                            }
-	GetUniformBlockIndex      :: #force_inline proc "c" (program: u32, uniformBlockName: cstring) -> u32                                            { ret := impl_GetUniformBlockIndex(program, uniformBlockName);                                          return ret }
-	GetActiveUniformBlockiv   :: #force_inline proc "c" (program: u32, uniformBlockIndex: u32, pname: u32, params: [^]i32)                          {        impl_GetActiveUniformBlockiv(program, uniformBlockIndex, pname, params)                                   }
-	GetActiveUniformBlockName :: #force_inline proc "c" (program: u32, uniformBlockIndex: u32, bufSize: i32, length: ^i32, uniformBlockName: [^]u8) {        impl_GetActiveUniformBlockName(program, uniformBlockIndex, bufSize, length, uniformBlockName)             }
-	UniformBlockBinding       :: #force_inline proc "c" (program: u32, uniformBlockIndex: u32, uniformBlockBinding: u32)                            {        impl_UniformBlockBinding(program, uniformBlockIndex, uniformBlockBinding)                                 }
+	DrawArraysInstanced       :: proc "c" (mode: u32, first: i32, count: i32, instancecount: i32)                                     {        impl_DrawArraysInstanced(mode, first, count, instancecount)                                               }
+	DrawElementsInstanced     :: proc "c" (mode: u32, count: i32, type: u32, indices: rawptr, instancecount: i32)                     {        impl_DrawElementsInstanced(mode, count, type, indices, instancecount)                                    }
+	TexBuffer                 :: proc "c" (target: u32, internalformat: u32, buffer: u32)                                             {        impl_TexBuffer(target, internalformat, buffer)                                                            }
+	PrimitiveRestartIndex     :: proc "c" (index: u32)                                                                                {        impl_PrimitiveRestartIndex(index)                                                                         }
+	CopyBufferSubData         :: proc "c" (readTarget: u32, writeTarget: u32, readOffset: int, writeOffset: int, size: int)           {        impl_CopyBufferSubData(readTarget, writeTarget, readOffset, writeOffset, size)                            }
+	GetUniformIndices         :: proc "c" (program: u32, uniformCount: i32, uniformNames: [^]cstring, uniformIndices: [^]u32)         {        impl_GetUniformIndices(program, uniformCount, uniformNames, uniformIndices)                               }
+	GetActiveUniformsiv       :: proc "c" (program: u32, uniformCount: i32, uniformIndices: [^]u32, pname: u32, params: [^]i32)       {        impl_GetActiveUniformsiv(program, uniformCount, uniformIndices, pname, params)                            }
+	GetActiveUniformName      :: proc "c" (program: u32, uniformIndex: u32, bufSize: i32, length: ^i32, uniformName: [^]u8)           {        impl_GetActiveUniformName(program, uniformIndex, bufSize, length, uniformName)                            }
+	GetUniformBlockIndex      :: proc "c" (program: u32, uniformBlockName: cstring) -> u32                                            { ret := impl_GetUniformBlockIndex(program, uniformBlockName);                                          return ret }
+	GetActiveUniformBlockiv   :: proc "c" (program: u32, uniformBlockIndex: u32, pname: u32, params: [^]i32)                          {        impl_GetActiveUniformBlockiv(program, uniformBlockIndex, pname, params)                                   }
+	GetActiveUniformBlockName :: proc "c" (program: u32, uniformBlockIndex: u32, bufSize: i32, length: ^i32, uniformBlockName: [^]u8) {        impl_GetActiveUniformBlockName(program, uniformBlockIndex, bufSize, length, uniformBlockName)             }
+	UniformBlockBinding       :: proc "c" (program: u32, uniformBlockIndex: u32, uniformBlockBinding: u32)                            {        impl_UniformBlockBinding(program, uniformBlockIndex, uniformBlockBinding)                                 }
 
 	// VERSION_3_2
-	DrawElementsBaseVertex          :: #force_inline proc "c" (mode: u32, count: i32, type: u32, indices: rawptr, basevertex: i32)                                            {        impl_DrawElementsBaseVertex(mode, count, type, indices, basevertex)                                                }
-	DrawRangeElementsBaseVertex     :: #force_inline proc "c" (mode: u32, start: u32, end: u32, count: i32, type: u32, indices: rawptr, basevertex: i32)                      {        impl_DrawRangeElementsBaseVertex(mode, start, end, count, type, indices, basevertex)                               }
-	DrawElementsInstancedBaseVertex :: #force_inline proc "c" (mode: u32, count: i32, type: u32, indices: rawptr, instancecount: i32, basevertex: i32)                        {        impl_DrawElementsInstancedBaseVertex(mode, count, type, indices, instancecount, basevertex)                        }
-	MultiDrawElementsBaseVertex     :: #force_inline proc "c" (mode: u32, count: [^]i32, type: u32, indices: [^]rawptr, drawcount: i32, basevertex: [^]i32)                   {        impl_MultiDrawElementsBaseVertex(mode, count, type, indices, drawcount, basevertex)                                }
-	ProvokingVertex                 :: #force_inline proc "c" (mode: u32)                                                                                                     {        impl_ProvokingVertex(mode)                                                                                          }
-	FenceSync                       :: #force_inline proc "c" (condition: u32, flags: u32) -> sync_t                                                                          { ret := impl_FenceSync(condition, flags);                                                                        return ret }
-	IsSync                          :: #force_inline proc "c" (sync: sync_t) -> bool                                                                                          { ret := impl_IsSync(sync);                                                                                       return ret }
-	DeleteSync                      :: #force_inline proc "c" (sync: sync_t)                                                                                                  {        impl_DeleteSync(sync)                                                                                               }
-	ClientWaitSync                  :: #force_inline proc "c" (sync: sync_t, flags: u32, timeout: u64) -> u32                                                                 { ret := impl_ClientWaitSync(sync, flags, timeout);                                                               return ret }
-	WaitSync                        :: #force_inline proc "c" (sync: sync_t, flags: u32, timeout: u64)                                                                        {        impl_WaitSync(sync, flags, timeout)                                                                                 }
-	GetInteger64v                   :: #force_inline proc "c" (pname: u32, data: ^i64)                                                                                        {        impl_GetInteger64v(pname, data)                                                                                     }
-	GetSynciv                       :: #force_inline proc "c" (sync: sync_t, pname: u32, bufSize: i32, length: ^i32, values: [^]i32)                                          {        impl_GetSynciv(sync, pname, bufSize, length, values)                                                                }
-	GetInteger64i_v                 :: #force_inline proc "c" (target: u32, index: u32, data: ^i64)                                                                           {        impl_GetInteger64i_v(target, index, data)                                                                           }
-	GetBufferParameteri64v          :: #force_inline proc "c" (target: u32, pname: u32, params: [^]i64)                                                                       {        impl_GetBufferParameteri64v(target, pname, params)                                                                  }
-	FramebufferTexture              :: #force_inline proc "c" (target: u32, attachment: u32, texture: u32, level: i32)                                                        {        impl_FramebufferTexture(target, attachment, texture, level)                                                         }
-	TexImage2DMultisample           :: #force_inline proc "c" (target: u32, samples: i32, internalformat: u32, width: i32, height: i32, fixedsamplelocations: bool)             {        impl_TexImage2DMultisample(target, samples, internalformat, width, height, fixedsamplelocations)                    }
-	TexImage3DMultisample           :: #force_inline proc "c" (target: u32, samples: i32, internalformat: u32, width: i32, height: i32, depth: i32, fixedsamplelocations: bool) {        impl_TexImage3DMultisample(target, samples, internalformat, width, height, depth, fixedsamplelocations)             }
-	GetMultisamplefv                :: #force_inline proc "c" (pname: u32, index: u32, val: ^f32)                                                                             {        impl_GetMultisamplefv(pname, index, val)                                                                            }
-	SampleMaski                     :: #force_inline proc "c" (maskNumber: u32, mask: u32)                                                                                    {        impl_SampleMaski(maskNumber, mask)                                                                                  }
+	DrawElementsBaseVertex          :: proc "c" (mode: u32, count: i32, type: u32, indices: rawptr, basevertex: i32)                                            {        impl_DrawElementsBaseVertex(mode, count, type, indices, basevertex)                                                }
+	DrawRangeElementsBaseVertex     :: proc "c" (mode: u32, start: u32, end: u32, count: i32, type: u32, indices: rawptr, basevertex: i32)                      {        impl_DrawRangeElementsBaseVertex(mode, start, end, count, type, indices, basevertex)                               }
+	DrawElementsInstancedBaseVertex :: proc "c" (mode: u32, count: i32, type: u32, indices: rawptr, instancecount: i32, basevertex: i32)                        {        impl_DrawElementsInstancedBaseVertex(mode, count, type, indices, instancecount, basevertex)                        }
+	MultiDrawElementsBaseVertex     :: proc "c" (mode: u32, count: [^]i32, type: u32, indices: [^]rawptr, drawcount: i32, basevertex: [^]i32)                   {        impl_MultiDrawElementsBaseVertex(mode, count, type, indices, drawcount, basevertex)                                }
+	ProvokingVertex                 :: proc "c" (mode: u32)                                                                                                     {        impl_ProvokingVertex(mode)                                                                                          }
+	FenceSync                       :: proc "c" (condition: u32, flags: u32) -> sync_t                                                                          { ret := impl_FenceSync(condition, flags);                                                                        return ret }
+	IsSync                          :: proc "c" (sync: sync_t) -> bool                                                                                          { ret := impl_IsSync(sync);                                                                                       return ret }
+	DeleteSync                      :: proc "c" (sync: sync_t)                                                                                                  {        impl_DeleteSync(sync)                                                                                               }
+	ClientWaitSync                  :: proc "c" (sync: sync_t, flags: u32, timeout: u64) -> u32                                                                 { ret := impl_ClientWaitSync(sync, flags, timeout);                                                               return ret }
+	WaitSync                        :: proc "c" (sync: sync_t, flags: u32, timeout: u64)                                                                        {        impl_WaitSync(sync, flags, timeout)                                                                                 }
+	GetInteger64v                   :: proc "c" (pname: u32, data: ^i64)                                                                                        {        impl_GetInteger64v(pname, data)                                                                                     }
+	GetSynciv                       :: proc "c" (sync: sync_t, pname: u32, bufSize: i32, length: ^i32, values: [^]i32)                                          {        impl_GetSynciv(sync, pname, bufSize, length, values)                                                                }
+	GetInteger64i_v                 :: proc "c" (target: u32, index: u32, data: ^i64)                                                                           {        impl_GetInteger64i_v(target, index, data)                                                                           }
+	GetBufferParameteri64v          :: proc "c" (target: u32, pname: u32, params: [^]i64)                                                                       {        impl_GetBufferParameteri64v(target, pname, params)                                                                  }
+	FramebufferTexture              :: proc "c" (target: u32, attachment: u32, texture: u32, level: i32)                                                        {        impl_FramebufferTexture(target, attachment, texture, level)                                                         }
+	TexImage2DMultisample           :: proc "c" (target: u32, samples: i32, internalformat: u32, width: i32, height: i32, fixedsamplelocations: bool)             {        impl_TexImage2DMultisample(target, samples, internalformat, width, height, fixedsamplelocations)                    }
+	TexImage3DMultisample           :: proc "c" (target: u32, samples: i32, internalformat: u32, width: i32, height: i32, depth: i32, fixedsamplelocations: bool) {        impl_TexImage3DMultisample(target, samples, internalformat, width, height, depth, fixedsamplelocations)             }
+	GetMultisamplefv                :: proc "c" (pname: u32, index: u32, val: ^f32)                                                                             {        impl_GetMultisamplefv(pname, index, val)                                                                            }
+	SampleMaski                     :: proc "c" (maskNumber: u32, mask: u32)                                                                                    {        impl_SampleMaski(maskNumber, mask)                                                                                  }
 
 	// VERSION_3_3
-	BindFragDataLocationIndexed :: #force_inline proc "c" (program: u32, colorNumber: u32, index: u32, name: cstring) {        impl_BindFragDataLocationIndexed(program, colorNumber, index, name)             }
-	GetFragDataIndex            :: #force_inline proc "c" (program: u32, name: cstring) -> i32                        { ret := impl_GetFragDataIndex(program, name);                                return ret }
-	GenSamplers                 :: #force_inline proc "c" (count: i32, samplers: [^]u32)                              {        impl_GenSamplers(count, samplers)                                               }
-	DeleteSamplers              :: #force_inline proc "c" (count: i32, samplers: [^]u32)                              {        impl_DeleteSamplers(count, samplers)                                            }
-	IsSampler                   :: #force_inline proc "c" (sampler: u32) -> bool                                      { ret := impl_IsSampler(sampler);                                             return ret }
-	BindSampler                 :: #force_inline proc "c" (unit: u32, sampler: u32)                                   {        impl_BindSampler(unit, sampler)                                                 }
-	SamplerParameteri           :: #force_inline proc "c" (sampler: u32, pname: u32, param: i32)                      {        impl_SamplerParameteri(sampler, pname, param)                                   }
-	SamplerParameteriv          :: #force_inline proc "c" (sampler: u32, pname: u32, param: ^i32)                     {        impl_SamplerParameteriv(sampler, pname, param)                                  }
-	SamplerParameterf           :: #force_inline proc "c" (sampler: u32, pname: u32, param: f32)                      {        impl_SamplerParameterf(sampler, pname, param)                                   }
-	SamplerParameterfv          :: #force_inline proc "c" (sampler: u32, pname: u32, param: ^f32)                     {        impl_SamplerParameterfv(sampler, pname, param)                                  }
-	SamplerParameterIiv         :: #force_inline proc "c" (sampler: u32, pname: u32, param: ^i32)                     {        impl_SamplerParameterIiv(sampler, pname, param)                                 }
-	SamplerParameterIuiv        :: #force_inline proc "c" (sampler: u32, pname: u32, param: ^u32)                     {        impl_SamplerParameterIuiv(sampler, pname, param)                                }
-	GetSamplerParameteriv       :: #force_inline proc "c" (sampler: u32, pname: u32, params: [^]i32)                  {        impl_GetSamplerParameteriv(sampler, pname, params)                              }
-	GetSamplerParameterIiv      :: #force_inline proc "c" (sampler: u32, pname: u32, params: [^]i32)                  {        impl_GetSamplerParameterIiv(sampler, pname, params)                             }
-	GetSamplerParameterfv       :: #force_inline proc "c" (sampler: u32, pname: u32, params: [^]f32)                  {        impl_GetSamplerParameterfv(sampler, pname, params)                              }
-	GetSamplerParameterIuiv     :: #force_inline proc "c" (sampler: u32, pname: u32, params: [^]u32)                  {        impl_GetSamplerParameterIuiv(sampler, pname, params)                            }
-	QueryCounter                :: #force_inline proc "c" (id: u32, target: u32)                                      {        impl_QueryCounter(id, target)                                                   }
-	GetQueryObjecti64v          :: #force_inline proc "c" (id: u32, pname: u32, params: [^]i64)                       {        impl_GetQueryObjecti64v(id, pname, params)                                      }
-	GetQueryObjectui64v         :: #force_inline proc "c" (id: u32, pname: u32, params: [^]u64)                       {        impl_GetQueryObjectui64v(id, pname, params)                                     }
-	VertexAttribDivisor         :: #force_inline proc "c" (index: u32, divisor: u32)                                  {        impl_VertexAttribDivisor(index, divisor)                                        }
-	VertexAttribP1ui            :: #force_inline proc "c" (index: u32, type: u32, normalized: bool, value: u32)       {        impl_VertexAttribP1ui(index, type, normalized, value)                          }
-	VertexAttribP1uiv           :: #force_inline proc "c" (index: u32, type: u32, normalized: bool, value: ^u32)      {        impl_VertexAttribP1uiv(index, type, normalized, value)                         }
-	VertexAttribP2ui            :: #force_inline proc "c" (index: u32, type: u32, normalized: bool, value: u32)       {        impl_VertexAttribP2ui(index, type, normalized, value)                          }
-	VertexAttribP2uiv           :: #force_inline proc "c" (index: u32, type: u32, normalized: bool, value: ^u32)      {        impl_VertexAttribP2uiv(index, type, normalized, value)                         }
-	VertexAttribP3ui            :: #force_inline proc "c" (index: u32, type: u32, normalized: bool, value: u32)       {        impl_VertexAttribP3ui(index, type, normalized, value)                          }
-	VertexAttribP3uiv           :: #force_inline proc "c" (index: u32, type: u32, normalized: bool, value: ^u32)      {        impl_VertexAttribP3uiv(index, type, normalized, value)                         }
-	VertexAttribP4ui            :: #force_inline proc "c" (index: u32, type: u32, normalized: bool, value: u32)       {        impl_VertexAttribP4ui(index, type, normalized, value)                          }
-	VertexAttribP4uiv           :: #force_inline proc "c" (index: u32, type: u32, normalized: bool, value: ^u32)      {        impl_VertexAttribP4uiv(index, type, normalized, value)                         }
-	VertexP2ui                  :: #force_inline proc "c" (type: u32, value: u32)                                     {        impl_VertexP2ui(type, value)                                                   }
-	VertexP2uiv                 :: #force_inline proc "c" (type: u32, value: ^u32)                                    {        impl_VertexP2uiv(type, value)                                                  }
-	VertexP3ui                  :: #force_inline proc "c" (type: u32, value: u32)                                     {        impl_VertexP3ui(type, value)                                                   }
-	VertexP3uiv                 :: #force_inline proc "c" (type: u32, value: ^u32)                                    {        impl_VertexP3uiv(type, value)                                                  }
-	VertexP4ui                  :: #force_inline proc "c" (type: u32, value: u32)                                     {        impl_VertexP4ui(type, value)                                                   }
-	VertexP4uiv                 :: #force_inline proc "c" (type: u32, value: ^u32)                                    {        impl_VertexP4uiv(type, value)                                                  }
-	TexCoordP1ui                :: #force_inline proc "c" (type: u32, coords: u32)                                    {        impl_TexCoordP1ui(type, coords)                                                }
-	TexCoordP1uiv               :: #force_inline proc "c" (type: u32, coords: [^]u32)                                 {        impl_TexCoordP1uiv(type, coords)                                               }
-	TexCoordP2ui                :: #force_inline proc "c" (type: u32, coords: u32)                                    {        impl_TexCoordP2ui(type, coords)                                                }
-	TexCoordP2uiv               :: #force_inline proc "c" (type: u32, coords: [^]u32)                                 {        impl_TexCoordP2uiv(type, coords)                                               }
-	TexCoordP3ui                :: #force_inline proc "c" (type: u32, coords: u32)                                    {        impl_TexCoordP3ui(type, coords)                                                }
-	TexCoordP3uiv               :: #force_inline proc "c" (type: u32, coords: [^]u32)                                 {        impl_TexCoordP3uiv(type, coords)                                               }
-	TexCoordP4ui                :: #force_inline proc "c" (type: u32, coords: u32)                                    {        impl_TexCoordP4ui(type, coords)                                                }
-	TexCoordP4uiv               :: #force_inline proc "c" (type: u32, coords: [^]u32)                                 {        impl_TexCoordP4uiv(type, coords)                                               }
-	MultiTexCoordP1ui           :: #force_inline proc "c" (texture: u32, type: u32, coords: u32)                      {        impl_MultiTexCoordP1ui(texture, type, coords)                                  }
-	MultiTexCoordP1uiv          :: #force_inline proc "c" (texture: u32, type: u32, coords: [^]u32)                   {        impl_MultiTexCoordP1uiv(texture, type, coords)                                 }
-	MultiTexCoordP2ui           :: #force_inline proc "c" (texture: u32, type: u32, coords: u32)                      {        impl_MultiTexCoordP2ui(texture, type, coords)                                  }
-	MultiTexCoordP2uiv          :: #force_inline proc "c" (texture: u32, type: u32, coords: [^]u32)                   {        impl_MultiTexCoordP2uiv(texture, type, coords)                                 }
-	MultiTexCoordP3ui           :: #force_inline proc "c" (texture: u32, type: u32, coords: u32)                      {        impl_MultiTexCoordP3ui(texture, type, coords)                                  }
-	MultiTexCoordP3uiv          :: #force_inline proc "c" (texture: u32, type: u32, coords: [^]u32)                   {        impl_MultiTexCoordP3uiv(texture, type, coords)                                 }
-	MultiTexCoordP4ui           :: #force_inline proc "c" (texture: u32, type: u32, coords: u32)                      {        impl_MultiTexCoordP4ui(texture, type, coords)                                  }
-	MultiTexCoordP4uiv          :: #force_inline proc "c" (texture: u32, type: u32, coords: [^]u32)                   {        impl_MultiTexCoordP4uiv(texture, type, coords)                                 }
-	NormalP3ui                  :: #force_inline proc "c" (type: u32, coords: u32)                                    {        impl_NormalP3ui(type, coords)                                                  }
-	NormalP3uiv                 :: #force_inline proc "c" (type: u32, coords: [^]u32)                                 {        impl_NormalP3uiv(type, coords)                                                 }
-	ColorP3ui                   :: #force_inline proc "c" (type: u32, color: u32)                                     {        impl_ColorP3ui(type, color)                                                    }
-	ColorP3uiv                  :: #force_inline proc "c" (type: u32, color: ^u32)                                    {        impl_ColorP3uiv(type, color)                                                   }
-	ColorP4ui                   :: #force_inline proc "c" (type: u32, color: u32)                                     {        impl_ColorP4ui(type, color)                                                    }
-	ColorP4uiv                  :: #force_inline proc "c" (type: u32, color: ^u32)                                    {        impl_ColorP4uiv(type, color)                                                   }
-	SecondaryColorP3ui          :: #force_inline proc "c" (type: u32, color: u32)                                     {        impl_SecondaryColorP3ui(type, color)                                           }
-	SecondaryColorP3uiv         :: #force_inline proc "c" (type: u32, color: ^u32)                                    {        impl_SecondaryColorP3uiv(type, color)                                          }
+	BindFragDataLocationIndexed :: proc "c" (program: u32, colorNumber: u32, index: u32, name: cstring) {        impl_BindFragDataLocationIndexed(program, colorNumber, index, name)             }
+	GetFragDataIndex            :: proc "c" (program: u32, name: cstring) -> i32                        { ret := impl_GetFragDataIndex(program, name);                                return ret }
+	GenSamplers                 :: proc "c" (count: i32, samplers: [^]u32)                              {        impl_GenSamplers(count, samplers)                                               }
+	DeleteSamplers              :: proc "c" (count: i32, samplers: [^]u32)                              {        impl_DeleteSamplers(count, samplers)                                            }
+	IsSampler                   :: proc "c" (sampler: u32) -> bool                                      { ret := impl_IsSampler(sampler);                                             return ret }
+	BindSampler                 :: proc "c" (unit: u32, sampler: u32)                                   {        impl_BindSampler(unit, sampler)                                                 }
+	SamplerParameteri           :: proc "c" (sampler: u32, pname: u32, param: i32)                      {        impl_SamplerParameteri(sampler, pname, param)                                   }
+	SamplerParameteriv          :: proc "c" (sampler: u32, pname: u32, param: ^i32)                     {        impl_SamplerParameteriv(sampler, pname, param)                                  }
+	SamplerParameterf           :: proc "c" (sampler: u32, pname: u32, param: f32)                      {        impl_SamplerParameterf(sampler, pname, param)                                   }
+	SamplerParameterfv          :: proc "c" (sampler: u32, pname: u32, param: ^f32)                     {        impl_SamplerParameterfv(sampler, pname, param)                                  }
+	SamplerParameterIiv         :: proc "c" (sampler: u32, pname: u32, param: ^i32)                     {        impl_SamplerParameterIiv(sampler, pname, param)                                 }
+	SamplerParameterIuiv        :: proc "c" (sampler: u32, pname: u32, param: ^u32)                     {        impl_SamplerParameterIuiv(sampler, pname, param)                                }
+	GetSamplerParameteriv       :: proc "c" (sampler: u32, pname: u32, params: [^]i32)                  {        impl_GetSamplerParameteriv(sampler, pname, params)                              }
+	GetSamplerParameterIiv      :: proc "c" (sampler: u32, pname: u32, params: [^]i32)                  {        impl_GetSamplerParameterIiv(sampler, pname, params)                             }
+	GetSamplerParameterfv       :: proc "c" (sampler: u32, pname: u32, params: [^]f32)                  {        impl_GetSamplerParameterfv(sampler, pname, params)                              }
+	GetSamplerParameterIuiv     :: proc "c" (sampler: u32, pname: u32, params: [^]u32)                  {        impl_GetSamplerParameterIuiv(sampler, pname, params)                            }
+	QueryCounter                :: proc "c" (id: u32, target: u32)                                      {        impl_QueryCounter(id, target)                                                   }
+	GetQueryObjecti64v          :: proc "c" (id: u32, pname: u32, params: [^]i64)                       {        impl_GetQueryObjecti64v(id, pname, params)                                      }
+	GetQueryObjectui64v         :: proc "c" (id: u32, pname: u32, params: [^]u64)                       {        impl_GetQueryObjectui64v(id, pname, params)                                     }
+	VertexAttribDivisor         :: proc "c" (index: u32, divisor: u32)                                  {        impl_VertexAttribDivisor(index, divisor)                                        }
+	VertexAttribP1ui            :: proc "c" (index: u32, type: u32, normalized: bool, value: u32)       {        impl_VertexAttribP1ui(index, type, normalized, value)                          }
+	VertexAttribP1uiv           :: proc "c" (index: u32, type: u32, normalized: bool, value: ^u32)      {        impl_VertexAttribP1uiv(index, type, normalized, value)                         }
+	VertexAttribP2ui            :: proc "c" (index: u32, type: u32, normalized: bool, value: u32)       {        impl_VertexAttribP2ui(index, type, normalized, value)                          }
+	VertexAttribP2uiv           :: proc "c" (index: u32, type: u32, normalized: bool, value: ^u32)      {        impl_VertexAttribP2uiv(index, type, normalized, value)                         }
+	VertexAttribP3ui            :: proc "c" (index: u32, type: u32, normalized: bool, value: u32)       {        impl_VertexAttribP3ui(index, type, normalized, value)                          }
+	VertexAttribP3uiv           :: proc "c" (index: u32, type: u32, normalized: bool, value: ^u32)      {        impl_VertexAttribP3uiv(index, type, normalized, value)                         }
+	VertexAttribP4ui            :: proc "c" (index: u32, type: u32, normalized: bool, value: u32)       {        impl_VertexAttribP4ui(index, type, normalized, value)                          }
+	VertexAttribP4uiv           :: proc "c" (index: u32, type: u32, normalized: bool, value: ^u32)      {        impl_VertexAttribP4uiv(index, type, normalized, value)                         }
+	VertexP2ui                  :: proc "c" (type: u32, value: u32)                                     {        impl_VertexP2ui(type, value)                                                   }
+	VertexP2uiv                 :: proc "c" (type: u32, value: ^u32)                                    {        impl_VertexP2uiv(type, value)                                                  }
+	VertexP3ui                  :: proc "c" (type: u32, value: u32)                                     {        impl_VertexP3ui(type, value)                                                   }
+	VertexP3uiv                 :: proc "c" (type: u32, value: ^u32)                                    {        impl_VertexP3uiv(type, value)                                                  }
+	VertexP4ui                  :: proc "c" (type: u32, value: u32)                                     {        impl_VertexP4ui(type, value)                                                   }
+	VertexP4uiv                 :: proc "c" (type: u32, value: ^u32)                                    {        impl_VertexP4uiv(type, value)                                                  }
+	TexCoordP1ui                :: proc "c" (type: u32, coords: u32)                                    {        impl_TexCoordP1ui(type, coords)                                                }
+	TexCoordP1uiv               :: proc "c" (type: u32, coords: [^]u32)                                 {        impl_TexCoordP1uiv(type, coords)                                               }
+	TexCoordP2ui                :: proc "c" (type: u32, coords: u32)                                    {        impl_TexCoordP2ui(type, coords)                                                }
+	TexCoordP2uiv               :: proc "c" (type: u32, coords: [^]u32)                                 {        impl_TexCoordP2uiv(type, coords)                                               }
+	TexCoordP3ui                :: proc "c" (type: u32, coords: u32)                                    {        impl_TexCoordP3ui(type, coords)                                                }
+	TexCoordP3uiv               :: proc "c" (type: u32, coords: [^]u32)                                 {        impl_TexCoordP3uiv(type, coords)                                               }
+	TexCoordP4ui                :: proc "c" (type: u32, coords: u32)                                    {        impl_TexCoordP4ui(type, coords)                                                }
+	TexCoordP4uiv               :: proc "c" (type: u32, coords: [^]u32)                                 {        impl_TexCoordP4uiv(type, coords)                                               }
+	MultiTexCoordP1ui           :: proc "c" (texture: u32, type: u32, coords: u32)                      {        impl_MultiTexCoordP1ui(texture, type, coords)                                  }
+	MultiTexCoordP1uiv          :: proc "c" (texture: u32, type: u32, coords: [^]u32)                   {        impl_MultiTexCoordP1uiv(texture, type, coords)                                 }
+	MultiTexCoordP2ui           :: proc "c" (texture: u32, type: u32, coords: u32)                      {        impl_MultiTexCoordP2ui(texture, type, coords)                                  }
+	MultiTexCoordP2uiv          :: proc "c" (texture: u32, type: u32, coords: [^]u32)                   {        impl_MultiTexCoordP2uiv(texture, type, coords)                                 }
+	MultiTexCoordP3ui           :: proc "c" (texture: u32, type: u32, coords: u32)                      {        impl_MultiTexCoordP3ui(texture, type, coords)                                  }
+	MultiTexCoordP3uiv          :: proc "c" (texture: u32, type: u32, coords: [^]u32)                   {        impl_MultiTexCoordP3uiv(texture, type, coords)                                 }
+	MultiTexCoordP4ui           :: proc "c" (texture: u32, type: u32, coords: u32)                      {        impl_MultiTexCoordP4ui(texture, type, coords)                                  }
+	MultiTexCoordP4uiv          :: proc "c" (texture: u32, type: u32, coords: [^]u32)                   {        impl_MultiTexCoordP4uiv(texture, type, coords)                                 }
+	NormalP3ui                  :: proc "c" (type: u32, coords: u32)                                    {        impl_NormalP3ui(type, coords)                                                  }
+	NormalP3uiv                 :: proc "c" (type: u32, coords: [^]u32)                                 {        impl_NormalP3uiv(type, coords)                                                 }
+	ColorP3ui                   :: proc "c" (type: u32, color: u32)                                     {        impl_ColorP3ui(type, color)                                                    }
+	ColorP3uiv                  :: proc "c" (type: u32, color: ^u32)                                    {        impl_ColorP3uiv(type, color)                                                   }
+	ColorP4ui                   :: proc "c" (type: u32, color: u32)                                     {        impl_ColorP4ui(type, color)                                                    }
+	ColorP4uiv                  :: proc "c" (type: u32, color: ^u32)                                    {        impl_ColorP4uiv(type, color)                                                   }
+	SecondaryColorP3ui          :: proc "c" (type: u32, color: u32)                                     {        impl_SecondaryColorP3ui(type, color)                                           }
+	SecondaryColorP3uiv         :: proc "c" (type: u32, color: ^u32)                                    {        impl_SecondaryColorP3uiv(type, color)                                          }
 
 	// VERSION_4_0
-	MinSampleShading               :: #force_inline proc "c" (value: f32)                                                                         {        impl_MinSampleShading(value)                                                                        }
-	BlendEquationi                 :: #force_inline proc "c" (buf: u32, mode: u32)                                                                {        impl_BlendEquationi(buf, mode)                                                                      }
-	BlendEquationSeparatei         :: #force_inline proc "c" (buf: u32, modeRGB: u32, modeAlpha: u32)                                             {        impl_BlendEquationSeparatei(buf, modeRGB, modeAlpha)                                                }
-	BlendFunci                     :: #force_inline proc "c" (buf: u32, src: u32, dst: u32)                                                       {        impl_BlendFunci(buf, src, dst)                                                                      }
-	BlendFuncSeparatei             :: #force_inline proc "c" (buf: u32, srcRGB: u32, dstRGB: u32, srcAlpha: u32, dstAlpha: u32)                   {        impl_BlendFuncSeparatei(buf, srcRGB, dstRGB, srcAlpha, dstAlpha)                                    }
-	DrawArraysIndirect             :: #force_inline proc "c" (mode: u32, indirect: ^DrawArraysIndirectCommand)                                    {        impl_DrawArraysIndirect(mode, indirect)                                                             }
-	DrawElementsIndirect           :: #force_inline proc "c" (mode: u32, type: u32, indirect: ^DrawElementsIndirectCommand)                       {        impl_DrawElementsIndirect(mode, type, indirect)                                                    }
-	Uniform1d                      :: #force_inline proc "c" (location: i32, x: f64)                                                              {        impl_Uniform1d(location, x)                                                                         }
-	Uniform2d                      :: #force_inline proc "c" (location: i32, x: f64, y: f64)                                                      {        impl_Uniform2d(location, x, y)                                                                      }
-	Uniform3d                      :: #force_inline proc "c" (location: i32, x: f64, y: f64, z: f64)                                              {        impl_Uniform3d(location, x, y, z)                                                                   }
-	Uniform4d                      :: #force_inline proc "c" (location: i32, x: f64, y: f64, z: f64, w: f64)                                      {        impl_Uniform4d(location, x, y, z, w)                                                                }
-	Uniform1dv                     :: #force_inline proc "c" (location: i32, count: i32, value: [^]f64)                                          {        impl_Uniform1dv(location, count, value)                                                             }
-	Uniform2dv                     :: #force_inline proc "c" (location: i32, count: i32, value: [^]f64)                                          {        impl_Uniform2dv(location, count, value)                                                             }
-	Uniform3dv                     :: #force_inline proc "c" (location: i32, count: i32, value: [^]f64)                                          {        impl_Uniform3dv(location, count, value)                                                             }
-	Uniform4dv                     :: #force_inline proc "c" (location: i32, count: i32, value: [^]f64)                                          {        impl_Uniform4dv(location, count, value)                                                             }
-	UniformMatrix2dv               :: #force_inline proc "c" (location: i32, count: i32, transpose: bool, value: [^]f64)                       {        impl_UniformMatrix2dv(location, count, transpose, value)                                            }
-	UniformMatrix3dv               :: #force_inline proc "c" (location: i32, count: i32, transpose: bool, value: [^]f64)                       {        impl_UniformMatrix3dv(location, count, transpose, value)                                            }
-	UniformMatrix4dv               :: #force_inline proc "c" (location: i32, count: i32, transpose: bool, value: [^]f64)                       {        impl_UniformMatrix4dv(location, count, transpose, value)                                            }
-	UniformMatrix2x3dv             :: #force_inline proc "c" (location: i32, count: i32, transpose: bool, value: [^]f64)                       {        impl_UniformMatrix2x3dv(location, count, transpose, value)                                          }
-	UniformMatrix2x4dv             :: #force_inline proc "c" (location: i32, count: i32, transpose: bool, value: [^]f64)                       {        impl_UniformMatrix2x4dv(location, count, transpose, value)                                          }
-	UniformMatrix3x2dv             :: #force_inline proc "c" (location: i32, count: i32, transpose: bool, value: [^]f64)                       {        impl_UniformMatrix3x2dv(location, count, transpose, value)                                          }
-	UniformMatrix3x4dv             :: #force_inline proc "c" (location: i32, count: i32, transpose: bool, value: [^]f64)                       {        impl_UniformMatrix3x4dv(location, count, transpose, value)                                          }
-	UniformMatrix4x2dv             :: #force_inline proc "c" (location: i32, count: i32, transpose: bool, value: [^]f64)                       {        impl_UniformMatrix4x2dv(location, count, transpose, value)                                          }
-	UniformMatrix4x3dv             :: #force_inline proc "c" (location: i32, count: i32, transpose: bool, value: [^]f64)                       {        impl_UniformMatrix4x3dv(location, count, transpose, value)                                          }
-	GetUniformdv                   :: #force_inline proc "c" (program: u32, location: i32, params: [^]f64)                                        {        impl_GetUniformdv(program, location, params)                                                        }
-	GetSubroutineUniformLocation   :: #force_inline proc "c" (program: u32, shadertype: u32, name: cstring) -> i32                                { ret := impl_GetSubroutineUniformLocation(program, shadertype, name);                           return ret }
-	GetSubroutineIndex             :: #force_inline proc "c" (program: u32, shadertype: u32, name: cstring) -> u32                                { ret := impl_GetSubroutineIndex(program, shadertype, name);                                     return ret }
-	GetActiveSubroutineUniformiv   :: #force_inline proc "c" (program: u32, shadertype: u32, index: u32, pname: u32, values: [^]i32)              {        impl_GetActiveSubroutineUniformiv(program, shadertype, index, pname, values)                       }
-	GetActiveSubroutineUniformName :: #force_inline proc "c" (program: u32, shadertype: u32, index: u32, bufsize: i32, length: ^i32, name: [^]u8) {        impl_GetActiveSubroutineUniformName(program, shadertype, index, bufsize, length, name)             }
-	GetActiveSubroutineName        :: #force_inline proc "c" (program: u32, shadertype: u32, index: u32, bufsize: i32, length: ^i32, name: [^]u8) {        impl_GetActiveSubroutineName(program, shadertype, index, bufsize, length, name)                    }
-	UniformSubroutinesuiv          :: #force_inline proc "c" (shadertype: u32, count: i32, indices: [^]u32)                                         {        impl_UniformSubroutinesuiv(shadertype, count, indices)                                             }
-	GetUniformSubroutineuiv        :: #force_inline proc "c" (shadertype: u32, location: i32, params: [^]u32)                                     {        impl_GetUniformSubroutineuiv(shadertype, location, params)                                         }
-	GetProgramStageiv              :: #force_inline proc "c" (program: u32, shadertype: u32, pname: u32, values: [^]i32)                          {        impl_GetProgramStageiv(program, shadertype, pname, values)                                         }
-	PatchParameteri                :: #force_inline proc "c" (pname: u32, value: i32)                                                             {        impl_PatchParameteri(pname, value)                                                                  }
-	PatchParameterfv               :: #force_inline proc "c" (pname: u32, values: [^]f32)                                                         {        impl_PatchParameterfv(pname, values)                                                                }
-	BindTransformFeedback          :: #force_inline proc "c" (target: u32, id: u32)                                                               {        impl_BindTransformFeedback(target, id)                                                              }
-	DeleteTransformFeedbacks       :: #force_inline proc "c" (n: i32, ids: [^]u32)                                                                {        impl_DeleteTransformFeedbacks(n, ids)                                                               }
-	GenTransformFeedbacks          :: #force_inline proc "c" (n: i32, ids: [^]u32)                                                                {        impl_GenTransformFeedbacks(n, ids)                                                                  }
-	IsTransformFeedback            :: #force_inline proc "c" (id: u32) -> bool                                                                    { ret := impl_IsTransformFeedback(id);                                                            return ret }
-	PauseTransformFeedback         :: #force_inline proc "c" ()                                                                                   {        impl_PauseTransformFeedback()                                                                       }
-	ResumeTransformFeedback        :: #force_inline proc "c" ()                                                                                   {        impl_ResumeTransformFeedback()                                                                      }
-	DrawTransformFeedback          :: #force_inline proc "c" (mode: u32, id: u32)                                                                 {        impl_DrawTransformFeedback(mode, id)                                                                }
-	DrawTransformFeedbackStream    :: #force_inline proc "c" (mode: u32, id: u32, stream: u32)                                                    {        impl_DrawTransformFeedbackStream(mode, id, stream)                                                  }
-	BeginQueryIndexed              :: #force_inline proc "c" (target: u32, index: u32, id: u32)                                                   {        impl_BeginQueryIndexed(target, index, id)                                                           }
-	EndQueryIndexed                :: #force_inline proc "c" (target: u32, index: u32)                                                            {        impl_EndQueryIndexed(target, index)                                                                 }
-	GetQueryIndexediv              :: #force_inline proc "c" (target: u32, index: u32, pname: u32, params: [^]i32)                                {        impl_GetQueryIndexediv(target, index, pname, params)                                                }
+	MinSampleShading               :: proc "c" (value: f32)                                                                         {        impl_MinSampleShading(value)                                                                        }
+	BlendEquationi                 :: proc "c" (buf: u32, mode: u32)                                                                {        impl_BlendEquationi(buf, mode)                                                                      }
+	BlendEquationSeparatei         :: proc "c" (buf: u32, modeRGB: u32, modeAlpha: u32)                                             {        impl_BlendEquationSeparatei(buf, modeRGB, modeAlpha)                                                }
+	BlendFunci                     :: proc "c" (buf: u32, src: u32, dst: u32)                                                       {        impl_BlendFunci(buf, src, dst)                                                                      }
+	BlendFuncSeparatei             :: proc "c" (buf: u32, srcRGB: u32, dstRGB: u32, srcAlpha: u32, dstAlpha: u32)                   {        impl_BlendFuncSeparatei(buf, srcRGB, dstRGB, srcAlpha, dstAlpha)                                    }
+	DrawArraysIndirect             :: proc "c" (mode: u32, indirect: ^DrawArraysIndirectCommand)                                    {        impl_DrawArraysIndirect(mode, indirect)                                                             }
+	DrawElementsIndirect           :: proc "c" (mode: u32, type: u32, indirect: ^DrawElementsIndirectCommand)                       {        impl_DrawElementsIndirect(mode, type, indirect)                                                    }
+	Uniform1d                      :: proc "c" (location: i32, x: f64)                                                              {        impl_Uniform1d(location, x)                                                                         }
+	Uniform2d                      :: proc "c" (location: i32, x: f64, y: f64)                                                      {        impl_Uniform2d(location, x, y)                                                                      }
+	Uniform3d                      :: proc "c" (location: i32, x: f64, y: f64, z: f64)                                              {        impl_Uniform3d(location, x, y, z)                                                                   }
+	Uniform4d                      :: proc "c" (location: i32, x: f64, y: f64, z: f64, w: f64)                                      {        impl_Uniform4d(location, x, y, z, w)                                                                }
+	Uniform1dv                     :: proc "c" (location: i32, count: i32, value: [^]f64)                                          {        impl_Uniform1dv(location, count, value)                                                             }
+	Uniform2dv                     :: proc "c" (location: i32, count: i32, value: [^]f64)                                          {        impl_Uniform2dv(location, count, value)                                                             }
+	Uniform3dv                     :: proc "c" (location: i32, count: i32, value: [^]f64)                                          {        impl_Uniform3dv(location, count, value)                                                             }
+	Uniform4dv                     :: proc "c" (location: i32, count: i32, value: [^]f64)                                          {        impl_Uniform4dv(location, count, value)                                                             }
+	UniformMatrix2dv               :: proc "c" (location: i32, count: i32, transpose: bool, value: [^]f64)                       {        impl_UniformMatrix2dv(location, count, transpose, value)                                            }
+	UniformMatrix3dv               :: proc "c" (location: i32, count: i32, transpose: bool, value: [^]f64)                       {        impl_UniformMatrix3dv(location, count, transpose, value)                                            }
+	UniformMatrix4dv               :: proc "c" (location: i32, count: i32, transpose: bool, value: [^]f64)                       {        impl_UniformMatrix4dv(location, count, transpose, value)                                            }
+	UniformMatrix2x3dv             :: proc "c" (location: i32, count: i32, transpose: bool, value: [^]f64)                       {        impl_UniformMatrix2x3dv(location, count, transpose, value)                                          }
+	UniformMatrix2x4dv             :: proc "c" (location: i32, count: i32, transpose: bool, value: [^]f64)                       {        impl_UniformMatrix2x4dv(location, count, transpose, value)                                          }
+	UniformMatrix3x2dv             :: proc "c" (location: i32, count: i32, transpose: bool, value: [^]f64)                       {        impl_UniformMatrix3x2dv(location, count, transpose, value)                                          }
+	UniformMatrix3x4dv             :: proc "c" (location: i32, count: i32, transpose: bool, value: [^]f64)                       {        impl_UniformMatrix3x4dv(location, count, transpose, value)                                          }
+	UniformMatrix4x2dv             :: proc "c" (location: i32, count: i32, transpose: bool, value: [^]f64)                       {        impl_UniformMatrix4x2dv(location, count, transpose, value)                                          }
+	UniformMatrix4x3dv             :: proc "c" (location: i32, count: i32, transpose: bool, value: [^]f64)                       {        impl_UniformMatrix4x3dv(location, count, transpose, value)                                          }
+	GetUniformdv                   :: proc "c" (program: u32, location: i32, params: [^]f64)                                        {        impl_GetUniformdv(program, location, params)                                                        }
+	GetSubroutineUniformLocation   :: proc "c" (program: u32, shadertype: u32, name: cstring) -> i32                                { ret := impl_GetSubroutineUniformLocation(program, shadertype, name);                           return ret }
+	GetSubroutineIndex             :: proc "c" (program: u32, shadertype: u32, name: cstring) -> u32                                { ret := impl_GetSubroutineIndex(program, shadertype, name);                                     return ret }
+	GetActiveSubroutineUniformiv   :: proc "c" (program: u32, shadertype: u32, index: u32, pname: u32, values: [^]i32)              {        impl_GetActiveSubroutineUniformiv(program, shadertype, index, pname, values)                       }
+	GetActiveSubroutineUniformName :: proc "c" (program: u32, shadertype: u32, index: u32, bufsize: i32, length: ^i32, name: [^]u8) {        impl_GetActiveSubroutineUniformName(program, shadertype, index, bufsize, length, name)             }
+	GetActiveSubroutineName        :: proc "c" (program: u32, shadertype: u32, index: u32, bufsize: i32, length: ^i32, name: [^]u8) {        impl_GetActiveSubroutineName(program, shadertype, index, bufsize, length, name)                    }
+	UniformSubroutinesuiv          :: proc "c" (shadertype: u32, count: i32, indices: [^]u32)                                         {        impl_UniformSubroutinesuiv(shadertype, count, indices)                                             }
+	GetUniformSubroutineuiv        :: proc "c" (shadertype: u32, location: i32, params: [^]u32)                                     {        impl_GetUniformSubroutineuiv(shadertype, location, params)                                         }
+	GetProgramStageiv              :: proc "c" (program: u32, shadertype: u32, pname: u32, values: [^]i32)                          {        impl_GetProgramStageiv(program, shadertype, pname, values)                                         }
+	PatchParameteri                :: proc "c" (pname: u32, value: i32)                                                             {        impl_PatchParameteri(pname, value)                                                                  }
+	PatchParameterfv               :: proc "c" (pname: u32, values: [^]f32)                                                         {        impl_PatchParameterfv(pname, values)                                                                }
+	BindTransformFeedback          :: proc "c" (target: u32, id: u32)                                                               {        impl_BindTransformFeedback(target, id)                                                              }
+	DeleteTransformFeedbacks       :: proc "c" (n: i32, ids: [^]u32)                                                                {        impl_DeleteTransformFeedbacks(n, ids)                                                               }
+	GenTransformFeedbacks          :: proc "c" (n: i32, ids: [^]u32)                                                                {        impl_GenTransformFeedbacks(n, ids)                                                                  }
+	IsTransformFeedback            :: proc "c" (id: u32) -> bool                                                                    { ret := impl_IsTransformFeedback(id);                                                            return ret }
+	PauseTransformFeedback         :: proc "c" ()                                                                                   {        impl_PauseTransformFeedback()                                                                       }
+	ResumeTransformFeedback        :: proc "c" ()                                                                                   {        impl_ResumeTransformFeedback()                                                                      }
+	DrawTransformFeedback          :: proc "c" (mode: u32, id: u32)                                                                 {        impl_DrawTransformFeedback(mode, id)                                                                }
+	DrawTransformFeedbackStream    :: proc "c" (mode: u32, id: u32, stream: u32)                                                    {        impl_DrawTransformFeedbackStream(mode, id, stream)                                                  }
+	BeginQueryIndexed              :: proc "c" (target: u32, index: u32, id: u32)                                                   {        impl_BeginQueryIndexed(target, index, id)                                                           }
+	EndQueryIndexed                :: proc "c" (target: u32, index: u32)                                                            {        impl_EndQueryIndexed(target, index)                                                                 }
+	GetQueryIndexediv              :: proc "c" (target: u32, index: u32, pname: u32, params: [^]i32)                                {        impl_GetQueryIndexediv(target, index, pname, params)                                                }
 
 	// VERSION_4_1
-	ReleaseShaderCompiler     :: #force_inline proc "c" ()                                                                             {        impl_ReleaseShaderCompiler()                                                             }
-	ShaderBinary              :: #force_inline proc "c" (count: i32, shaders: ^u32, binaryformat: u32, binary: rawptr, length: i32)    {        impl_ShaderBinary(count, shaders, binaryformat, binary, length)                          }
-	GetShaderPrecisionFormat  :: #force_inline proc "c" (shadertype: u32, precisiontype: u32, range: ^i32, precision: ^i32)            {        impl_GetShaderPrecisionFormat(shadertype, precisiontype, range, precision)             }
-	DepthRangef               :: #force_inline proc "c" (n: f32, f: f32)                                                               {        impl_DepthRangef(n, f)                                                                   }
-	ClearDepthf               :: #force_inline proc "c" (d: f32)                                                                       {        impl_ClearDepthf(d)                                                                      }
-	GetProgramBinary          :: #force_inline proc "c" (program: u32, bufSize: i32, length: ^i32, binaryFormat: ^u32, binary: rawptr) {        impl_GetProgramBinary(program, bufSize, length, binaryFormat, binary)                    }
-	ProgramBinary             :: #force_inline proc "c" (program: u32, binaryFormat: u32, binary: rawptr, length: i32)                 {        impl_ProgramBinary(program, binaryFormat, binary, length)                                }
-	ProgramParameteri         :: #force_inline proc "c" (program: u32, pname: u32, value: i32)                                         {        impl_ProgramParameteri(program, pname, value)                                            }
-	UseProgramStages          :: #force_inline proc "c" (pipeline: u32, stages: u32, program: u32)                                     {        impl_UseProgramStages(pipeline, stages, program)                                         }
-	ActiveShaderProgram       :: #force_inline proc "c" (pipeline: u32, program: u32)                                                  {        impl_ActiveShaderProgram(pipeline, program)                                              }
-	CreateShaderProgramv      :: #force_inline proc "c" (type: u32, count: i32, strings: [^]cstring) -> u32                            { ret := impl_CreateShaderProgramv(type, count, strings);                             return ret }
-	BindProgramPipeline       :: #force_inline proc "c" (pipeline: u32)                                                                {        impl_BindProgramPipeline(pipeline)                                                       }
-	DeleteProgramPipelines    :: #force_inline proc "c" (n: i32, pipelines: [^]u32)                                                    {        impl_DeleteProgramPipelines(n, pipelines)                                                }
-	GenProgramPipelines       :: #force_inline proc "c" (n: i32, pipelines: [^]u32)                                                    {        impl_GenProgramPipelines(n, pipelines)                                                   }
-	IsProgramPipeline         :: #force_inline proc "c" (pipeline: u32) -> bool                                                        { ret := impl_IsProgramPipeline(pipeline);                                             return ret }
-	GetProgramPipelineiv      :: #force_inline proc "c" (pipeline: u32, pname: u32, params: [^]i32)                                    {        impl_GetProgramPipelineiv(pipeline, pname, params)                                       }
-	ProgramUniform1i          :: #force_inline proc "c" (program: u32, location: i32, v0: i32)                                         {        impl_ProgramUniform1i(program, location, v0)                                             }
-	ProgramUniform1iv         :: #force_inline proc "c" (program: u32, location: i32, count: i32, value: [^]i32)                      {        impl_ProgramUniform1iv(program, location, count, value)                                  }
-	ProgramUniform1f          :: #force_inline proc "c" (program: u32, location: i32, v0: f32)                                         {        impl_ProgramUniform1f(program, location, v0)                                             }
-	ProgramUniform1fv         :: #force_inline proc "c" (program: u32, location: i32, count: i32, value: [^]f32)                      {        impl_ProgramUniform1fv(program, location, count, value)                                  }
-	ProgramUniform1d          :: #force_inline proc "c" (program: u32, location: i32, v0: f64)                                         {        impl_ProgramUniform1d(program, location, v0)                                             }
-	ProgramUniform1dv         :: #force_inline proc "c" (program: u32, location: i32, count: i32, value: [^]f64)                      {        impl_ProgramUniform1dv(program, location, count, value)                                  }
-	ProgramUniform1ui         :: #force_inline proc "c" (program: u32, location: i32, v0: u32)                                         {        impl_ProgramUniform1ui(program, location, v0)                                            }
-	ProgramUniform1uiv        :: #force_inline proc "c" (program: u32, location: i32, count: i32, value: [^]u32)                      {        impl_ProgramUniform1uiv(program, location, count, value)                                 }
-	ProgramUniform2i          :: #force_inline proc "c" (program: u32, location: i32, v0: i32, v1: i32)                                {        impl_ProgramUniform2i(program, location, v0, v1)                                         }
-	ProgramUniform2iv         :: #force_inline proc "c" (program: u32, location: i32, count: i32, value: [^]i32)                       {        impl_ProgramUniform2iv(program, location, count, value)                                  }
-	ProgramUniform2f          :: #force_inline proc "c" (program: u32, location: i32, v0: f32, v1: f32)                                {        impl_ProgramUniform2f(program, location, v0, v1)                                         }
-	ProgramUniform2fv         :: #force_inline proc "c" (program: u32, location: i32, count: i32, value: [^]f32)                       {        impl_ProgramUniform2fv(program, location, count, value)                                  }
-	ProgramUniform2d          :: #force_inline proc "c" (program: u32, location: i32, v0: f64, v1: f64)                                {        impl_ProgramUniform2d(program, location, v0, v1)                                         }
-	ProgramUniform2dv         :: #force_inline proc "c" (program: u32, location: i32, count: i32, value: [^]f64)                       {        impl_ProgramUniform2dv(program, location, count, value)                                  }
-	ProgramUniform2ui         :: #force_inline proc "c" (program: u32, location: i32, v0: u32, v1: u32)                                {        impl_ProgramUniform2ui(program, location, v0, v1)                                        }
-	ProgramUniform2uiv        :: #force_inline proc "c" (program: u32, location: i32, count: i32, value: [^]u32)                       {        impl_ProgramUniform2uiv(program, location, count, value)                                 }
-	ProgramUniform3i          :: #force_inline proc "c" (program: u32, location: i32, v0: i32, v1: i32, v2: i32)                       {        impl_ProgramUniform3i(program, location, v0, v1, v2)                                     }
-	ProgramUniform3iv         :: #force_inline proc "c" (program: u32, location: i32, count: i32, value: [^]i32)                       {        impl_ProgramUniform3iv(program, location, count, value)                                  }
-	ProgramUniform3f          :: #force_inline proc "c" (program: u32, location: i32, v0: f32, v1: f32, v2: f32)                       {        impl_ProgramUniform3f(program, location, v0, v1, v2)                                     }
-	ProgramUniform3fv         :: #force_inline proc "c" (program: u32, location: i32, count: i32, value: [^]f32)                       {        impl_ProgramUniform3fv(program, location, count, value)                                  }
-	ProgramUniform3d          :: #force_inline proc "c" (program: u32, location: i32, v0: f64, v1: f64, v2: f64)                       {        impl_ProgramUniform3d(program, location, v0, v1, v2)                                     }
-	ProgramUniform3dv         :: #force_inline proc "c" (program: u32, location: i32, count: i32, value: [^]f64)                       {        impl_ProgramUniform3dv(program, location, count, value)                                  }
-	ProgramUniform3ui         :: #force_inline proc "c" (program: u32, location: i32, v0: u32, v1: u32, v2: u32)                       {        impl_ProgramUniform3ui(program, location, v0, v1, v2)                                    }
-	ProgramUniform3uiv        :: #force_inline proc "c" (program: u32, location: i32, count: i32, value: [^]u32)                       {        impl_ProgramUniform3uiv(program, location, count, value)                                 }
-	ProgramUniform4i          :: #force_inline proc "c" (program: u32, location: i32, v0: i32, v1: i32, v2: i32, v3: i32)              {        impl_ProgramUniform4i(program, location, v0, v1, v2, v3)                                 }
-	ProgramUniform4iv         :: #force_inline proc "c" (program: u32, location: i32, count: i32, value: [^]i32)                       {        impl_ProgramUniform4iv(program, location, count, value)                                  }
-	ProgramUniform4f          :: #force_inline proc "c" (program: u32, location: i32, v0: f32, v1: f32, v2: f32, v3: f32)              {        impl_ProgramUniform4f(program, location, v0, v1, v2, v3)                                 }
-	ProgramUniform4fv         :: #force_inline proc "c" (program: u32, location: i32, count: i32, value: [^]f32)                       {        impl_ProgramUniform4fv(program, location, count, value)                                  }
-	ProgramUniform4d          :: #force_inline proc "c" (program: u32, location: i32, v0: f64, v1: f64, v2: f64, v3: f64)              {        impl_ProgramUniform4d(program, location, v0, v1, v2, v3)                                 }
-	ProgramUniform4dv         :: #force_inline proc "c" (program: u32, location: i32, count: i32, value: [^]f64)                       {        impl_ProgramUniform4dv(program, location, count, value)                                  }
-	ProgramUniform4ui         :: #force_inline proc "c" (program: u32, location: i32, v0: u32, v1: u32, v2: u32, v3: u32)              {        impl_ProgramUniform4ui(program, location, v0, v1, v2, v3)                                }
-	ProgramUniform4uiv        :: #force_inline proc "c" (program: u32, location: i32, count: i32, value: [^]u32)                       {        impl_ProgramUniform4uiv(program, location, count, value)                                 }
-	ProgramUniformMatrix2fv   :: #force_inline proc "c" (program: u32, location: i32, count: i32, transpose: bool, value: [^]f32)  {        impl_ProgramUniformMatrix2fv(program, location, count, transpose, value)                 }
-	ProgramUniformMatrix3fv   :: #force_inline proc "c" (program: u32, location: i32, count: i32, transpose: bool, value: [^]f32)  {        impl_ProgramUniformMatrix3fv(program, location, count, transpose, value)                 }
-	ProgramUniformMatrix4fv   :: #force_inline proc "c" (program: u32, location: i32, count: i32, transpose: bool, value: [^]f32)  {        impl_ProgramUniformMatrix4fv(program, location, count, transpose, value)                 }
-	ProgramUniformMatrix2dv   :: #force_inline proc "c" (program: u32, location: i32, count: i32, transpose: bool, value: [^]f64)  {        impl_ProgramUniformMatrix2dv(program, location, count, transpose, value)                 }
-	ProgramUniformMatrix3dv   :: #force_inline proc "c" (program: u32, location: i32, count: i32, transpose: bool, value: [^]f64)  {        impl_ProgramUniformMatrix3dv(program, location, count, transpose, value)                 }
-	ProgramUniformMatrix4dv   :: #force_inline proc "c" (program: u32, location: i32, count: i32, transpose: bool, value: [^]f64)  {        impl_ProgramUniformMatrix4dv(program, location, count, transpose, value)                 }
-	ProgramUniformMatrix2x3fv :: #force_inline proc "c" (program: u32, location: i32, count: i32, transpose: bool, value: [^]f32)  {        impl_ProgramUniformMatrix2x3fv(program, location, count, transpose, value)               }
-	ProgramUniformMatrix3x2fv :: #force_inline proc "c" (program: u32, location: i32, count: i32, transpose: bool, value: [^]f32)  {        impl_ProgramUniformMatrix3x2fv(program, location, count, transpose, value)               }
-	ProgramUniformMatrix2x4fv :: #force_inline proc "c" (program: u32, location: i32, count: i32, transpose: bool, value: [^]f32)  {        impl_ProgramUniformMatrix2x4fv(program, location, count, transpose, value)               }
-	ProgramUniformMatrix4x2fv :: #force_inline proc "c" (program: u32, location: i32, count: i32, transpose: bool, value: [^]f32)  {        impl_ProgramUniformMatrix4x2fv(program, location, count, transpose, value)               }
-	ProgramUniformMatrix3x4fv :: #force_inline proc "c" (program: u32, location: i32, count: i32, transpose: bool, value: [^]f32)  {        impl_ProgramUniformMatrix3x4fv(program, location, count, transpose, value)               }
-	ProgramUniformMatrix4x3fv :: #force_inline proc "c" (program: u32, location: i32, count: i32, transpose: bool, value: [^]f32)  {        impl_ProgramUniformMatrix4x3fv(program, location, count, transpose, value)               }
-	ProgramUniformMatrix2x3dv :: #force_inline proc "c" (program: u32, location: i32, count: i32, transpose: bool, value: [^]f64)  {        impl_ProgramUniformMatrix2x3dv(program, location, count, transpose, value)               }
-	ProgramUniformMatrix3x2dv :: #force_inline proc "c" (program: u32, location: i32, count: i32, transpose: bool, value: [^]f64)  {        impl_ProgramUniformMatrix3x2dv(program, location, count, transpose, value)               }
-	ProgramUniformMatrix2x4dv :: #force_inline proc "c" (program: u32, location: i32, count: i32, transpose: bool, value: [^]f64)  {        impl_ProgramUniformMatrix2x4dv(program, location, count, transpose, value)               }
-	ProgramUniformMatrix4x2dv :: #force_inline proc "c" (program: u32, location: i32, count: i32, transpose: bool, value: [^]f64)  {        impl_ProgramUniformMatrix4x2dv(program, location, count, transpose, value)               }
-	ProgramUniformMatrix3x4dv :: #force_inline proc "c" (program: u32, location: i32, count: i32, transpose: bool, value: [^]f64)  {        impl_ProgramUniformMatrix3x4dv(program, location, count, transpose, value)               }
-	ProgramUniformMatrix4x3dv :: #force_inline proc "c" (program: u32, location: i32, count: i32, transpose: bool, value: [^]f64)  {        impl_ProgramUniformMatrix4x3dv(program, location, count, transpose, value)               }
-	ValidateProgramPipeline   :: #force_inline proc "c" (pipeline: u32)                                                                {        impl_ValidateProgramPipeline(pipeline)                                                   }
-	GetProgramPipelineInfoLog :: #force_inline proc "c" (pipeline: u32, bufSize: i32, length: ^i32, infoLog: [^]u8)                    {        impl_GetProgramPipelineInfoLog(pipeline, bufSize, length, infoLog)                       }
-	VertexAttribL1d           :: #force_inline proc "c" (index: u32, x: f64)                                                           {        impl_VertexAttribL1d(index, x)                                                           }
-	VertexAttribL2d           :: #force_inline proc "c" (index: u32, x: f64, y: f64)                                                   {        impl_VertexAttribL2d(index, x, y)                                                        }
-	VertexAttribL3d           :: #force_inline proc "c" (index: u32, x: f64, y: f64, z: f64)                                           {        impl_VertexAttribL3d(index, x, y, z)                                                     }
-	VertexAttribL4d           :: #force_inline proc "c" (index: u32, x: f64, y: f64, z: f64, w: f64)                                   {        impl_VertexAttribL4d(index, x, y, z, w)                                                  }
-	VertexAttribL1dv          :: #force_inline proc "c" (index: u32, v: ^f64)                                                       {        impl_VertexAttribL1dv(index, v)                                                          }
-	VertexAttribL2dv          :: #force_inline proc "c" (index: u32, v: ^[2]f64)                                                       {        impl_VertexAttribL2dv(index, v)                                                          }
-	VertexAttribL3dv          :: #force_inline proc "c" (index: u32, v: ^[3]f64)                                                       {        impl_VertexAttribL3dv(index, v)                                                          }
-	VertexAttribL4dv          :: #force_inline proc "c" (index: u32, v: ^[4]f64)                                                       {        impl_VertexAttribL4dv(index, v)                                                          }
-	VertexAttribLPointer      :: #force_inline proc "c" (index: u32, size: i32, type: u32, stride: i32, pointer: uintptr)               {        impl_VertexAttribLPointer(index, size, type, stride, pointer)                           }
-	GetVertexAttribLdv        :: #force_inline proc "c" (index: u32, pname: u32, params: [^]f64)                                       {        impl_GetVertexAttribLdv(index, pname, params)                                            }
-	ViewportArrayv            :: #force_inline proc "c" (first: u32, count: i32, v: [^]f32)                                            {        impl_ViewportArrayv(first, count, v)                                                     }
-	ViewportIndexedf          :: #force_inline proc "c" (index: u32, x: f32, y: f32, w: f32, h: f32)                                   {        impl_ViewportIndexedf(index, x, y, w, h)                                                 }
-	ViewportIndexedfv         :: #force_inline proc "c" (index: u32, v: ^[4]f32)                                                          {        impl_ViewportIndexedfv(index, v)                                                         }
-	ScissorArrayv             :: #force_inline proc "c" (first: u32, count: i32, v: [^]i32)                                            {        impl_ScissorArrayv(first, count, v)                                                      }
-	ScissorIndexed            :: #force_inline proc "c" (index: u32, left: i32, bottom: i32, width: i32, height: i32)                  {        impl_ScissorIndexed(index, left, bottom, width, height)                                  }
-	ScissorIndexedv           :: #force_inline proc "c" (index: u32, v: ^[4]i32)                                                          {        impl_ScissorIndexedv(index, v)                                                           }
-	DepthRangeArrayv          :: #force_inline proc "c" (first: u32, count: i32, v: [^]f64)                                            {        impl_DepthRangeArrayv(first, count, v)                                                   }
-	DepthRangeIndexed         :: #force_inline proc "c" (index: u32, n: f64, f: f64)                                                   {        impl_DepthRangeIndexed(index, n, f)                                                      }
-	GetFloati_v               :: #force_inline proc "c" (target: u32, index: u32, data: ^f32)                                          {        impl_GetFloati_v(target, index, data)                                                    }
-	GetDoublei_v              :: #force_inline proc "c" (target: u32, index: u32, data: ^f64)                                          {        impl_GetDoublei_v(target, index, data)                                                   }
+	ReleaseShaderCompiler     :: proc "c" ()                                                                             {        impl_ReleaseShaderCompiler()                                                             }
+	ShaderBinary              :: proc "c" (count: i32, shaders: ^u32, binaryformat: u32, binary: rawptr, length: i32)    {        impl_ShaderBinary(count, shaders, binaryformat, binary, length)                          }
+	GetShaderPrecisionFormat  :: proc "c" (shadertype: u32, precisiontype: u32, range: ^i32, precision: ^i32)            {        impl_GetShaderPrecisionFormat(shadertype, precisiontype, range, precision)             }
+	DepthRangef               :: proc "c" (n: f32, f: f32)                                                               {        impl_DepthRangef(n, f)                                                                   }
+	ClearDepthf               :: proc "c" (d: f32)                                                                       {        impl_ClearDepthf(d)                                                                      }
+	GetProgramBinary          :: proc "c" (program: u32, bufSize: i32, length: ^i32, binaryFormat: ^u32, binary: rawptr) {        impl_GetProgramBinary(program, bufSize, length, binaryFormat, binary)                    }
+	ProgramBinary             :: proc "c" (program: u32, binaryFormat: u32, binary: rawptr, length: i32)                 {        impl_ProgramBinary(program, binaryFormat, binary, length)                                }
+	ProgramParameteri         :: proc "c" (program: u32, pname: u32, value: i32)                                         {        impl_ProgramParameteri(program, pname, value)                                            }
+	UseProgramStages          :: proc "c" (pipeline: u32, stages: u32, program: u32)                                     {        impl_UseProgramStages(pipeline, stages, program)                                         }
+	ActiveShaderProgram       :: proc "c" (pipeline: u32, program: u32)                                                  {        impl_ActiveShaderProgram(pipeline, program)                                              }
+	CreateShaderProgramv      :: proc "c" (type: u32, count: i32, strings: [^]cstring) -> u32                            { ret := impl_CreateShaderProgramv(type, count, strings);                             return ret }
+	BindProgramPipeline       :: proc "c" (pipeline: u32)                                                                {        impl_BindProgramPipeline(pipeline)                                                       }
+	DeleteProgramPipelines    :: proc "c" (n: i32, pipelines: [^]u32)                                                    {        impl_DeleteProgramPipelines(n, pipelines)                                                }
+	GenProgramPipelines       :: proc "c" (n: i32, pipelines: [^]u32)                                                    {        impl_GenProgramPipelines(n, pipelines)                                                   }
+	IsProgramPipeline         :: proc "c" (pipeline: u32) -> bool                                                        { ret := impl_IsProgramPipeline(pipeline);                                             return ret }
+	GetProgramPipelineiv      :: proc "c" (pipeline: u32, pname: u32, params: [^]i32)                                    {        impl_GetProgramPipelineiv(pipeline, pname, params)                                       }
+	ProgramUniform1i          :: proc "c" (program: u32, location: i32, v0: i32)                                         {        impl_ProgramUniform1i(program, location, v0)                                             }
+	ProgramUniform1iv         :: proc "c" (program: u32, location: i32, count: i32, value: [^]i32)                      {        impl_ProgramUniform1iv(program, location, count, value)                                  }
+	ProgramUniform1f          :: proc "c" (program: u32, location: i32, v0: f32)                                         {        impl_ProgramUniform1f(program, location, v0)                                             }
+	ProgramUniform1fv         :: proc "c" (program: u32, location: i32, count: i32, value: [^]f32)                      {        impl_ProgramUniform1fv(program, location, count, value)                                  }
+	ProgramUniform1d          :: proc "c" (program: u32, location: i32, v0: f64)                                         {        impl_ProgramUniform1d(program, location, v0)                                             }
+	ProgramUniform1dv         :: proc "c" (program: u32, location: i32, count: i32, value: [^]f64)                      {        impl_ProgramUniform1dv(program, location, count, value)                                  }
+	ProgramUniform1ui         :: proc "c" (program: u32, location: i32, v0: u32)                                         {        impl_ProgramUniform1ui(program, location, v0)                                            }
+	ProgramUniform1uiv        :: proc "c" (program: u32, location: i32, count: i32, value: [^]u32)                      {        impl_ProgramUniform1uiv(program, location, count, value)                                 }
+	ProgramUniform2i          :: proc "c" (program: u32, location: i32, v0: i32, v1: i32)                                {        impl_ProgramUniform2i(program, location, v0, v1)                                         }
+	ProgramUniform2iv         :: proc "c" (program: u32, location: i32, count: i32, value: [^]i32)                       {        impl_ProgramUniform2iv(program, location, count, value)                                  }
+	ProgramUniform2f          :: proc "c" (program: u32, location: i32, v0: f32, v1: f32)                                {        impl_ProgramUniform2f(program, location, v0, v1)                                         }
+	ProgramUniform2fv         :: proc "c" (program: u32, location: i32, count: i32, value: [^]f32)                       {        impl_ProgramUniform2fv(program, location, count, value)                                  }
+	ProgramUniform2d          :: proc "c" (program: u32, location: i32, v0: f64, v1: f64)                                {        impl_ProgramUniform2d(program, location, v0, v1)                                         }
+	ProgramUniform2dv         :: proc "c" (program: u32, location: i32, count: i32, value: [^]f64)                       {        impl_ProgramUniform2dv(program, location, count, value)                                  }
+	ProgramUniform2ui         :: proc "c" (program: u32, location: i32, v0: u32, v1: u32)                                {        impl_ProgramUniform2ui(program, location, v0, v1)                                        }
+	ProgramUniform2uiv        :: proc "c" (program: u32, location: i32, count: i32, value: [^]u32)                       {        impl_ProgramUniform2uiv(program, location, count, value)                                 }
+	ProgramUniform3i          :: proc "c" (program: u32, location: i32, v0: i32, v1: i32, v2: i32)                       {        impl_ProgramUniform3i(program, location, v0, v1, v2)                                     }
+	ProgramUniform3iv         :: proc "c" (program: u32, location: i32, count: i32, value: [^]i32)                       {        impl_ProgramUniform3iv(program, location, count, value)                                  }
+	ProgramUniform3f          :: proc "c" (program: u32, location: i32, v0: f32, v1: f32, v2: f32)                       {        impl_ProgramUniform3f(program, location, v0, v1, v2)                                     }
+	ProgramUniform3fv         :: proc "c" (program: u32, location: i32, count: i32, value: [^]f32)                       {        impl_ProgramUniform3fv(program, location, count, value)                                  }
+	ProgramUniform3d          :: proc "c" (program: u32, location: i32, v0: f64, v1: f64, v2: f64)                       {        impl_ProgramUniform3d(program, location, v0, v1, v2)                                     }
+	ProgramUniform3dv         :: proc "c" (program: u32, location: i32, count: i32, value: [^]f64)                       {        impl_ProgramUniform3dv(program, location, count, value)                                  }
+	ProgramUniform3ui         :: proc "c" (program: u32, location: i32, v0: u32, v1: u32, v2: u32)                       {        impl_ProgramUniform3ui(program, location, v0, v1, v2)                                    }
+	ProgramUniform3uiv        :: proc "c" (program: u32, location: i32, count: i32, value: [^]u32)                       {        impl_ProgramUniform3uiv(program, location, count, value)                                 }
+	ProgramUniform4i          :: proc "c" (program: u32, location: i32, v0: i32, v1: i32, v2: i32, v3: i32)              {        impl_ProgramUniform4i(program, location, v0, v1, v2, v3)                                 }
+	ProgramUniform4iv         :: proc "c" (program: u32, location: i32, count: i32, value: [^]i32)                       {        impl_ProgramUniform4iv(program, location, count, value)                                  }
+	ProgramUniform4f          :: proc "c" (program: u32, location: i32, v0: f32, v1: f32, v2: f32, v3: f32)              {        impl_ProgramUniform4f(program, location, v0, v1, v2, v3)                                 }
+	ProgramUniform4fv         :: proc "c" (program: u32, location: i32, count: i32, value: [^]f32)                       {        impl_ProgramUniform4fv(program, location, count, value)                                  }
+	ProgramUniform4d          :: proc "c" (program: u32, location: i32, v0: f64, v1: f64, v2: f64, v3: f64)              {        impl_ProgramUniform4d(program, location, v0, v1, v2, v3)                                 }
+	ProgramUniform4dv         :: proc "c" (program: u32, location: i32, count: i32, value: [^]f64)                       {        impl_ProgramUniform4dv(program, location, count, value)                                  }
+	ProgramUniform4ui         :: proc "c" (program: u32, location: i32, v0: u32, v1: u32, v2: u32, v3: u32)              {        impl_ProgramUniform4ui(program, location, v0, v1, v2, v3)                                }
+	ProgramUniform4uiv        :: proc "c" (program: u32, location: i32, count: i32, value: [^]u32)                       {        impl_ProgramUniform4uiv(program, location, count, value)                                 }
+	ProgramUniformMatrix2fv   :: proc "c" (program: u32, location: i32, count: i32, transpose: bool, value: [^]f32)  {        impl_ProgramUniformMatrix2fv(program, location, count, transpose, value)                 }
+	ProgramUniformMatrix3fv   :: proc "c" (program: u32, location: i32, count: i32, transpose: bool, value: [^]f32)  {        impl_ProgramUniformMatrix3fv(program, location, count, transpose, value)                 }
+	ProgramUniformMatrix4fv   :: proc "c" (program: u32, location: i32, count: i32, transpose: bool, value: [^]f32)  {        impl_ProgramUniformMatrix4fv(program, location, count, transpose, value)                 }
+	ProgramUniformMatrix2dv   :: proc "c" (program: u32, location: i32, count: i32, transpose: bool, value: [^]f64)  {        impl_ProgramUniformMatrix2dv(program, location, count, transpose, value)                 }
+	ProgramUniformMatrix3dv   :: proc "c" (program: u32, location: i32, count: i32, transpose: bool, value: [^]f64)  {        impl_ProgramUniformMatrix3dv(program, location, count, transpose, value)                 }
+	ProgramUniformMatrix4dv   :: proc "c" (program: u32, location: i32, count: i32, transpose: bool, value: [^]f64)  {        impl_ProgramUniformMatrix4dv(program, location, count, transpose, value)                 }
+	ProgramUniformMatrix2x3fv :: proc "c" (program: u32, location: i32, count: i32, transpose: bool, value: [^]f32)  {        impl_ProgramUniformMatrix2x3fv(program, location, count, transpose, value)               }
+	ProgramUniformMatrix3x2fv :: proc "c" (program: u32, location: i32, count: i32, transpose: bool, value: [^]f32)  {        impl_ProgramUniformMatrix3x2fv(program, location, count, transpose, value)               }
+	ProgramUniformMatrix2x4fv :: proc "c" (program: u32, location: i32, count: i32, transpose: bool, value: [^]f32)  {        impl_ProgramUniformMatrix2x4fv(program, location, count, transpose, value)               }
+	ProgramUniformMatrix4x2fv :: proc "c" (program: u32, location: i32, count: i32, transpose: bool, value: [^]f32)  {        impl_ProgramUniformMatrix4x2fv(program, location, count, transpose, value)               }
+	ProgramUniformMatrix3x4fv :: proc "c" (program: u32, location: i32, count: i32, transpose: bool, value: [^]f32)  {        impl_ProgramUniformMatrix3x4fv(program, location, count, transpose, value)               }
+	ProgramUniformMatrix4x3fv :: proc "c" (program: u32, location: i32, count: i32, transpose: bool, value: [^]f32)  {        impl_ProgramUniformMatrix4x3fv(program, location, count, transpose, value)               }
+	ProgramUniformMatrix2x3dv :: proc "c" (program: u32, location: i32, count: i32, transpose: bool, value: [^]f64)  {        impl_ProgramUniformMatrix2x3dv(program, location, count, transpose, value)               }
+	ProgramUniformMatrix3x2dv :: proc "c" (program: u32, location: i32, count: i32, transpose: bool, value: [^]f64)  {        impl_ProgramUniformMatrix3x2dv(program, location, count, transpose, value)               }
+	ProgramUniformMatrix2x4dv :: proc "c" (program: u32, location: i32, count: i32, transpose: bool, value: [^]f64)  {        impl_ProgramUniformMatrix2x4dv(program, location, count, transpose, value)               }
+	ProgramUniformMatrix4x2dv :: proc "c" (program: u32, location: i32, count: i32, transpose: bool, value: [^]f64)  {        impl_ProgramUniformMatrix4x2dv(program, location, count, transpose, value)               }
+	ProgramUniformMatrix3x4dv :: proc "c" (program: u32, location: i32, count: i32, transpose: bool, value: [^]f64)  {        impl_ProgramUniformMatrix3x4dv(program, location, count, transpose, value)               }
+	ProgramUniformMatrix4x3dv :: proc "c" (program: u32, location: i32, count: i32, transpose: bool, value: [^]f64)  {        impl_ProgramUniformMatrix4x3dv(program, location, count, transpose, value)               }
+	ValidateProgramPipeline   :: proc "c" (pipeline: u32)                                                                {        impl_ValidateProgramPipeline(pipeline)                                                   }
+	GetProgramPipelineInfoLog :: proc "c" (pipeline: u32, bufSize: i32, length: ^i32, infoLog: [^]u8)                    {        impl_GetProgramPipelineInfoLog(pipeline, bufSize, length, infoLog)                       }
+	VertexAttribL1d           :: proc "c" (index: u32, x: f64)                                                           {        impl_VertexAttribL1d(index, x)                                                           }
+	VertexAttribL2d           :: proc "c" (index: u32, x: f64, y: f64)                                                   {        impl_VertexAttribL2d(index, x, y)                                                        }
+	VertexAttribL3d           :: proc "c" (index: u32, x: f64, y: f64, z: f64)                                           {        impl_VertexAttribL3d(index, x, y, z)                                                     }
+	VertexAttribL4d           :: proc "c" (index: u32, x: f64, y: f64, z: f64, w: f64)                                   {        impl_VertexAttribL4d(index, x, y, z, w)                                                  }
+	VertexAttribL1dv          :: proc "c" (index: u32, v: ^f64)                                                       {        impl_VertexAttribL1dv(index, v)                                                          }
+	VertexAttribL2dv          :: proc "c" (index: u32, v: ^[2]f64)                                                       {        impl_VertexAttribL2dv(index, v)                                                          }
+	VertexAttribL3dv          :: proc "c" (index: u32, v: ^[3]f64)                                                       {        impl_VertexAttribL3dv(index, v)                                                          }
+	VertexAttribL4dv          :: proc "c" (index: u32, v: ^[4]f64)                                                       {        impl_VertexAttribL4dv(index, v)                                                          }
+	VertexAttribLPointer      :: proc "c" (index: u32, size: i32, type: u32, stride: i32, pointer: uintptr)               {        impl_VertexAttribLPointer(index, size, type, stride, pointer)                           }
+	GetVertexAttribLdv        :: proc "c" (index: u32, pname: u32, params: [^]f64)                                       {        impl_GetVertexAttribLdv(index, pname, params)                                            }
+	ViewportArrayv            :: proc "c" (first: u32, count: i32, v: [^]f32)                                            {        impl_ViewportArrayv(first, count, v)                                                     }
+	ViewportIndexedf          :: proc "c" (index: u32, x: f32, y: f32, w: f32, h: f32)                                   {        impl_ViewportIndexedf(index, x, y, w, h)                                                 }
+	ViewportIndexedfv         :: proc "c" (index: u32, v: ^[4]f32)                                                          {        impl_ViewportIndexedfv(index, v)                                                         }
+	ScissorArrayv             :: proc "c" (first: u32, count: i32, v: [^]i32)                                            {        impl_ScissorArrayv(first, count, v)                                                      }
+	ScissorIndexed            :: proc "c" (index: u32, left: i32, bottom: i32, width: i32, height: i32)                  {        impl_ScissorIndexed(index, left, bottom, width, height)                                  }
+	ScissorIndexedv           :: proc "c" (index: u32, v: ^[4]i32)                                                          {        impl_ScissorIndexedv(index, v)                                                           }
+	DepthRangeArrayv          :: proc "c" (first: u32, count: i32, v: [^]f64)                                            {        impl_DepthRangeArrayv(first, count, v)                                                   }
+	DepthRangeIndexed         :: proc "c" (index: u32, n: f64, f: f64)                                                   {        impl_DepthRangeIndexed(index, n, f)                                                      }
+	GetFloati_v               :: proc "c" (target: u32, index: u32, data: ^f32)                                          {        impl_GetFloati_v(target, index, data)                                                    }
+	GetDoublei_v              :: proc "c" (target: u32, index: u32, data: ^f64)                                          {        impl_GetDoublei_v(target, index, data)                                                   }
 
 	// VERSION_4_2
-	DrawArraysInstancedBaseInstance             :: #force_inline proc "c" (mode: u32, first: i32, count: i32, instancecount: i32, baseinstance: u32)                                   { impl_DrawArraysInstancedBaseInstance(mode, first, count, instancecount, baseinstance)                                  }
-	DrawElementsInstancedBaseInstance           :: #force_inline proc "c" (mode: u32, count: i32, type: u32, indices: rawptr, instancecount: i32, baseinstance: u32)                   { impl_DrawElementsInstancedBaseInstance(mode, count, type, indices, instancecount, baseinstance)                       }
-	DrawElementsInstancedBaseVertexBaseInstance :: #force_inline proc "c" (mode: u32, count: i32, type: u32, indices: rawptr, instancecount: i32, basevertex: i32, baseinstance: u32)  { impl_DrawElementsInstancedBaseVertexBaseInstance(mode, count, type, indices, instancecount, basevertex, baseinstance) }
-	GetInternalformativ                         :: #force_inline proc "c" (target: u32, internalformat: u32, pname: u32, bufSize: i32, params: [^]i32)                                 { impl_GetInternalformativ(target, internalformat, pname, bufSize, params)                                               }
-	GetActiveAtomicCounterBufferiv              :: #force_inline proc "c" (program: u32, bufferIndex: u32, pname: u32, params: [^]i32)                                                 { impl_GetActiveAtomicCounterBufferiv(program, bufferIndex, pname, params)                                               }
-	BindImageTexture                            :: #force_inline proc "c" (unit: u32, texture: u32, level: i32, layered: bool, layer: i32, access: u32, format: u32)                     { impl_BindImageTexture(unit, texture, level, layered, layer, access, format)                                            }
-	MemoryBarrier                               :: #force_inline proc "c" (barriers: u32)                                                                                              { impl_MemoryBarrier(barriers)                                                                                           }
-	TexStorage1D                                :: #force_inline proc "c" (target: u32, levels: i32, internalformat: u32, width: i32)                                                  { impl_TexStorage1D(target, levels, internalformat, width)                                                               }
-	TexStorage2D                                :: #force_inline proc "c" (target: u32, levels: i32, internalformat: u32, width: i32, height: i32)                                     { impl_TexStorage2D(target, levels, internalformat, width, height)                                                       }
-	TexStorage3D                                :: #force_inline proc "c" (target: u32, levels: i32, internalformat: u32, width: i32, height: i32, depth: i32)                         { impl_TexStorage3D(target, levels, internalformat, width, height, depth)                                                }
-	DrawTransformFeedbackInstanced              :: #force_inline proc "c" (mode: u32, id: u32, instancecount: i32)                                                                     { impl_DrawTransformFeedbackInstanced(mode, id, instancecount)                                                           }
-	DrawTransformFeedbackStreamInstanced        :: #force_inline proc "c" (mode: u32, id: u32, stream: u32, instancecount: i32)                                                        { impl_DrawTransformFeedbackStreamInstanced(mode, id, stream, instancecount)                                             }
+	DrawArraysInstancedBaseInstance             :: proc "c" (mode: u32, first: i32, count: i32, instancecount: i32, baseinstance: u32)                                   { impl_DrawArraysInstancedBaseInstance(mode, first, count, instancecount, baseinstance)                                  }
+	DrawElementsInstancedBaseInstance           :: proc "c" (mode: u32, count: i32, type: u32, indices: rawptr, instancecount: i32, baseinstance: u32)                   { impl_DrawElementsInstancedBaseInstance(mode, count, type, indices, instancecount, baseinstance)                       }
+	DrawElementsInstancedBaseVertexBaseInstance :: proc "c" (mode: u32, count: i32, type: u32, indices: rawptr, instancecount: i32, basevertex: i32, baseinstance: u32)  { impl_DrawElementsInstancedBaseVertexBaseInstance(mode, count, type, indices, instancecount, basevertex, baseinstance) }
+	GetInternalformativ                         :: proc "c" (target: u32, internalformat: u32, pname: u32, bufSize: i32, params: [^]i32)                                 { impl_GetInternalformativ(target, internalformat, pname, bufSize, params)                                               }
+	GetActiveAtomicCounterBufferiv              :: proc "c" (program: u32, bufferIndex: u32, pname: u32, params: [^]i32)                                                 { impl_GetActiveAtomicCounterBufferiv(program, bufferIndex, pname, params)                                               }
+	BindImageTexture                            :: proc "c" (unit: u32, texture: u32, level: i32, layered: bool, layer: i32, access: u32, format: u32)                     { impl_BindImageTexture(unit, texture, level, layered, layer, access, format)                                            }
+	MemoryBarrier                               :: proc "c" (barriers: u32)                                                                                              { impl_MemoryBarrier(barriers)                                                                                           }
+	TexStorage1D                                :: proc "c" (target: u32, levels: i32, internalformat: u32, width: i32)                                                  { impl_TexStorage1D(target, levels, internalformat, width)                                                               }
+	TexStorage2D                                :: proc "c" (target: u32, levels: i32, internalformat: u32, width: i32, height: i32)                                     { impl_TexStorage2D(target, levels, internalformat, width, height)                                                       }
+	TexStorage3D                                :: proc "c" (target: u32, levels: i32, internalformat: u32, width: i32, height: i32, depth: i32)                         { impl_TexStorage3D(target, levels, internalformat, width, height, depth)                                                }
+	DrawTransformFeedbackInstanced              :: proc "c" (mode: u32, id: u32, instancecount: i32)                                                                     { impl_DrawTransformFeedbackInstanced(mode, id, instancecount)                                                           }
+	DrawTransformFeedbackStreamInstanced        :: proc "c" (mode: u32, id: u32, stream: u32, instancecount: i32)                                                        { impl_DrawTransformFeedbackStreamInstanced(mode, id, stream, instancecount)                                             }
 
 	// VERSION_4_3
-	ClearBufferData                 :: #force_inline proc "c" (target: u32, internalformat: u32, format: u32, type: u32, data: rawptr)                                                                                                                                   {        impl_ClearBufferData(target, internalformat, format, type, data)                                                                                                }
-	ClearBufferSubData              :: #force_inline proc "c" (target: u32, internalformat: u32, offset: int, size: int, format: u32, type: u32, data: rawptr)                                                                                                           {        impl_ClearBufferSubData(target, internalformat, offset, size, format, type, data)                                                                               }
-	DispatchCompute                 :: #force_inline proc "c" (num_groups_x: u32, num_groups_y: u32, num_groups_z: u32)                                                                                                                                                  {        impl_DispatchCompute(num_groups_x, num_groups_y, num_groups_z)                                                                                                   }
-	DispatchComputeIndirect         :: #force_inline proc "c" (indirect: ^DispatchIndirectCommand)                                                                                                                                                                       {        impl_DispatchComputeIndirect(indirect)                                                                                                                           }
-	CopyImageSubData                :: #force_inline proc "c" (srcName: u32, srcTarget: u32, srcLevel: i32, srcX: i32, srcY: i32, srcZ: i32, dstName: u32, dstTarget: u32, dstLevel: i32, dstX: i32, dstY: i32, dstZ: i32, srcWidth: i32, srcHeight: i32, srcDepth: i32) {        impl_CopyImageSubData(srcName, srcTarget, srcLevel, srcX, srcY, srcZ, dstName, dstTarget, dstLevel, dstX, dstY, dstZ, srcWidth, srcHeight, srcDepth)             }
-	FramebufferParameteri           :: #force_inline proc "c" (target: u32, pname: u32, param: i32)                                                                                                                                                                      {        impl_FramebufferParameteri(target, pname, param)                                                                                                                 }
-	GetFramebufferParameteriv       :: #force_inline proc "c" (target: u32, pname: u32, params: [^]i32)                                                                                                                                                                  {        impl_GetFramebufferParameteriv(target, pname, params)                                                                                                            }
-	GetInternalformati64v           :: #force_inline proc "c" (target: u32, internalformat: u32, pname: u32, bufSize: i32, params: [^]i64)                                                                                                                               {        impl_GetInternalformati64v(target, internalformat, pname, bufSize, params)                                                                                       }
-	InvalidateTexSubImage           :: #force_inline proc "c" (texture: u32, level: i32, xoffset: i32, yoffset: i32, zoffset: i32, width: i32, height: i32, depth: i32)                                                                                                  {        impl_InvalidateTexSubImage(texture, level, xoffset, yoffset, zoffset, width, height, depth)                                                                      }
-	InvalidateTexImage              :: #force_inline proc "c" (texture: u32, level: i32)                                                                                                                                                                                 {        impl_InvalidateTexImage(texture, level)                                                                                                                          }
-	InvalidateBufferSubData         :: #force_inline proc "c" (buffer: u32, offset: int, length: int)                                                                                                                                                                    {        impl_InvalidateBufferSubData(buffer, offset, length)                                                                                                             }
-	InvalidateBufferData            :: #force_inline proc "c" (buffer: u32)                                                                                                                                                                                              {        impl_InvalidateBufferData(buffer)                                                                                                                                }
-	InvalidateFramebuffer           :: #force_inline proc "c" (target: u32, numAttachments: i32, attachments: [^]u32)                                                                                                                                                    {        impl_InvalidateFramebuffer(target, numAttachments, attachments)                                                                                                  }
-	InvalidateSubFramebuffer        :: #force_inline proc "c" (target: u32, numAttachments: i32, attachments: [^]u32, x: i32, y: i32, width: i32, height: i32)                                                                                                           {        impl_InvalidateSubFramebuffer(target, numAttachments, attachments, x, y, width, height)                                                                          }
-	MultiDrawArraysIndirect         :: #force_inline proc "c" (mode: u32, indirect: [^]DrawArraysIndirectCommand, drawcount: i32, stride: i32)                                                                                                                           {        impl_MultiDrawArraysIndirect(mode, indirect, drawcount, stride)                                                                                                  }
-	MultiDrawElementsIndirect       :: #force_inline proc "c" (mode: u32, type: u32, indirect: [^]DrawElementsIndirectCommand, drawcount: i32, stride: i32)                                                                                                              {        impl_MultiDrawElementsIndirect(mode, type, indirect, drawcount, stride)                                                                                         }
-	GetProgramInterfaceiv           :: #force_inline proc "c" (program: u32, programInterface: u32, pname: u32, params: [^]i32)                                                                                                                                          {        impl_GetProgramInterfaceiv(program, programInterface, pname, params)                                                                                             }
-	GetProgramResourceIndex         :: #force_inline proc "c" (program: u32, programInterface: u32, name: cstring) -> u32                                                                                                                                                { ret := impl_GetProgramResourceIndex(program, programInterface, name) ;                                                                                       return ret }
-	GetProgramResourceName          :: #force_inline proc "c" (program: u32, programInterface: u32, index: u32, bufSize: i32, length: ^i32, name: [^]u8)                                                                                                                 {        impl_GetProgramResourceName(program, programInterface, index, bufSize, length, name)                                                                             }
-	GetProgramResourceiv            :: #force_inline proc "c" (program: u32, programInterface: u32, index: u32, propCount: i32, props: [^]u32, bufSize: i32, length: ^i32, params: [^]i32)                                                                               {        impl_GetProgramResourceiv(program, programInterface, index, propCount, props, bufSize, length, params)                                                           }
-	GetProgramResourceLocation      :: #force_inline proc "c" (program: u32, programInterface: u32, name: cstring) -> i32                                                                                                                                                { ret := impl_GetProgramResourceLocation(program, programInterface, name);                                                                                     return ret }
-	GetProgramResourceLocationIndex :: #force_inline proc "c" (program: u32, programInterface: u32, name: cstring) -> i32                                                                                                                                                { ret := impl_GetProgramResourceLocationIndex(program, programInterface, name);                                                                                return ret }
-	ShaderStorageBlockBinding       :: #force_inline proc "c" (program: u32, storageBlockIndex: u32, storageBlockBinding: u32)                                                                                                                                           {        impl_ShaderStorageBlockBinding(program, storageBlockIndex, storageBlockBinding)                                                                                  }
-	TexBufferRange                  :: #force_inline proc "c" (target: u32, internalformat: u32, buffer: u32, offset: int, size: int)                                                                                                                                    {        impl_TexBufferRange(target, internalformat, buffer, offset, size)                                                                                                }
-	TexStorage2DMultisample         :: #force_inline proc "c" (target: u32, samples: i32, internalformat: u32, width: i32, height: i32, fixedsamplelocations: bool)                                                                                                      {        impl_TexStorage2DMultisample(target, samples, internalformat, width, height, fixedsamplelocations)                                                               }
-	TexStorage3DMultisample         :: #force_inline proc "c" (target: u32, samples: i32, internalformat: u32, width: i32, height: i32, depth: i32, fixedsamplelocations: bool)                                                                                          {        impl_TexStorage3DMultisample(target, samples, internalformat, width, height, depth, fixedsamplelocations)                                                        }
-	TextureView                     :: #force_inline proc "c" (texture: u32, target: u32, origtexture: u32, internalformat: u32, minlevel: u32, numlevels: u32, minlayer: u32, numlayers: u32)                                                                           {        impl_TextureView(texture, target, origtexture, internalformat, minlevel, numlevels, minlayer, numlayers)                                                         }
-	BindVertexBuffer                :: #force_inline proc "c" (bindingindex: u32, buffer: u32, offset: int, stride: i32)                                                                                                                                                 {        impl_BindVertexBuffer(bindingindex, buffer, offset, stride)                                                                                                      }
-	VertexAttribFormat              :: #force_inline proc "c" (attribindex: u32, size: i32, type: u32, normalized: bool, relativeoffset: u32)                                                                                                                            {        impl_VertexAttribFormat(attribindex, size, type, normalized, relativeoffset)                                                                                    }
-	VertexAttribIFormat             :: #force_inline proc "c" (attribindex: u32, size: i32, type: u32, relativeoffset: u32)                                                                                                                                              {        impl_VertexAttribIFormat(attribindex, size, type, relativeoffset)                                                                                               }
-	VertexAttribLFormat             :: #force_inline proc "c" (attribindex: u32, size: i32, type: u32, relativeoffset: u32)                                                                                                                                              {        impl_VertexAttribLFormat(attribindex, size, type, relativeoffset)                                                                                               }
-	VertexAttribBinding             :: #force_inline proc "c" (attribindex: u32, bindingindex: u32)                                                                                                                                                                      {        impl_VertexAttribBinding(attribindex, bindingindex)                                                                                                              }
-	VertexBindingDivisor            :: #force_inline proc "c" (bindingindex: u32, divisor: u32)                                                                                                                                                                          {        impl_VertexBindingDivisor(bindingindex, divisor)                                                                                                                 }
-	DebugMessageControl             :: #force_inline proc "c" (source: u32, type: u32, severity: u32, count: i32, ids: [^]u32, enabled: bool)                                                                                                                            {        impl_DebugMessageControl(source, type, severity, count, ids, enabled)                                                                                           }
-	DebugMessageInsert              :: #force_inline proc "c" (source: u32, type: u32, id: u32, severity: u32, length: i32, buf: ^u8)                                                                                                                                    {        impl_DebugMessageInsert(source, type, id, severity, length, buf)                                                                                                }
-	DebugMessageCallback            :: #force_inline proc "c" (callback: debug_proc_t, userParam: rawptr)                                                                                                                                                                {        impl_DebugMessageCallback(callback, userParam)                                                                                                                   }
-	GetDebugMessageLog              :: #force_inline proc "c" (count: u32, bufSize: i32, sources: [^]u32, types: [^]u32, ids: [^]u32, severities: [^]u32, lengths: [^]i32, messageLog: [^]u8) -> u32                                                                     { ret := impl_GetDebugMessageLog(count, bufSize, sources, types, ids, severities, lengths, messageLog);                                                        return ret }
-	PushDebugGroup                  :: #force_inline proc "c" (source: u32, id: u32, length: i32, message: cstring)                                                                                                                                                      {        impl_PushDebugGroup(source, id, length, message)                                                                                                                 }
-	PopDebugGroup                   :: #force_inline proc "c" ()                                                                                                                                                                                                         {        impl_PopDebugGroup()                                                                                                                                             }
-	ObjectLabel                     :: #force_inline proc "c" (identifier: u32, name: u32, length: i32, label: [^]u8)                                                                                                                                                    {        impl_ObjectLabel(identifier, name, length, label)                                                                                                                }
-	GetObjectLabel                  :: #force_inline proc "c" (identifier: u32, name: u32, bufSize: i32, length: ^i32, label: [^]u8)                                                                                                                                     {        impl_GetObjectLabel(identifier, name, bufSize, length, label)                                                                                                    }
-	ObjectPtrLabel                  :: #force_inline proc "c" (ptr: rawptr, length: i32, label: [^]u8)                                                                                                                                                                   {        impl_ObjectPtrLabel(ptr, length, label)                                                                                                                          }
-	GetObjectPtrLabel               :: #force_inline proc "c" (ptr: rawptr, bufSize: i32, length: ^i32, label: [^]u8)                                                                                                                                                    {        impl_GetObjectPtrLabel(ptr, bufSize, length, label)                                                                                                              }
+	ClearBufferData                 :: proc "c" (target: u32, internalformat: u32, format: u32, type: u32, data: rawptr)                                                                                                                                   {        impl_ClearBufferData(target, internalformat, format, type, data)                                                                                                }
+	ClearBufferSubData              :: proc "c" (target: u32, internalformat: u32, offset: int, size: int, format: u32, type: u32, data: rawptr)                                                                                                           {        impl_ClearBufferSubData(target, internalformat, offset, size, format, type, data)                                                                               }
+	DispatchCompute                 :: proc "c" (num_groups_x: u32, num_groups_y: u32, num_groups_z: u32)                                                                                                                                                  {        impl_DispatchCompute(num_groups_x, num_groups_y, num_groups_z)                                                                                                   }
+	DispatchComputeIndirect         :: proc "c" (indirect: ^DispatchIndirectCommand)                                                                                                                                                                       {        impl_DispatchComputeIndirect(indirect)                                                                                                                           }
+	CopyImageSubData                :: proc "c" (srcName: u32, srcTarget: u32, srcLevel: i32, srcX: i32, srcY: i32, srcZ: i32, dstName: u32, dstTarget: u32, dstLevel: i32, dstX: i32, dstY: i32, dstZ: i32, srcWidth: i32, srcHeight: i32, srcDepth: i32) {        impl_CopyImageSubData(srcName, srcTarget, srcLevel, srcX, srcY, srcZ, dstName, dstTarget, dstLevel, dstX, dstY, dstZ, srcWidth, srcHeight, srcDepth)             }
+	FramebufferParameteri           :: proc "c" (target: u32, pname: u32, param: i32)                                                                                                                                                                      {        impl_FramebufferParameteri(target, pname, param)                                                                                                                 }
+	GetFramebufferParameteriv       :: proc "c" (target: u32, pname: u32, params: [^]i32)                                                                                                                                                                  {        impl_GetFramebufferParameteriv(target, pname, params)                                                                                                            }
+	GetInternalformati64v           :: proc "c" (target: u32, internalformat: u32, pname: u32, bufSize: i32, params: [^]i64)                                                                                                                               {        impl_GetInternalformati64v(target, internalformat, pname, bufSize, params)                                                                                       }
+	InvalidateTexSubImage           :: proc "c" (texture: u32, level: i32, xoffset: i32, yoffset: i32, zoffset: i32, width: i32, height: i32, depth: i32)                                                                                                  {        impl_InvalidateTexSubImage(texture, level, xoffset, yoffset, zoffset, width, height, depth)                                                                      }
+	InvalidateTexImage              :: proc "c" (texture: u32, level: i32)                                                                                                                                                                                 {        impl_InvalidateTexImage(texture, level)                                                                                                                          }
+	InvalidateBufferSubData         :: proc "c" (buffer: u32, offset: int, length: int)                                                                                                                                                                    {        impl_InvalidateBufferSubData(buffer, offset, length)                                                                                                             }
+	InvalidateBufferData            :: proc "c" (buffer: u32)                                                                                                                                                                                              {        impl_InvalidateBufferData(buffer)                                                                                                                                }
+	InvalidateFramebuffer           :: proc "c" (target: u32, numAttachments: i32, attachments: [^]u32)                                                                                                                                                    {        impl_InvalidateFramebuffer(target, numAttachments, attachments)                                                                                                  }
+	InvalidateSubFramebuffer        :: proc "c" (target: u32, numAttachments: i32, attachments: [^]u32, x: i32, y: i32, width: i32, height: i32)                                                                                                           {        impl_InvalidateSubFramebuffer(target, numAttachments, attachments, x, y, width, height)                                                                          }
+	MultiDrawArraysIndirect         :: proc "c" (mode: u32, indirect: [^]DrawArraysIndirectCommand, drawcount: i32, stride: i32)                                                                                                                           {        impl_MultiDrawArraysIndirect(mode, indirect, drawcount, stride)                                                                                                  }
+	MultiDrawElementsIndirect       :: proc "c" (mode: u32, type: u32, indirect: [^]DrawElementsIndirectCommand, drawcount: i32, stride: i32)                                                                                                              {        impl_MultiDrawElementsIndirect(mode, type, indirect, drawcount, stride)                                                                                         }
+	GetProgramInterfaceiv           :: proc "c" (program: u32, programInterface: u32, pname: u32, params: [^]i32)                                                                                                                                          {        impl_GetProgramInterfaceiv(program, programInterface, pname, params)                                                                                             }
+	GetProgramResourceIndex         :: proc "c" (program: u32, programInterface: u32, name: cstring) -> u32                                                                                                                                                { ret := impl_GetProgramResourceIndex(program, programInterface, name) ;                                                                                       return ret }
+	GetProgramResourceName          :: proc "c" (program: u32, programInterface: u32, index: u32, bufSize: i32, length: ^i32, name: [^]u8)                                                                                                                 {        impl_GetProgramResourceName(program, programInterface, index, bufSize, length, name)                                                                             }
+	GetProgramResourceiv            :: proc "c" (program: u32, programInterface: u32, index: u32, propCount: i32, props: [^]u32, bufSize: i32, length: ^i32, params: [^]i32)                                                                               {        impl_GetProgramResourceiv(program, programInterface, index, propCount, props, bufSize, length, params)                                                           }
+	GetProgramResourceLocation      :: proc "c" (program: u32, programInterface: u32, name: cstring) -> i32                                                                                                                                                { ret := impl_GetProgramResourceLocation(program, programInterface, name);                                                                                     return ret }
+	GetProgramResourceLocationIndex :: proc "c" (program: u32, programInterface: u32, name: cstring) -> i32                                                                                                                                                { ret := impl_GetProgramResourceLocationIndex(program, programInterface, name);                                                                                return ret }
+	ShaderStorageBlockBinding       :: proc "c" (program: u32, storageBlockIndex: u32, storageBlockBinding: u32)                                                                                                                                           {        impl_ShaderStorageBlockBinding(program, storageBlockIndex, storageBlockBinding)                                                                                  }
+	TexBufferRange                  :: proc "c" (target: u32, internalformat: u32, buffer: u32, offset: int, size: int)                                                                                                                                    {        impl_TexBufferRange(target, internalformat, buffer, offset, size)                                                                                                }
+	TexStorage2DMultisample         :: proc "c" (target: u32, samples: i32, internalformat: u32, width: i32, height: i32, fixedsamplelocations: bool)                                                                                                      {        impl_TexStorage2DMultisample(target, samples, internalformat, width, height, fixedsamplelocations)                                                               }
+	TexStorage3DMultisample         :: proc "c" (target: u32, samples: i32, internalformat: u32, width: i32, height: i32, depth: i32, fixedsamplelocations: bool)                                                                                          {        impl_TexStorage3DMultisample(target, samples, internalformat, width, height, depth, fixedsamplelocations)                                                        }
+	TextureView                     :: proc "c" (texture: u32, target: u32, origtexture: u32, internalformat: u32, minlevel: u32, numlevels: u32, minlayer: u32, numlayers: u32)                                                                           {        impl_TextureView(texture, target, origtexture, internalformat, minlevel, numlevels, minlayer, numlayers)                                                         }
+	BindVertexBuffer                :: proc "c" (bindingindex: u32, buffer: u32, offset: int, stride: i32)                                                                                                                                                 {        impl_BindVertexBuffer(bindingindex, buffer, offset, stride)                                                                                                      }
+	VertexAttribFormat              :: proc "c" (attribindex: u32, size: i32, type: u32, normalized: bool, relativeoffset: u32)                                                                                                                            {        impl_VertexAttribFormat(attribindex, size, type, normalized, relativeoffset)                                                                                    }
+	VertexAttribIFormat             :: proc "c" (attribindex: u32, size: i32, type: u32, relativeoffset: u32)                                                                                                                                              {        impl_VertexAttribIFormat(attribindex, size, type, relativeoffset)                                                                                               }
+	VertexAttribLFormat             :: proc "c" (attribindex: u32, size: i32, type: u32, relativeoffset: u32)                                                                                                                                              {        impl_VertexAttribLFormat(attribindex, size, type, relativeoffset)                                                                                               }
+	VertexAttribBinding             :: proc "c" (attribindex: u32, bindingindex: u32)                                                                                                                                                                      {        impl_VertexAttribBinding(attribindex, bindingindex)                                                                                                              }
+	VertexBindingDivisor            :: proc "c" (bindingindex: u32, divisor: u32)                                                                                                                                                                          {        impl_VertexBindingDivisor(bindingindex, divisor)                                                                                                                 }
+	DebugMessageControl             :: proc "c" (source: u32, type: u32, severity: u32, count: i32, ids: [^]u32, enabled: bool)                                                                                                                            {        impl_DebugMessageControl(source, type, severity, count, ids, enabled)                                                                                           }
+	DebugMessageInsert              :: proc "c" (source: u32, type: u32, id: u32, severity: u32, length: i32, buf: ^u8)                                                                                                                                    {        impl_DebugMessageInsert(source, type, id, severity, length, buf)                                                                                                }
+	DebugMessageCallback            :: proc "c" (callback: debug_proc_t, userParam: rawptr)                                                                                                                                                                {        impl_DebugMessageCallback(callback, userParam)                                                                                                                   }
+	GetDebugMessageLog              :: proc "c" (count: u32, bufSize: i32, sources: [^]u32, types: [^]u32, ids: [^]u32, severities: [^]u32, lengths: [^]i32, messageLog: [^]u8) -> u32                                                                     { ret := impl_GetDebugMessageLog(count, bufSize, sources, types, ids, severities, lengths, messageLog);                                                        return ret }
+	PushDebugGroup                  :: proc "c" (source: u32, id: u32, length: i32, message: cstring)                                                                                                                                                      {        impl_PushDebugGroup(source, id, length, message)                                                                                                                 }
+	PopDebugGroup                   :: proc "c" ()                                                                                                                                                                                                         {        impl_PopDebugGroup()                                                                                                                                             }
+	ObjectLabel                     :: proc "c" (identifier: u32, name: u32, length: i32, label: [^]u8)                                                                                                                                                    {        impl_ObjectLabel(identifier, name, length, label)                                                                                                                }
+	GetObjectLabel                  :: proc "c" (identifier: u32, name: u32, bufSize: i32, length: ^i32, label: [^]u8)                                                                                                                                     {        impl_GetObjectLabel(identifier, name, bufSize, length, label)                                                                                                    }
+	ObjectPtrLabel                  :: proc "c" (ptr: rawptr, length: i32, label: [^]u8)                                                                                                                                                                   {        impl_ObjectPtrLabel(ptr, length, label)                                                                                                                          }
+	GetObjectPtrLabel               :: proc "c" (ptr: rawptr, bufSize: i32, length: ^i32, label: [^]u8)                                                                                                                                                    {        impl_GetObjectPtrLabel(ptr, bufSize, length, label)                                                                                                              }
 
 	// VERSION_4_4
-	BufferStorage     :: #force_inline proc "c" (target: u32, size: int, data: rawptr, flags: u32)                                                                                              { impl_BufferStorage(target, size, data, flags)                                                              }
-	ClearTexImage     :: #force_inline proc "c" (texture: u32, level: i32, format: u32, type: u32, data: rawptr)                                                                                { impl_ClearTexImage(texture, level, format, type, data)                                                     }
-	ClearTexSubImage  :: #force_inline proc "c" (texture: u32, level: i32, xoffset: i32, yoffset: i32, zoffset: i32, width: i32, height: i32, depth: i32, format: u32, type: u32, data: rawptr) { impl_ClearTexSubImage(texture, level, xoffset, yoffset, zoffset, width, height, depth, format, type, data) }
-	BindBuffersBase   :: #force_inline proc "c" (target: u32, first: u32, count: i32, buffers: [^]u32)                                                                                          { impl_BindBuffersBase(target, first, count, buffers)                                                        }
-	BindBuffersRange  :: #force_inline proc "c" (target: u32, first: u32, count: i32, buffers: [^]u32, offsets: [^]uintptr, sizes: [^]int)                                                      { impl_BindBuffersRange(target, first, count, buffers, offsets, sizes)                                       }
-	BindTextures      :: #force_inline proc "c" (first: u32, count: i32, textures: [^]u32)                                                                                                      { impl_BindTextures(first, count, textures)                                                                  }
-	BindSamplers      :: #force_inline proc "c" (first: u32, count: i32, samplers: [^]u32)                                                                                                      { impl_BindSamplers(first, count, samplers)                                                                  }
-	BindImageTextures :: #force_inline proc "c" (first: u32, count: i32, textures: [^]u32)                                                                                                      { impl_BindImageTextures(first, count, textures)                                                             }
-	BindVertexBuffers :: #force_inline proc "c" (first: u32, count: i32, buffers: [^]u32, offsets: [^]uintptr, strides: [^]i32)                                                                 { impl_BindVertexBuffers(first, count, buffers, offsets, strides)                                            }
+	BufferStorage     :: proc "c" (target: u32, size: int, data: rawptr, flags: u32)                                                                                              { impl_BufferStorage(target, size, data, flags)                                                              }
+	ClearTexImage     :: proc "c" (texture: u32, level: i32, format: u32, type: u32, data: rawptr)                                                                                { impl_ClearTexImage(texture, level, format, type, data)                                                     }
+	ClearTexSubImage  :: proc "c" (texture: u32, level: i32, xoffset: i32, yoffset: i32, zoffset: i32, width: i32, height: i32, depth: i32, format: u32, type: u32, data: rawptr) { impl_ClearTexSubImage(texture, level, xoffset, yoffset, zoffset, width, height, depth, format, type, data) }
+	BindBuffersBase   :: proc "c" (target: u32, first: u32, count: i32, buffers: [^]u32)                                                                                          { impl_BindBuffersBase(target, first, count, buffers)                                                        }
+	BindBuffersRange  :: proc "c" (target: u32, first: u32, count: i32, buffers: [^]u32, offsets: [^]uintptr, sizes: [^]int)                                                      { impl_BindBuffersRange(target, first, count, buffers, offsets, sizes)                                       }
+	BindTextures      :: proc "c" (first: u32, count: i32, textures: [^]u32)                                                                                                      { impl_BindTextures(first, count, textures)                                                                  }
+	BindSamplers      :: proc "c" (first: u32, count: i32, samplers: [^]u32)                                                                                                      { impl_BindSamplers(first, count, samplers)                                                                  }
+	BindImageTextures :: proc "c" (first: u32, count: i32, textures: [^]u32)                                                                                                      { impl_BindImageTextures(first, count, textures)                                                             }
+	BindVertexBuffers :: proc "c" (first: u32, count: i32, buffers: [^]u32, offsets: [^]uintptr, strides: [^]i32)                                                                 { impl_BindVertexBuffers(first, count, buffers, offsets, strides)                                            }
 
 	// VERSION_4_5
-	ClipControl                              :: #force_inline proc "c" (origin: u32, depth: u32)                                                                                                                                            {        impl_ClipControl(origin, depth)                                                                                                               }
-	CreateTransformFeedbacks                 :: #force_inline proc "c" (n: i32, ids: [^]u32)                                                                                                                                                {        impl_CreateTransformFeedbacks(n, ids)                                                                                                         }
-	TransformFeedbackBufferBase              :: #force_inline proc "c" (xfb: u32, index: u32, buffer: u32)                                                                                                                                  {        impl_TransformFeedbackBufferBase(xfb, index, buffer)                                                                                          }
-	TransformFeedbackBufferRange             :: #force_inline proc "c" (xfb: u32, index: u32, buffer: u32, offset: int, size: int)                                                                                                          {        impl_TransformFeedbackBufferRange(xfb, index, buffer, offset, size)                                                                           }
-	GetTransformFeedbackiv                   :: #force_inline proc "c" (xfb: u32, pname: u32, param: ^i32)                                                                                                                                  {        impl_GetTransformFeedbackiv(xfb, pname, param)                                                                                                }
-	GetTransformFeedbacki_v                  :: #force_inline proc "c" (xfb: u32, pname: u32, index: u32, param: ^i32)                                                                                                                      {        impl_GetTransformFeedbacki_v(xfb, pname, index, param)                                                                                        }
-	GetTransformFeedbacki64_v                :: #force_inline proc "c" (xfb: u32, pname: u32, index: u32, param: ^i64)                                                                                                                      {        impl_GetTransformFeedbacki64_v(xfb, pname, index, param)                                                                                      }
-	CreateBuffers                            :: #force_inline proc "c" (n: i32, buffers: [^]u32)                                                                                                                                            {        impl_CreateBuffers(n, buffers)                                                                                                                }
-	NamedBufferStorage                       :: #force_inline proc "c" (buffer: u32, size: int, data: rawptr, flags: u32)                                                                                                                   {        impl_NamedBufferStorage(buffer, size, data, flags)                                                                                            }
-	NamedBufferData                          :: #force_inline proc "c" (buffer: u32, size: int, data: rawptr, usage: u32)                                                                                                                   {        impl_NamedBufferData(buffer, size, data, usage)                                                                                               }
-	NamedBufferSubData                       :: #force_inline proc "c" (buffer: u32, offset: int, size: int, data: rawptr)                                                                                                                  {        impl_NamedBufferSubData(buffer, offset, size, data)                                                                                           }
-	CopyNamedBufferSubData                   :: #force_inline proc "c" (readBuffer: u32, writeBuffer: u32, readOffset: int, writeOffset: int, size: int)                                                                                    {        impl_CopyNamedBufferSubData(readBuffer, writeBuffer, readOffset, writeOffset, size)                                                           }
-	ClearNamedBufferData                     :: #force_inline proc "c" (buffer: u32, internalformat: u32, format: u32, type: u32, data: rawptr)                                                                                             {        impl_ClearNamedBufferData(buffer, internalformat, format, type, data)                                                                        }
-	ClearNamedBufferSubData                  :: #force_inline proc "c" (buffer: u32, internalformat: u32, offset: int, size: int, format: u32, type: u32, data: rawptr)                                                                     {        impl_ClearNamedBufferSubData(buffer, internalformat, offset, size, format, type, data)                                                       }
-	MapNamedBuffer                           :: #force_inline proc "c" (buffer: u32, access: u32) -> rawptr                                                                                                                                 { ret := impl_MapNamedBuffer(buffer, access);                                                                                               return ret }
-	MapNamedBufferRange                      :: #force_inline proc "c" (buffer: u32, offset: int, length: int, access: u32) -> rawptr                                                                                                       { ret := impl_MapNamedBufferRange(buffer, offset, length, access);                                                                          return ret }
-	UnmapNamedBuffer                         :: #force_inline proc "c" (buffer: u32) -> bool                                                                                                                                                { ret := impl_UnmapNamedBuffer(buffer);                                                                                                     return ret }
-	FlushMappedNamedBufferRange              :: #force_inline proc "c" (buffer: u32, offset: int, length: int)                                                                                                                              {        impl_FlushMappedNamedBufferRange(buffer, offset, length)                                                                                      }
-	GetNamedBufferParameteriv                :: #force_inline proc "c" (buffer: u32, pname: u32, params: [^]i32)                                                                                                                            {        impl_GetNamedBufferParameteriv(buffer, pname, params)                                                                                         }
-	GetNamedBufferParameteri64v              :: #force_inline proc "c" (buffer: u32, pname: u32, params: [^]i64)                                                                                                                            {        impl_GetNamedBufferParameteri64v(buffer, pname, params)                                                                                       }
-	GetNamedBufferPointerv                   :: #force_inline proc "c" (buffer: u32, pname: u32, params: [^]rawptr)                                                                                                                         {        impl_GetNamedBufferPointerv(buffer, pname, params)                                                                                            }
-	GetNamedBufferSubData                    :: #force_inline proc "c" (buffer: u32, offset: int, size: int, data: rawptr)                                                                                                                  {        impl_GetNamedBufferSubData(buffer, offset, size, data)                                                                                        }
-	CreateFramebuffers                       :: #force_inline proc "c" (n: i32, framebuffers: [^]u32)                                                                                                                                       {        impl_CreateFramebuffers(n, framebuffers)                                                                                                      }
-	NamedFramebufferRenderbuffer             :: #force_inline proc "c" (framebuffer: u32, attachment: u32, renderbuffertarget: u32, renderbuffer: u32)                                                                                      {        impl_NamedFramebufferRenderbuffer(framebuffer, attachment, renderbuffertarget, renderbuffer)                                                  }
-	NamedFramebufferParameteri               :: #force_inline proc "c" (framebuffer: u32, pname: u32, param: i32)                                                                                                                           {        impl_NamedFramebufferParameteri(framebuffer, pname, param)                                                                                    }
-	NamedFramebufferTexture                  :: #force_inline proc "c" (framebuffer: u32, attachment: u32, texture: u32, level: i32)                                                                                                        {        impl_NamedFramebufferTexture(framebuffer, attachment, texture, level)                                                                         }
-	NamedFramebufferTextureLayer             :: #force_inline proc "c" (framebuffer: u32, attachment: u32, texture: u32, level: i32, layer: i32)                                                                                            {        impl_NamedFramebufferTextureLayer(framebuffer, attachment, texture, level, layer)                                                             }
-	NamedFramebufferDrawBuffer               :: #force_inline proc "c" (framebuffer: u32, buf: u32)                                                                                                                                         {        impl_NamedFramebufferDrawBuffer(framebuffer, buf)                                                                                             }
-	NamedFramebufferDrawBuffers              :: #force_inline proc "c" (framebuffer: u32, n: i32, bufs: [^]u32)                                                                                                                             {        impl_NamedFramebufferDrawBuffers(framebuffer, n, bufs)                                                                                        }
-	NamedFramebufferReadBuffer               :: #force_inline proc "c" (framebuffer: u32, src: u32)                                                                                                                                         {        impl_NamedFramebufferReadBuffer(framebuffer, src)                                                                                             }
-	InvalidateNamedFramebufferData           :: #force_inline proc "c" (framebuffer: u32, numAttachments: i32, attachments: [^]u32)                                                                                                           {        impl_InvalidateNamedFramebufferData(framebuffer, numAttachments, attachments)                                                                 }
-	InvalidateNamedFramebufferSubData        :: #force_inline proc "c" (framebuffer: u32, numAttachments: i32, attachments: [^]u32, x: i32, y: i32, width: i32, height: i32)                                                                  {        impl_InvalidateNamedFramebufferSubData(framebuffer, numAttachments, attachments, x, y, width, height)                                         }
-	ClearNamedFramebufferiv                  :: #force_inline proc "c" (framebuffer: u32, buffer: u32, drawbuffer: i32, value: ^i32)                                                                                                        {        impl_ClearNamedFramebufferiv(framebuffer, buffer, drawbuffer, value)                                                                          }
-	ClearNamedFramebufferuiv                 :: #force_inline proc "c" (framebuffer: u32, buffer: u32, drawbuffer: i32, value: ^u32)                                                                                                        {        impl_ClearNamedFramebufferuiv(framebuffer, buffer, drawbuffer, value)                                                                         }
-	ClearNamedFramebufferfv                  :: #force_inline proc "c" (framebuffer: u32, buffer: u32, drawbuffer: i32, value: ^f32)                                                                                                        {        impl_ClearNamedFramebufferfv(framebuffer, buffer, drawbuffer, value)                                                                          }
-	ClearNamedFramebufferfi                  :: #force_inline proc "c" (framebuffer: u32, buffer: u32, drawbuffer: i32, depth: f32, stencil: i32)                                                                                           {        impl_ClearNamedFramebufferfi(framebuffer, buffer, drawbuffer, depth, stencil)                                                                 }
-	BlitNamedFramebuffer                     :: #force_inline proc "c" (readFramebuffer: u32, drawFramebuffer: u32, srcX0: i32, srcY0: i32, srcX1: i32, srcY1: i32, dstX0: i32, dstY0: i32, dstX1: i32, dstY1: i32, mask: u32, filter: u32) {        impl_BlitNamedFramebuffer(readFramebuffer, drawFramebuffer, srcX0, srcY0, srcX1, srcY1, dstX0, dstY0, dstX1, dstY1, mask, filter)             }
-	CheckNamedFramebufferStatus              :: #force_inline proc "c" (framebuffer: u32, target: u32) -> u32                                                                                                                               { ret := impl_CheckNamedFramebufferStatus(framebuffer, target);                                                                             return ret }
-	GetNamedFramebufferParameteriv           :: #force_inline proc "c" (framebuffer: u32, pname: u32, param: ^i32)                                                                                                                          {        impl_GetNamedFramebufferParameteriv(framebuffer, pname, param)                                                                                }
-	GetNamedFramebufferAttachmentParameteriv :: #force_inline proc "c" (framebuffer: u32, attachment: u32, pname: u32, params: [^]i32)                                                                                                      {        impl_GetNamedFramebufferAttachmentParameteriv(framebuffer, attachment, pname, params)                                                         }
-	CreateRenderbuffers                      :: #force_inline proc "c" (n: i32, renderbuffers: [^]u32)                                                                                                                                      {        impl_CreateRenderbuffers(n, renderbuffers)                                                                                                    }
-	NamedRenderbufferStorage                 :: #force_inline proc "c" (renderbuffer: u32, internalformat: u32, width: i32, height: i32)                                                                                                    {        impl_NamedRenderbufferStorage(renderbuffer, internalformat, width, height)                                                                    }
-	NamedRenderbufferStorageMultisample      :: #force_inline proc "c" (renderbuffer: u32, samples: i32, internalformat: u32, width: i32, height: i32)                                                                                      {        impl_NamedRenderbufferStorageMultisample(renderbuffer, samples, internalformat, width, height)                                                }
-	GetNamedRenderbufferParameteriv          :: #force_inline proc "c" (renderbuffer: u32, pname: u32, params: [^]i32)                                                                                                                      {        impl_GetNamedRenderbufferParameteriv(renderbuffer, pname, params)                                                                             }
-	CreateTextures                           :: #force_inline proc "c" (target: u32, n: i32, textures: [^]u32)                                                                                                                              {        impl_CreateTextures(target, n, textures)                                                                                                      }
-	TextureBuffer                            :: #force_inline proc "c" (texture: u32, internalformat: u32, buffer: u32)                                                                                                                     {        impl_TextureBuffer(texture, internalformat, buffer)                                                                                           }
-	TextureBufferRange                       :: #force_inline proc "c" (texture: u32, internalformat: u32, buffer: u32, offset: int, size: int)                                                                                             {        impl_TextureBufferRange(texture, internalformat, buffer, offset, size)                                                                        }
-	TextureStorage1D                         :: #force_inline proc "c" (texture: u32, levels: i32, internalformat: u32, width: i32)                                                                                                         {        impl_TextureStorage1D(texture, levels, internalformat, width)                                                                                 }
-	TextureStorage2D                         :: #force_inline proc "c" (texture: u32, levels: i32, internalformat: u32, width: i32, height: i32)                                                                                            {        impl_TextureStorage2D(texture, levels, internalformat, width, height)                                                                         }
-	TextureStorage3D                         :: #force_inline proc "c" (texture: u32, levels: i32, internalformat: u32, width: i32, height: i32, depth: i32)                                                                                {        impl_TextureStorage3D(texture, levels, internalformat, width, height, depth)                                                                  }
-	TextureStorage2DMultisample              :: #force_inline proc "c" (texture: u32, samples: i32, internalformat: u32, width: i32, height: i32, fixedsamplelocations: bool)                                                               {        impl_TextureStorage2DMultisample(texture, samples, internalformat, width, height, fixedsamplelocations)                                       }
-	TextureStorage3DMultisample              :: #force_inline proc "c" (texture: u32, samples: i32, internalformat: u32, width: i32, height: i32, depth: i32, fixedsamplelocations: bool)                                                   {        impl_TextureStorage3DMultisample(texture, samples, internalformat, width, height, depth, fixedsamplelocations)                                }
-	TextureSubImage1D                        :: #force_inline proc "c" (texture: u32, level: i32, xoffset: i32, width: i32, format: u32, type: u32, pixels: rawptr)                                                                         {        impl_TextureSubImage1D(texture, level, xoffset, width, format, type, pixels)                                                                 }
-	TextureSubImage2D                        :: #force_inline proc "c" (texture: u32, level: i32, xoffset: i32, yoffset: i32, width: i32, height: i32, format: u32, type: u32, pixels: rawptr)                                              {        impl_TextureSubImage2D(texture, level, xoffset, yoffset, width, height, format, type, pixels)                                                }
-	TextureSubImage3D                        :: #force_inline proc "c" (texture: u32, level: i32, xoffset: i32, yoffset: i32, zoffset: i32, width: i32, height: i32, depth: i32, format: u32, type: u32, pixels: rawptr)                    {        impl_TextureSubImage3D(texture, level, xoffset, yoffset, zoffset, width, height, depth, format, type, pixels)                                }
-	CompressedTextureSubImage1D              :: #force_inline proc "c" (texture: u32, level: i32, xoffset: i32, width: i32, format: u32, imageSize: i32, data: rawptr)                                                                      {        impl_CompressedTextureSubImage1D(texture, level, xoffset, width, format, imageSize, data)                                                     }
-	CompressedTextureSubImage2D              :: #force_inline proc "c" (texture: u32, level: i32, xoffset: i32, yoffset: i32, width: i32, height: i32, format: u32, imageSize: i32, data: rawptr)                                           {        impl_CompressedTextureSubImage2D(texture, level, xoffset, yoffset, width, height, format, imageSize, data)                                    }
-	CompressedTextureSubImage3D              :: #force_inline proc "c" (texture: u32, level: i32, xoffset: i32, yoffset: i32, zoffset: i32, width: i32, height: i32, depth: i32, format: u32, imageSize: i32, data: rawptr)                 {        impl_CompressedTextureSubImage3D(texture, level, xoffset, yoffset, zoffset, width, height, depth, format, imageSize, data)                    }
-	CopyTextureSubImage1D                    :: #force_inline proc "c" (texture: u32, level: i32, xoffset: i32, x: i32, y: i32, width: i32)                                                                                                 {        impl_CopyTextureSubImage1D(texture, level, xoffset, x, y, width)                                                                              }
-	CopyTextureSubImage2D                    :: #force_inline proc "c" (texture: u32, level: i32, xoffset: i32, yoffset: i32, x: i32, y: i32, width: i32, height: i32)                                                                      {        impl_CopyTextureSubImage2D(texture, level, xoffset, yoffset, x, y, width, height)                                                             }
-	CopyTextureSubImage3D                    :: #force_inline proc "c" (texture: u32, level: i32, xoffset: i32, yoffset: i32, zoffset: i32, x: i32, y: i32, width: i32, height: i32)                                                        {        impl_CopyTextureSubImage3D(texture, level, xoffset, yoffset, zoffset, x, y, width, height)                                                    }
-	TextureParameterf                        :: #force_inline proc "c" (texture: u32, pname: u32, param: f32)                                                                                                                               {        impl_TextureParameterf(texture, pname, param)                                                                                                 }
-	TextureParameterfv                       :: #force_inline proc "c" (texture: u32, pname: u32, param: ^f32)                                                                                                                              {        impl_TextureParameterfv(texture, pname, param)                                                                                                }
-	TextureParameteri                        :: #force_inline proc "c" (texture: u32, pname: u32, param: i32)                                                                                                                               {        impl_TextureParameteri(texture, pname, param)                                                                                                 }
-	TextureParameterIiv                      :: #force_inline proc "c" (texture: u32, pname: u32, params: [^]i32)                                                                                                                           {        impl_TextureParameterIiv(texture, pname, params)                                                                                              }
-	TextureParameterIuiv                     :: #force_inline proc "c" (texture: u32, pname: u32, params: [^]u32)                                                                                                                           {        impl_TextureParameterIuiv(texture, pname, params)                                                                                             }
-	TextureParameteriv                       :: #force_inline proc "c" (texture: u32, pname: u32, param: ^i32)                                                                                                                              {        impl_TextureParameteriv(texture, pname, param)                                                                                                }
-	GenerateTextureMipmap                    :: #force_inline proc "c" (texture: u32)                                                                                                                                                       {        impl_GenerateTextureMipmap(texture)                                                                                                           }
-	BindTextureUnit                          :: #force_inline proc "c" (unit: u32, texture: u32)                                                                                                                                            {        impl_BindTextureUnit(unit, texture)                                                                                                           }
-	GetTextureImage                          :: #force_inline proc "c" (texture: u32, level: i32, format: u32, type: u32, bufSize: i32, pixels: rawptr)                                                                                     {        impl_GetTextureImage(texture, level, format, type, bufSize, pixels)                                                                          }
-	GetCompressedTextureImage                :: #force_inline proc "c" (texture: u32, level: i32, bufSize: i32, pixels: rawptr)                                                                                                             {        impl_GetCompressedTextureImage(texture, level, bufSize, pixels)                                                                               }
-	GetTextureLevelParameterfv               :: #force_inline proc "c" (texture: u32, level: i32, pname: u32, params: [^]f32)                                                                                                               {        impl_GetTextureLevelParameterfv(texture, level, pname, params)                                                                                }
-	GetTextureLevelParameteriv               :: #force_inline proc "c" (texture: u32, level: i32, pname: u32, params: [^]i32)                                                                                                               {        impl_GetTextureLevelParameteriv(texture, level, pname, params)                                                                                }
-	GetTextureParameterfv                    :: #force_inline proc "c" (texture: u32, pname: u32, params: [^]f32)                                                                                                                           {        impl_GetTextureParameterfv(texture, pname, params)                                                                                            }
-	GetTextureParameterIiv                   :: #force_inline proc "c" (texture: u32, pname: u32, params: [^]i32)                                                                                                                           {        impl_GetTextureParameterIiv(texture, pname, params)                                                                                           }
-	GetTextureParameterIuiv                  :: #force_inline proc "c" (texture: u32, pname: u32, params: [^]u32)                                                                                                                           {        impl_GetTextureParameterIuiv(texture, pname, params)                                                                                          }
-	GetTextureParameteriv                    :: #force_inline proc "c" (texture: u32, pname: u32, params: [^]i32)                                                                                                                           {        impl_GetTextureParameteriv(texture, pname, params)                                                                                            }
-	CreateVertexArrays                       :: #force_inline proc "c" (n: i32, arrays: [^]u32)                                                                                                                                             {        impl_CreateVertexArrays(n, arrays)                                                                                                            }
-	DisableVertexArrayAttrib                 :: #force_inline proc "c" (vaobj: u32, index: u32)                                                                                                                                             {        impl_DisableVertexArrayAttrib(vaobj, index)                                                                                                   }
-	EnableVertexArrayAttrib                  :: #force_inline proc "c" (vaobj: u32, index: u32)                                                                                                                                             {        impl_EnableVertexArrayAttrib(vaobj, index)                                                                                                    }
-	VertexArrayElementBuffer                 :: #force_inline proc "c" (vaobj: u32, buffer: u32)                                                                                                                                            {        impl_VertexArrayElementBuffer(vaobj, buffer)                                                                                                  }
-	VertexArrayVertexBuffer                  :: #force_inline proc "c" (vaobj: u32, bindingindex: u32, buffer: u32, offset: int, stride: i32)                                                                                               {        impl_VertexArrayVertexBuffer(vaobj, bindingindex, buffer, offset, stride)                                                                     }
-	VertexArrayVertexBuffers                 :: #force_inline proc "c" (vaobj: u32, first: u32, count: i32, buffers: [^]u32, offsets: [^]uintptr, strides: [^]i32)                                                                          {        impl_VertexArrayVertexBuffers(vaobj, first, count, buffers, offsets, strides)                                                                 }
-	VertexArrayAttribBinding                 :: #force_inline proc "c" (vaobj: u32, attribindex: u32, bindingindex: u32)                                                                                                                    {        impl_VertexArrayAttribBinding(vaobj, attribindex, bindingindex)                                                                               }
-	VertexArrayAttribFormat                  :: #force_inline proc "c" (vaobj: u32, attribindex: u32, size: i32, type: u32, normalized: bool, relativeoffset: u32)                                                                          {        impl_VertexArrayAttribFormat(vaobj, attribindex, size, type, normalized, relativeoffset)                                                     }
-	VertexArrayAttribIFormat                 :: #force_inline proc "c" (vaobj: u32, attribindex: u32, size: i32, type: u32, relativeoffset: u32)                                                                                            {        impl_VertexArrayAttribIFormat(vaobj, attribindex, size, type, relativeoffset)                                                                }
-	VertexArrayAttribLFormat                 :: #force_inline proc "c" (vaobj: u32, attribindex: u32, size: i32, type: u32, relativeoffset: u32)                                                                                            {        impl_VertexArrayAttribLFormat(vaobj, attribindex, size, type, relativeoffset)                                                                }
-	VertexArrayBindingDivisor                :: #force_inline proc "c" (vaobj: u32, bindingindex: u32, divisor: u32)                                                                                                                        {        impl_VertexArrayBindingDivisor(vaobj, bindingindex, divisor)                                                                                  }
-	GetVertexArrayiv                         :: #force_inline proc "c" (vaobj: u32, pname: u32, param: ^i32)                                                                                                                                {        impl_GetVertexArrayiv(vaobj, pname, param)                                                                                                    }
-	GetVertexArrayIndexediv                  :: #force_inline proc "c" (vaobj: u32, index: u32, pname: u32, param: ^i32)                                                                                                                    {        impl_GetVertexArrayIndexediv(vaobj, index, pname, param)                                                                                      }
-	GetVertexArrayIndexed64iv                :: #force_inline proc "c" (vaobj: u32, index: u32, pname: u32, param: ^i64)                                                                                                                    {        impl_GetVertexArrayIndexed64iv(vaobj, index, pname, param)                                                                                    }
-	CreateSamplers                           :: #force_inline proc "c" (n: i32, samplers: [^]u32)                                                                                                                                           {        impl_CreateSamplers(n, samplers)                                                                                                              }
-	CreateProgramPipelines                   :: #force_inline proc "c" (n: i32, pipelines: [^]u32)                                                                                                                                          {        impl_CreateProgramPipelines(n, pipelines)                                                                                                     }
-	CreateQueries                            :: #force_inline proc "c" (target: u32, n: i32, ids: [^]u32)                                                                                                                                   {        impl_CreateQueries(target, n, ids)                                                                                                            }
-	GetQueryBufferObjecti64v                 :: #force_inline proc "c" (id: u32, buffer: u32, pname: u32, offset: int)                                                                                                                      {        impl_GetQueryBufferObjecti64v(id, buffer, pname, offset)                                                                                      }
-	GetQueryBufferObjectiv                   :: #force_inline proc "c" (id: u32, buffer: u32, pname: u32, offset: int)                                                                                                                      {        impl_GetQueryBufferObjectiv(id, buffer, pname, offset)                                                                                        }
-	GetQueryBufferObjectui64v                :: #force_inline proc "c" (id: u32, buffer: u32, pname: u32, offset: int)                                                                                                                      {        impl_GetQueryBufferObjectui64v(id, buffer, pname, offset)                                                                                     }
-	GetQueryBufferObjectuiv                  :: #force_inline proc "c" (id: u32, buffer: u32, pname: u32, offset: int)                                                                                                                      {        impl_GetQueryBufferObjectuiv(id, buffer, pname, offset)                                                                                       }
-	MemoryBarrierByRegion                    :: #force_inline proc "c" (barriers: u32)                                                                                                                                                      {        impl_MemoryBarrierByRegion(barriers)                                                                                                          }
-	GetTextureSubImage                       :: #force_inline proc "c" (texture: u32, level: i32, xoffset: i32, yoffset: i32, zoffset: i32, width: i32, height: i32, depth: i32, format: u32, type: u32, bufSize: i32, pixels: rawptr)      {        impl_GetTextureSubImage(texture, level, xoffset, yoffset, zoffset, width, height, depth, format, type, bufSize, pixels)                      }
-	GetCompressedTextureSubImage             :: #force_inline proc "c" (texture: u32, level: i32, xoffset: i32, yoffset: i32, zoffset: i32, width: i32, height: i32, depth: i32, bufSize: i32, pixels: rawptr)                              {        impl_GetCompressedTextureSubImage(texture, level, xoffset, yoffset, zoffset, width, height, depth, bufSize, pixels)                           }
-	GetGraphicsResetStatus                   :: #force_inline proc "c" () -> u32                                                                                                                                                            { ret := impl_GetGraphicsResetStatus();                                                                                                     return ret }
-	GetnCompressedTexImage                   :: #force_inline proc "c" (target: u32, lod: i32, bufSize: i32, pixels: rawptr)                                                                                                                {        impl_GetnCompressedTexImage(target, lod, bufSize, pixels)                                                                                     }
-	GetnTexImage                             :: #force_inline proc "c" (target: u32, level: i32, format: u32, type: u32, bufSize: i32, pixels: rawptr)                                                                                      {        impl_GetnTexImage(target, level, format, type, bufSize, pixels)                                                                              }
-	GetnUniformdv                            :: #force_inline proc "c" (program: u32, location: i32, bufSize: i32, params: [^]f64)                                                                                                          {        impl_GetnUniformdv(program, location, bufSize, params)                                                                                        }
-	GetnUniformfv                            :: #force_inline proc "c" (program: u32, location: i32, bufSize: i32, params: [^]f32)                                                                                                          {        impl_GetnUniformfv(program, location, bufSize, params)                                                                                        }
-	GetnUniformiv                            :: #force_inline proc "c" (program: u32, location: i32, bufSize: i32, params: [^]i32)                                                                                                          {        impl_GetnUniformiv(program, location, bufSize, params)                                                                                        }
-	GetnUniformuiv                           :: #force_inline proc "c" (program: u32, location: i32, bufSize: i32, params: [^]u32)                                                                                                          {        impl_GetnUniformuiv(program, location, bufSize, params)                                                                                       }
-	ReadnPixels                              :: #force_inline proc "c" (x: i32, y: i32, width: i32, height: i32, format: u32, type: u32, bufSize: i32, data: rawptr)                                                                        {        impl_ReadnPixels(x, y, width, height, format, type, bufSize, data)                                                                           }
-	GetnMapdv                                :: #force_inline proc "c" (target: u32, query: u32, bufSize: i32, v: [^]f64)                                                                                                                     {        impl_GetnMapdv(target, query, bufSize, v)                                                                                                     }
-	GetnMapfv                                :: #force_inline proc "c" (target: u32, query: u32, bufSize: i32, v: [^]f32)                                                                                                                     {        impl_GetnMapfv(target, query, bufSize, v)                                                                                                     }
-	GetnMapiv                                :: #force_inline proc "c" (target: u32, query: u32, bufSize: i32, v: [^]i32)                                                                                                                     {        impl_GetnMapiv(target, query, bufSize, v)                                                                                                     }
-	GetnPixelMapusv                          :: #force_inline proc "c" (map_: u32, bufSize: i32, values: [^]u16)                                                                                                                            {        impl_GetnPixelMapusv(map_, bufSize, values)                                                                                                   }
-	GetnPixelMapfv                           :: #force_inline proc "c" (map_: u32, bufSize: i32, values: [^]f32)                                                                                                                            {        impl_GetnPixelMapfv(map_, bufSize, values)                                                                                                    }
-	GetnPixelMapuiv                          :: #force_inline proc "c" (map_: u32, bufSize: i32, values: [^]u32)                                                                                                                            {        impl_GetnPixelMapuiv(map_, bufSize, values)                                                                                                   }
-	GetnPolygonStipple                       :: #force_inline proc "c" (bufSize: i32, pattern: [^]u8)                                                                                                                                         {        impl_GetnPolygonStipple(bufSize, pattern)                                                                                                     }
-	GetnColorTable                           :: #force_inline proc "c" (target: u32, format: u32, type: u32, bufSize: i32, table: rawptr)                                                                                                   {        impl_GetnColorTable(target, format, type, bufSize, table)                                                                                    }
-	GetnConvolutionFilter                    :: #force_inline proc "c" (target: u32, format: u32, type: u32, bufSize: i32, image: rawptr)                                                                                                   {        impl_GetnConvolutionFilter(target, format, type, bufSize, image)                                                                             }
-	GetnSeparableFilter                      :: #force_inline proc "c" (target: u32, format: u32, type: u32, rowBufSize: i32, row: rawptr, columnBufSize: i32, column: rawptr, span: rawptr)                                                {        impl_GetnSeparableFilter(target, format, type, rowBufSize, row, columnBufSize, column, span)                                                 }
-	GetnHistogram                            :: #force_inline proc "c" (target: u32, reset: bool, format: u32, type: u32, bufSize: i32, values: rawptr)                                                                                     {        impl_GetnHistogram(target, reset, format, type, bufSize, values)                                                                             }
-	GetnMinmax                               :: #force_inline proc "c" (target: u32, reset: bool, format: u32, type: u32, bufSize: i32, values: rawptr)                                                                                     {        impl_GetnMinmax(target, reset, format, type, bufSize, values)                                                                                }
-	TextureBarrier                           :: #force_inline proc "c" ()                                                                                                                                                                   {        impl_TextureBarrier()                                                                                                                         }
-	GetUnsignedBytevEXT                      :: #force_inline proc "c" (pname: u32, data: ^byte)                                                                                                                                            {        impl_GetUnsignedBytevEXT(pname, data)                                                                                                         }
-	TexPageCommitmentARB                     :: #force_inline proc "c"(target: u32, level: i32, xoffset: i32, yoffset: i32, zoffset: i32, width: i32, height: i32, depth: i32, commit: bool)                                                {        impl_TexPageCommitmentARB(target, level, xoffset, yoffset, zoffset, width, height, depth, commit)                                             }
+	ClipControl                              :: proc "c" (origin: u32, depth: u32)                                                                                                                                            {        impl_ClipControl(origin, depth)                                                                                                               }
+	CreateTransformFeedbacks                 :: proc "c" (n: i32, ids: [^]u32)                                                                                                                                                {        impl_CreateTransformFeedbacks(n, ids)                                                                                                         }
+	TransformFeedbackBufferBase              :: proc "c" (xfb: u32, index: u32, buffer: u32)                                                                                                                                  {        impl_TransformFeedbackBufferBase(xfb, index, buffer)                                                                                          }
+	TransformFeedbackBufferRange             :: proc "c" (xfb: u32, index: u32, buffer: u32, offset: int, size: int)                                                                                                          {        impl_TransformFeedbackBufferRange(xfb, index, buffer, offset, size)                                                                           }
+	GetTransformFeedbackiv                   :: proc "c" (xfb: u32, pname: u32, param: ^i32)                                                                                                                                  {        impl_GetTransformFeedbackiv(xfb, pname, param)                                                                                                }
+	GetTransformFeedbacki_v                  :: proc "c" (xfb: u32, pname: u32, index: u32, param: ^i32)                                                                                                                      {        impl_GetTransformFeedbacki_v(xfb, pname, index, param)                                                                                        }
+	GetTransformFeedbacki64_v                :: proc "c" (xfb: u32, pname: u32, index: u32, param: ^i64)                                                                                                                      {        impl_GetTransformFeedbacki64_v(xfb, pname, index, param)                                                                                      }
+	CreateBuffers                            :: proc "c" (n: i32, buffers: [^]u32)                                                                                                                                            {        impl_CreateBuffers(n, buffers)                                                                                                                }
+	NamedBufferStorage                       :: proc "c" (buffer: u32, size: int, data: rawptr, flags: u32)                                                                                                                   {        impl_NamedBufferStorage(buffer, size, data, flags)                                                                                            }
+	NamedBufferData                          :: proc "c" (buffer: u32, size: int, data: rawptr, usage: u32)                                                                                                                   {        impl_NamedBufferData(buffer, size, data, usage)                                                                                               }
+	NamedBufferSubData                       :: proc "c" (buffer: u32, offset: int, size: int, data: rawptr)                                                                                                                  {        impl_NamedBufferSubData(buffer, offset, size, data)                                                                                           }
+	CopyNamedBufferSubData                   :: proc "c" (readBuffer: u32, writeBuffer: u32, readOffset: int, writeOffset: int, size: int)                                                                                    {        impl_CopyNamedBufferSubData(readBuffer, writeBuffer, readOffset, writeOffset, size)                                                           }
+	ClearNamedBufferData                     :: proc "c" (buffer: u32, internalformat: u32, format: u32, type: u32, data: rawptr)                                                                                             {        impl_ClearNamedBufferData(buffer, internalformat, format, type, data)                                                                        }
+	ClearNamedBufferSubData                  :: proc "c" (buffer: u32, internalformat: u32, offset: int, size: int, format: u32, type: u32, data: rawptr)                                                                     {        impl_ClearNamedBufferSubData(buffer, internalformat, offset, size, format, type, data)                                                       }
+	MapNamedBuffer                           :: proc "c" (buffer: u32, access: u32) -> rawptr                                                                                                                                 { ret := impl_MapNamedBuffer(buffer, access);                                                                                               return ret }
+	MapNamedBufferRange                      :: proc "c" (buffer: u32, offset: int, length: int, access: u32) -> rawptr                                                                                                       { ret := impl_MapNamedBufferRange(buffer, offset, length, access);                                                                          return ret }
+	UnmapNamedBuffer                         :: proc "c" (buffer: u32) -> bool                                                                                                                                                { ret := impl_UnmapNamedBuffer(buffer);                                                                                                     return ret }
+	FlushMappedNamedBufferRange              :: proc "c" (buffer: u32, offset: int, length: int)                                                                                                                              {        impl_FlushMappedNamedBufferRange(buffer, offset, length)                                                                                      }
+	GetNamedBufferParameteriv                :: proc "c" (buffer: u32, pname: u32, params: [^]i32)                                                                                                                            {        impl_GetNamedBufferParameteriv(buffer, pname, params)                                                                                         }
+	GetNamedBufferParameteri64v              :: proc "c" (buffer: u32, pname: u32, params: [^]i64)                                                                                                                            {        impl_GetNamedBufferParameteri64v(buffer, pname, params)                                                                                       }
+	GetNamedBufferPointerv                   :: proc "c" (buffer: u32, pname: u32, params: [^]rawptr)                                                                                                                         {        impl_GetNamedBufferPointerv(buffer, pname, params)                                                                                            }
+	GetNamedBufferSubData                    :: proc "c" (buffer: u32, offset: int, size: int, data: rawptr)                                                                                                                  {        impl_GetNamedBufferSubData(buffer, offset, size, data)                                                                                        }
+	CreateFramebuffers                       :: proc "c" (n: i32, framebuffers: [^]u32)                                                                                                                                       {        impl_CreateFramebuffers(n, framebuffers)                                                                                                      }
+	NamedFramebufferRenderbuffer             :: proc "c" (framebuffer: u32, attachment: u32, renderbuffertarget: u32, renderbuffer: u32)                                                                                      {        impl_NamedFramebufferRenderbuffer(framebuffer, attachment, renderbuffertarget, renderbuffer)                                                  }
+	NamedFramebufferParameteri               :: proc "c" (framebuffer: u32, pname: u32, param: i32)                                                                                                                           {        impl_NamedFramebufferParameteri(framebuffer, pname, param)                                                                                    }
+	NamedFramebufferTexture                  :: proc "c" (framebuffer: u32, attachment: u32, texture: u32, level: i32)                                                                                                        {        impl_NamedFramebufferTexture(framebuffer, attachment, texture, level)                                                                         }
+	NamedFramebufferTextureLayer             :: proc "c" (framebuffer: u32, attachment: u32, texture: u32, level: i32, layer: i32)                                                                                            {        impl_NamedFramebufferTextureLayer(framebuffer, attachment, texture, level, layer)                                                             }
+	NamedFramebufferDrawBuffer               :: proc "c" (framebuffer: u32, buf: u32)                                                                                                                                         {        impl_NamedFramebufferDrawBuffer(framebuffer, buf)                                                                                             }
+	NamedFramebufferDrawBuffers              :: proc "c" (framebuffer: u32, n: i32, bufs: [^]u32)                                                                                                                             {        impl_NamedFramebufferDrawBuffers(framebuffer, n, bufs)                                                                                        }
+	NamedFramebufferReadBuffer               :: proc "c" (framebuffer: u32, src: u32)                                                                                                                                         {        impl_NamedFramebufferReadBuffer(framebuffer, src)                                                                                             }
+	InvalidateNamedFramebufferData           :: proc "c" (framebuffer: u32, numAttachments: i32, attachments: [^]u32)                                                                                                           {        impl_InvalidateNamedFramebufferData(framebuffer, numAttachments, attachments)                                                                 }
+	InvalidateNamedFramebufferSubData        :: proc "c" (framebuffer: u32, numAttachments: i32, attachments: [^]u32, x: i32, y: i32, width: i32, height: i32)                                                                  {        impl_InvalidateNamedFramebufferSubData(framebuffer, numAttachments, attachments, x, y, width, height)                                         }
+	ClearNamedFramebufferiv                  :: proc "c" (framebuffer: u32, buffer: u32, drawbuffer: i32, value: ^i32)                                                                                                        {        impl_ClearNamedFramebufferiv(framebuffer, buffer, drawbuffer, value)                                                                          }
+	ClearNamedFramebufferuiv                 :: proc "c" (framebuffer: u32, buffer: u32, drawbuffer: i32, value: ^u32)                                                                                                        {        impl_ClearNamedFramebufferuiv(framebuffer, buffer, drawbuffer, value)                                                                         }
+	ClearNamedFramebufferfv                  :: proc "c" (framebuffer: u32, buffer: u32, drawbuffer: i32, value: ^f32)                                                                                                        {        impl_ClearNamedFramebufferfv(framebuffer, buffer, drawbuffer, value)                                                                          }
+	ClearNamedFramebufferfi                  :: proc "c" (framebuffer: u32, buffer: u32, drawbuffer: i32, depth: f32, stencil: i32)                                                                                           {        impl_ClearNamedFramebufferfi(framebuffer, buffer, drawbuffer, depth, stencil)                                                                 }
+	BlitNamedFramebuffer                     :: proc "c" (readFramebuffer: u32, drawFramebuffer: u32, srcX0: i32, srcY0: i32, srcX1: i32, srcY1: i32, dstX0: i32, dstY0: i32, dstX1: i32, dstY1: i32, mask: u32, filter: u32) {        impl_BlitNamedFramebuffer(readFramebuffer, drawFramebuffer, srcX0, srcY0, srcX1, srcY1, dstX0, dstY0, dstX1, dstY1, mask, filter)             }
+	CheckNamedFramebufferStatus              :: proc "c" (framebuffer: u32, target: u32) -> u32                                                                                                                               { ret := impl_CheckNamedFramebufferStatus(framebuffer, target);                                                                             return ret }
+	GetNamedFramebufferParameteriv           :: proc "c" (framebuffer: u32, pname: u32, param: ^i32)                                                                                                                          {        impl_GetNamedFramebufferParameteriv(framebuffer, pname, param)                                                                                }
+	GetNamedFramebufferAttachmentParameteriv :: proc "c" (framebuffer: u32, attachment: u32, pname: u32, params: [^]i32)                                                                                                      {        impl_GetNamedFramebufferAttachmentParameteriv(framebuffer, attachment, pname, params)                                                         }
+	CreateRenderbuffers                      :: proc "c" (n: i32, renderbuffers: [^]u32)                                                                                                                                      {        impl_CreateRenderbuffers(n, renderbuffers)                                                                                                    }
+	NamedRenderbufferStorage                 :: proc "c" (renderbuffer: u32, internalformat: u32, width: i32, height: i32)                                                                                                    {        impl_NamedRenderbufferStorage(renderbuffer, internalformat, width, height)                                                                    }
+	NamedRenderbufferStorageMultisample      :: proc "c" (renderbuffer: u32, samples: i32, internalformat: u32, width: i32, height: i32)                                                                                      {        impl_NamedRenderbufferStorageMultisample(renderbuffer, samples, internalformat, width, height)                                                }
+	GetNamedRenderbufferParameteriv          :: proc "c" (renderbuffer: u32, pname: u32, params: [^]i32)                                                                                                                      {        impl_GetNamedRenderbufferParameteriv(renderbuffer, pname, params)                                                                             }
+	CreateTextures                           :: proc "c" (target: u32, n: i32, textures: [^]u32)                                                                                                                              {        impl_CreateTextures(target, n, textures)                                                                                                      }
+	TextureBuffer                            :: proc "c" (texture: u32, internalformat: u32, buffer: u32)                                                                                                                     {        impl_TextureBuffer(texture, internalformat, buffer)                                                                                           }
+	TextureBufferRange                       :: proc "c" (texture: u32, internalformat: u32, buffer: u32, offset: int, size: int)                                                                                             {        impl_TextureBufferRange(texture, internalformat, buffer, offset, size)                                                                        }
+	TextureStorage1D                         :: proc "c" (texture: u32, levels: i32, internalformat: u32, width: i32)                                                                                                         {        impl_TextureStorage1D(texture, levels, internalformat, width)                                                                                 }
+	TextureStorage2D                         :: proc "c" (texture: u32, levels: i32, internalformat: u32, width: i32, height: i32)                                                                                            {        impl_TextureStorage2D(texture, levels, internalformat, width, height)                                                                         }
+	TextureStorage3D                         :: proc "c" (texture: u32, levels: i32, internalformat: u32, width: i32, height: i32, depth: i32)                                                                                {        impl_TextureStorage3D(texture, levels, internalformat, width, height, depth)                                                                  }
+	TextureStorage2DMultisample              :: proc "c" (texture: u32, samples: i32, internalformat: u32, width: i32, height: i32, fixedsamplelocations: bool)                                                               {        impl_TextureStorage2DMultisample(texture, samples, internalformat, width, height, fixedsamplelocations)                                       }
+	TextureStorage3DMultisample              :: proc "c" (texture: u32, samples: i32, internalformat: u32, width: i32, height: i32, depth: i32, fixedsamplelocations: bool)                                                   {        impl_TextureStorage3DMultisample(texture, samples, internalformat, width, height, depth, fixedsamplelocations)                                }
+	TextureSubImage1D                        :: proc "c" (texture: u32, level: i32, xoffset: i32, width: i32, format: u32, type: u32, pixels: rawptr)                                                                         {        impl_TextureSubImage1D(texture, level, xoffset, width, format, type, pixels)                                                                 }
+	TextureSubImage2D                        :: proc "c" (texture: u32, level: i32, xoffset: i32, yoffset: i32, width: i32, height: i32, format: u32, type: u32, pixels: rawptr)                                              {        impl_TextureSubImage2D(texture, level, xoffset, yoffset, width, height, format, type, pixels)                                                }
+	TextureSubImage3D                        :: proc "c" (texture: u32, level: i32, xoffset: i32, yoffset: i32, zoffset: i32, width: i32, height: i32, depth: i32, format: u32, type: u32, pixels: rawptr)                    {        impl_TextureSubImage3D(texture, level, xoffset, yoffset, zoffset, width, height, depth, format, type, pixels)                                }
+	CompressedTextureSubImage1D              :: proc "c" (texture: u32, level: i32, xoffset: i32, width: i32, format: u32, imageSize: i32, data: rawptr)                                                                      {        impl_CompressedTextureSubImage1D(texture, level, xoffset, width, format, imageSize, data)                                                     }
+	CompressedTextureSubImage2D              :: proc "c" (texture: u32, level: i32, xoffset: i32, yoffset: i32, width: i32, height: i32, format: u32, imageSize: i32, data: rawptr)                                           {        impl_CompressedTextureSubImage2D(texture, level, xoffset, yoffset, width, height, format, imageSize, data)                                    }
+	CompressedTextureSubImage3D              :: proc "c" (texture: u32, level: i32, xoffset: i32, yoffset: i32, zoffset: i32, width: i32, height: i32, depth: i32, format: u32, imageSize: i32, data: rawptr)                 {        impl_CompressedTextureSubImage3D(texture, level, xoffset, yoffset, zoffset, width, height, depth, format, imageSize, data)                    }
+	CopyTextureSubImage1D                    :: proc "c" (texture: u32, level: i32, xoffset: i32, x: i32, y: i32, width: i32)                                                                                                 {        impl_CopyTextureSubImage1D(texture, level, xoffset, x, y, width)                                                                              }
+	CopyTextureSubImage2D                    :: proc "c" (texture: u32, level: i32, xoffset: i32, yoffset: i32, x: i32, y: i32, width: i32, height: i32)                                                                      {        impl_CopyTextureSubImage2D(texture, level, xoffset, yoffset, x, y, width, height)                                                             }
+	CopyTextureSubImage3D                    :: proc "c" (texture: u32, level: i32, xoffset: i32, yoffset: i32, zoffset: i32, x: i32, y: i32, width: i32, height: i32)                                                        {        impl_CopyTextureSubImage3D(texture, level, xoffset, yoffset, zoffset, x, y, width, height)                                                    }
+	TextureParameterf                        :: proc "c" (texture: u32, pname: u32, param: f32)                                                                                                                               {        impl_TextureParameterf(texture, pname, param)                                                                                                 }
+	TextureParameterfv                       :: proc "c" (texture: u32, pname: u32, param: ^f32)                                                                                                                              {        impl_TextureParameterfv(texture, pname, param)                                                                                                }
+	TextureParameteri                        :: proc "c" (texture: u32, pname: u32, param: i32)                                                                                                                               {        impl_TextureParameteri(texture, pname, param)                                                                                                 }
+	TextureParameterIiv                      :: proc "c" (texture: u32, pname: u32, params: [^]i32)                                                                                                                           {        impl_TextureParameterIiv(texture, pname, params)                                                                                              }
+	TextureParameterIuiv                     :: proc "c" (texture: u32, pname: u32, params: [^]u32)                                                                                                                           {        impl_TextureParameterIuiv(texture, pname, params)                                                                                             }
+	TextureParameteriv                       :: proc "c" (texture: u32, pname: u32, param: ^i32)                                                                                                                              {        impl_TextureParameteriv(texture, pname, param)                                                                                                }
+	GenerateTextureMipmap                    :: proc "c" (texture: u32)                                                                                                                                                       {        impl_GenerateTextureMipmap(texture)                                                                                                           }
+	BindTextureUnit                          :: proc "c" (unit: u32, texture: u32)                                                                                                                                            {        impl_BindTextureUnit(unit, texture)                                                                                                           }
+	GetTextureImage                          :: proc "c" (texture: u32, level: i32, format: u32, type: u32, bufSize: i32, pixels: rawptr)                                                                                     {        impl_GetTextureImage(texture, level, format, type, bufSize, pixels)                                                                          }
+	GetCompressedTextureImage                :: proc "c" (texture: u32, level: i32, bufSize: i32, pixels: rawptr)                                                                                                             {        impl_GetCompressedTextureImage(texture, level, bufSize, pixels)                                                                               }
+	GetTextureLevelParameterfv               :: proc "c" (texture: u32, level: i32, pname: u32, params: [^]f32)                                                                                                               {        impl_GetTextureLevelParameterfv(texture, level, pname, params)                                                                                }
+	GetTextureLevelParameteriv               :: proc "c" (texture: u32, level: i32, pname: u32, params: [^]i32)                                                                                                               {        impl_GetTextureLevelParameteriv(texture, level, pname, params)                                                                                }
+	GetTextureParameterfv                    :: proc "c" (texture: u32, pname: u32, params: [^]f32)                                                                                                                           {        impl_GetTextureParameterfv(texture, pname, params)                                                                                            }
+	GetTextureParameterIiv                   :: proc "c" (texture: u32, pname: u32, params: [^]i32)                                                                                                                           {        impl_GetTextureParameterIiv(texture, pname, params)                                                                                           }
+	GetTextureParameterIuiv                  :: proc "c" (texture: u32, pname: u32, params: [^]u32)                                                                                                                           {        impl_GetTextureParameterIuiv(texture, pname, params)                                                                                          }
+	GetTextureParameteriv                    :: proc "c" (texture: u32, pname: u32, params: [^]i32)                                                                                                                           {        impl_GetTextureParameteriv(texture, pname, params)                                                                                            }
+	CreateVertexArrays                       :: proc "c" (n: i32, arrays: [^]u32)                                                                                                                                             {        impl_CreateVertexArrays(n, arrays)                                                                                                            }
+	DisableVertexArrayAttrib                 :: proc "c" (vaobj: u32, index: u32)                                                                                                                                             {        impl_DisableVertexArrayAttrib(vaobj, index)                                                                                                   }
+	EnableVertexArrayAttrib                  :: proc "c" (vaobj: u32, index: u32)                                                                                                                                             {        impl_EnableVertexArrayAttrib(vaobj, index)                                                                                                    }
+	VertexArrayElementBuffer                 :: proc "c" (vaobj: u32, buffer: u32)                                                                                                                                            {        impl_VertexArrayElementBuffer(vaobj, buffer)                                                                                                  }
+	VertexArrayVertexBuffer                  :: proc "c" (vaobj: u32, bindingindex: u32, buffer: u32, offset: int, stride: i32)                                                                                               {        impl_VertexArrayVertexBuffer(vaobj, bindingindex, buffer, offset, stride)                                                                     }
+	VertexArrayVertexBuffers                 :: proc "c" (vaobj: u32, first: u32, count: i32, buffers: [^]u32, offsets: [^]uintptr, strides: [^]i32)                                                                          {        impl_VertexArrayVertexBuffers(vaobj, first, count, buffers, offsets, strides)                                                                 }
+	VertexArrayAttribBinding                 :: proc "c" (vaobj: u32, attribindex: u32, bindingindex: u32)                                                                                                                    {        impl_VertexArrayAttribBinding(vaobj, attribindex, bindingindex)                                                                               }
+	VertexArrayAttribFormat                  :: proc "c" (vaobj: u32, attribindex: u32, size: i32, type: u32, normalized: bool, relativeoffset: u32)                                                                          {        impl_VertexArrayAttribFormat(vaobj, attribindex, size, type, normalized, relativeoffset)                                                     }
+	VertexArrayAttribIFormat                 :: proc "c" (vaobj: u32, attribindex: u32, size: i32, type: u32, relativeoffset: u32)                                                                                            {        impl_VertexArrayAttribIFormat(vaobj, attribindex, size, type, relativeoffset)                                                                }
+	VertexArrayAttribLFormat                 :: proc "c" (vaobj: u32, attribindex: u32, size: i32, type: u32, relativeoffset: u32)                                                                                            {        impl_VertexArrayAttribLFormat(vaobj, attribindex, size, type, relativeoffset)                                                                }
+	VertexArrayBindingDivisor                :: proc "c" (vaobj: u32, bindingindex: u32, divisor: u32)                                                                                                                        {        impl_VertexArrayBindingDivisor(vaobj, bindingindex, divisor)                                                                                  }
+	GetVertexArrayiv                         :: proc "c" (vaobj: u32, pname: u32, param: ^i32)                                                                                                                                {        impl_GetVertexArrayiv(vaobj, pname, param)                                                                                                    }
+	GetVertexArrayIndexediv                  :: proc "c" (vaobj: u32, index: u32, pname: u32, param: ^i32)                                                                                                                    {        impl_GetVertexArrayIndexediv(vaobj, index, pname, param)                                                                                      }
+	GetVertexArrayIndexed64iv                :: proc "c" (vaobj: u32, index: u32, pname: u32, param: ^i64)                                                                                                                    {        impl_GetVertexArrayIndexed64iv(vaobj, index, pname, param)                                                                                    }
+	CreateSamplers                           :: proc "c" (n: i32, samplers: [^]u32)                                                                                                                                           {        impl_CreateSamplers(n, samplers)                                                                                                              }
+	CreateProgramPipelines                   :: proc "c" (n: i32, pipelines: [^]u32)                                                                                                                                          {        impl_CreateProgramPipelines(n, pipelines)                                                                                                     }
+	CreateQueries                            :: proc "c" (target: u32, n: i32, ids: [^]u32)                                                                                                                                   {        impl_CreateQueries(target, n, ids)                                                                                                            }
+	GetQueryBufferObjecti64v                 :: proc "c" (id: u32, buffer: u32, pname: u32, offset: int)                                                                                                                      {        impl_GetQueryBufferObjecti64v(id, buffer, pname, offset)                                                                                      }
+	GetQueryBufferObjectiv                   :: proc "c" (id: u32, buffer: u32, pname: u32, offset: int)                                                                                                                      {        impl_GetQueryBufferObjectiv(id, buffer, pname, offset)                                                                                        }
+	GetQueryBufferObjectui64v                :: proc "c" (id: u32, buffer: u32, pname: u32, offset: int)                                                                                                                      {        impl_GetQueryBufferObjectui64v(id, buffer, pname, offset)                                                                                     }
+	GetQueryBufferObjectuiv                  :: proc "c" (id: u32, buffer: u32, pname: u32, offset: int)                                                                                                                      {        impl_GetQueryBufferObjectuiv(id, buffer, pname, offset)                                                                                       }
+	MemoryBarrierByRegion                    :: proc "c" (barriers: u32)                                                                                                                                                      {        impl_MemoryBarrierByRegion(barriers)                                                                                                          }
+	GetTextureSubImage                       :: proc "c" (texture: u32, level: i32, xoffset: i32, yoffset: i32, zoffset: i32, width: i32, height: i32, depth: i32, format: u32, type: u32, bufSize: i32, pixels: rawptr)      {        impl_GetTextureSubImage(texture, level, xoffset, yoffset, zoffset, width, height, depth, format, type, bufSize, pixels)                      }
+	GetCompressedTextureSubImage             :: proc "c" (texture: u32, level: i32, xoffset: i32, yoffset: i32, zoffset: i32, width: i32, height: i32, depth: i32, bufSize: i32, pixels: rawptr)                              {        impl_GetCompressedTextureSubImage(texture, level, xoffset, yoffset, zoffset, width, height, depth, bufSize, pixels)                           }
+	GetGraphicsResetStatus                   :: proc "c" () -> u32                                                                                                                                                            { ret := impl_GetGraphicsResetStatus();                                                                                                     return ret }
+	GetnCompressedTexImage                   :: proc "c" (target: u32, lod: i32, bufSize: i32, pixels: rawptr)                                                                                                                {        impl_GetnCompressedTexImage(target, lod, bufSize, pixels)                                                                                     }
+	GetnTexImage                             :: proc "c" (target: u32, level: i32, format: u32, type: u32, bufSize: i32, pixels: rawptr)                                                                                      {        impl_GetnTexImage(target, level, format, type, bufSize, pixels)                                                                              }
+	GetnUniformdv                            :: proc "c" (program: u32, location: i32, bufSize: i32, params: [^]f64)                                                                                                          {        impl_GetnUniformdv(program, location, bufSize, params)                                                                                        }
+	GetnUniformfv                            :: proc "c" (program: u32, location: i32, bufSize: i32, params: [^]f32)                                                                                                          {        impl_GetnUniformfv(program, location, bufSize, params)                                                                                        }
+	GetnUniformiv                            :: proc "c" (program: u32, location: i32, bufSize: i32, params: [^]i32)                                                                                                          {        impl_GetnUniformiv(program, location, bufSize, params)                                                                                        }
+	GetnUniformuiv                           :: proc "c" (program: u32, location: i32, bufSize: i32, params: [^]u32)                                                                                                          {        impl_GetnUniformuiv(program, location, bufSize, params)                                                                                       }
+	ReadnPixels                              :: proc "c" (x: i32, y: i32, width: i32, height: i32, format: u32, type: u32, bufSize: i32, data: rawptr)                                                                        {        impl_ReadnPixels(x, y, width, height, format, type, bufSize, data)                                                                           }
+	GetnMapdv                                :: proc "c" (target: u32, query: u32, bufSize: i32, v: [^]f64)                                                                                                                     {        impl_GetnMapdv(target, query, bufSize, v)                                                                                                     }
+	GetnMapfv                                :: proc "c" (target: u32, query: u32, bufSize: i32, v: [^]f32)                                                                                                                     {        impl_GetnMapfv(target, query, bufSize, v)                                                                                                     }
+	GetnMapiv                                :: proc "c" (target: u32, query: u32, bufSize: i32, v: [^]i32)                                                                                                                     {        impl_GetnMapiv(target, query, bufSize, v)                                                                                                     }
+	GetnPixelMapusv                          :: proc "c" (map_: u32, bufSize: i32, values: [^]u16)                                                                                                                            {        impl_GetnPixelMapusv(map_, bufSize, values)                                                                                                   }
+	GetnPixelMapfv                           :: proc "c" (map_: u32, bufSize: i32, values: [^]f32)                                                                                                                            {        impl_GetnPixelMapfv(map_, bufSize, values)                                                                                                    }
+	GetnPixelMapuiv                          :: proc "c" (map_: u32, bufSize: i32, values: [^]u32)                                                                                                                            {        impl_GetnPixelMapuiv(map_, bufSize, values)                                                                                                   }
+	GetnPolygonStipple                       :: proc "c" (bufSize: i32, pattern: [^]u8)                                                                                                                                         {        impl_GetnPolygonStipple(bufSize, pattern)                                                                                                     }
+	GetnColorTable                           :: proc "c" (target: u32, format: u32, type: u32, bufSize: i32, table: rawptr)                                                                                                   {        impl_GetnColorTable(target, format, type, bufSize, table)                                                                                    }
+	GetnConvolutionFilter                    :: proc "c" (target: u32, format: u32, type: u32, bufSize: i32, image: rawptr)                                                                                                   {        impl_GetnConvolutionFilter(target, format, type, bufSize, image)                                                                             }
+	GetnSeparableFilter                      :: proc "c" (target: u32, format: u32, type: u32, rowBufSize: i32, row: rawptr, columnBufSize: i32, column: rawptr, span: rawptr)                                                {        impl_GetnSeparableFilter(target, format, type, rowBufSize, row, columnBufSize, column, span)                                                 }
+	GetnHistogram                            :: proc "c" (target: u32, reset: bool, format: u32, type: u32, bufSize: i32, values: rawptr)                                                                                     {        impl_GetnHistogram(target, reset, format, type, bufSize, values)                                                                             }
+	GetnMinmax                               :: proc "c" (target: u32, reset: bool, format: u32, type: u32, bufSize: i32, values: rawptr)                                                                                     {        impl_GetnMinmax(target, reset, format, type, bufSize, values)                                                                                }
+	TextureBarrier                           :: proc "c" ()                                                                                                                                                                   {        impl_TextureBarrier()                                                                                                                         }
+	GetUnsignedBytevEXT                      :: proc "c" (pname: u32, data: ^byte)                                                                                                                                            {        impl_GetUnsignedBytevEXT(pname, data)                                                                                                         }
+	TexPageCommitmentARB                     :: proc "c"(target: u32, level: i32, xoffset: i32, yoffset: i32, zoffset: i32, width: i32, height: i32, depth: i32, commit: bool)                                                {        impl_TexPageCommitmentARB(target, level, xoffset, yoffset, zoffset, width, height, depth, commit)                                             }
 
 	// VERSION_4_6
-	SpecializeShader               :: #force_inline proc "c" (shader: u32, pEntryPoint: cstring, numSpecializationConstants: u32, pConstantIndex: ^u32, pConstantValue: ^u32) { impl_SpecializeShader(shader, pEntryPoint, numSpecializationConstants, pConstantIndex, pConstantValue) }
-	MultiDrawArraysIndirectCount   :: #force_inline proc "c" (mode: i32, indirect: [^]DrawArraysIndirectCommand, drawcount: i32, maxdrawcount, stride: i32)                   { impl_MultiDrawArraysIndirectCount(mode, indirect, drawcount, maxdrawcount, stride)                     }
-	MultiDrawElementsIndirectCount :: #force_inline proc "c" (mode: i32, type: i32, indirect: [^]DrawElementsIndirectCommand, drawcount: i32, maxdrawcount, stride: i32)      { impl_MultiDrawElementsIndirectCount(mode, type, indirect, drawcount, maxdrawcount, stride)             }
-	PolygonOffsetClamp             :: #force_inline proc "c" (factor, units, clamp: f32)                                                                                      { impl_PolygonOffsetClamp(factor, units, clamp)                                                          }
+	SpecializeShader               :: proc "c" (shader: u32, pEntryPoint: cstring, numSpecializationConstants: u32, pConstantIndex: ^u32, pConstantValue: ^u32) { impl_SpecializeShader(shader, pEntryPoint, numSpecializationConstants, pConstantIndex, pConstantValue) }
+	MultiDrawArraysIndirectCount   :: proc "c" (mode: i32, indirect: [^]DrawArraysIndirectCommand, drawcount: i32, maxdrawcount, stride: i32)                   { impl_MultiDrawArraysIndirectCount(mode, indirect, drawcount, maxdrawcount, stride)                     }
+	MultiDrawElementsIndirectCount :: proc "c" (mode: i32, type: i32, indirect: [^]DrawElementsIndirectCommand, drawcount: i32, maxdrawcount, stride: i32)      { impl_MultiDrawElementsIndirectCount(mode, type, indirect, drawcount, maxdrawcount, stride)             }
+	PolygonOffsetClamp             :: proc "c" (factor, units, clamp: f32)                                                                                      { impl_PolygonOffsetClamp(factor, units, clamp)                                                          }
 } else {
 	import "core:runtime"
 	import "core:fmt"
 
-	debug_helper :: #force_inline proc"c"(from_loc: runtime.Source_Code_Location, num_ret: int, args: ..any, loc := #caller_location) {
+	debug_helper :: proc"c"(from_loc: runtime.Source_Code_Location, num_ret: int, args: ..any, loc := #caller_location) {
 		context = runtime.default_context()
 
 		Error_Enum :: enum {
@@ -805,740 +805,740 @@ when !ODIN_DEBUG {
 		}
 	}
 
-	CullFace               :: #force_inline proc "c" (mode: u32, loc := #caller_location)                                                                                         {        impl_CullFace(mode);                                                                         debug_helper(loc, 0, mode)                                                                                   }
-	FrontFace              :: #force_inline proc "c" (mode: u32, loc := #caller_location)                                                                                         {        impl_FrontFace(mode);                                                                        debug_helper(loc, 0, mode)                                                                                   }
-	Hint                   :: #force_inline proc "c" (target, mode: u32, loc := #caller_location)                                                                                 {        impl_Hint(target, mode);                                                                     debug_helper(loc, 0, target, mode)                                                                           }
-	LineWidth              :: #force_inline proc "c" (width: f32, loc := #caller_location)                                                                                        {        impl_LineWidth(width);                                                                       debug_helper(loc, 0, width)                                                                                  }
-	PointSize              :: #force_inline proc "c" (size: f32, loc := #caller_location)                                                                                         {        impl_PointSize(size);                                                                        debug_helper(loc, 0, size)                                                                                   }
-	PolygonMode            :: #force_inline proc "c" (face, mode: u32, loc := #caller_location)                                                                                   {        impl_PolygonMode(face, mode);                                                                debug_helper(loc, 0, face, mode)                                                                             }
-	Scissor                :: #force_inline proc "c" (x, y, width, height: i32, loc := #caller_location)                                                                          {        impl_Scissor(x, y, width, height);                                                           debug_helper(loc, 0, x, y, width, height)                                                                    }
-	TexParameterf          :: #force_inline proc "c" (target, pname: u32, param: f32, loc := #caller_location)                                                                    {        impl_TexParameterf(target, pname, param);                                                    debug_helper(loc, 0, target, pname, param)                                                                   }
-	TexParameterfv         :: #force_inline proc "c" (target, pname: u32, params: [^]f32, loc := #caller_location)                                                                {        impl_TexParameterfv(target, pname, params);                                                  debug_helper(loc, 0, target, pname, params)                                                                  }
-	TexParameteri          :: #force_inline proc "c" (target, pname: u32, param: i32, loc := #caller_location)                                                                    {        impl_TexParameteri(target, pname, param);                                                    debug_helper(loc, 0, target, pname, param)                                                                   }
-	TexParameteriv         :: #force_inline proc "c" (target, pname: u32, params: [^]i32, loc := #caller_location)                                                                {        impl_TexParameteriv(target, pname, params);                                                  debug_helper(loc, 0, target, pname, params)                                                                  }
-	TexImage1D             :: #force_inline proc "c" (target: u32, level, internalformat, width, border: i32, format, type: u32, pixels: rawptr, loc := #caller_location)         {        impl_TexImage1D(target, level, internalformat, width, border, format, type, pixels);         debug_helper(loc, 0, target, level, internalformat, width, border, format, type, pixels)                     }
-	TexImage2D             :: #force_inline proc "c" (target: u32, level, internalformat, width, height, border: i32, format, type: u32, pixels: rawptr, loc := #caller_location) {        impl_TexImage2D(target, level, internalformat, width, height, border, format, type, pixels); debug_helper(loc, 0, target, level, internalformat, width, height, border, format, type, pixels)             }
-	DrawBuffer             :: #force_inline proc "c" (buf: u32, loc := #caller_location)                                                                                          {        impl_DrawBuffer(buf);                                                                        debug_helper(loc, 0, buf)                                                                                    }
-	Clear                  :: #force_inline proc "c" (mask: u32, loc := #caller_location)                                                                                         {        impl_Clear(mask);                                                                            debug_helper(loc, 0, mask)                                                                                   }
-	ClearColor             :: #force_inline proc "c" (red, green, blue, alpha: f32, loc := #caller_location)                                                                      {        impl_ClearColor(red, green, blue, alpha);                                                    debug_helper(loc, 0, red, green, blue, alpha)                                                                }
-	ClearStencil           :: #force_inline proc "c" (s: i32, loc := #caller_location)                                                                                            {        impl_ClearStencil(s);                                                                        debug_helper(loc, 0, s)                                                                                      }
-	ClearDepth             :: #force_inline proc "c" (depth: f64, loc := #caller_location)                                                                                        {        impl_ClearDepth(depth);                                                                      debug_helper(loc, 0, depth)                                                                                  }
-	StencilMask            :: #force_inline proc "c" (mask: u32, loc := #caller_location)                                                                                         {        impl_StencilMask(mask);                                                                      debug_helper(loc, 0, mask)                                                                                   }
-	ColorMask              :: #force_inline proc "c" (red, green, blue, alpha: bool, loc := #caller_location)                                                                     {        impl_ColorMask(red, green, blue, alpha);                                                     debug_helper(loc, 0, red, green, blue, alpha)                                                                }
-	DepthMask              :: #force_inline proc "c" (flag: bool, loc := #caller_location)                                                                                        {        impl_DepthMask(flag);                                                                        debug_helper(loc, 0, flag)                                                                                   }
-	Disable                :: #force_inline proc "c" (cap: u32, loc := #caller_location)                                                                                          {        impl_Disable(cap);                                                                           debug_helper(loc, 0, cap)                                                                                    }
-	Enable                 :: #force_inline proc "c" (cap: u32, loc := #caller_location)                                                                                          {        impl_Enable(cap);                                                                            debug_helper(loc, 0, cap)                                                                                    }
-	Finish                 :: #force_inline proc "c" (loc := #caller_location)                                                                                                    {        impl_Finish();                                                                               debug_helper(loc, 0)                                                                                         }
-	Flush                  :: #force_inline proc "c" (loc := #caller_location)                                                                                                    {        impl_Flush();                                                                                debug_helper(loc, 0)                                                                                         }
-	BlendFunc              :: #force_inline proc "c" (sfactor, dfactor: u32, loc := #caller_location)                                                                             {        impl_BlendFunc(sfactor, dfactor);                                                            debug_helper(loc, 0, sfactor, dfactor)                                                                       }
-	LogicOp                :: #force_inline proc "c" (opcode: u32, loc := #caller_location)                                                                                       {        impl_LogicOp(opcode);                                                                        debug_helper(loc, 0, opcode)                                                                                 }
-	StencilFunc            :: #force_inline proc "c" (func: u32, ref: i32, mask: u32, loc := #caller_location)                                                                    {        impl_StencilFunc(func, ref, mask);                                                           debug_helper(loc, 0, func, ref, mask)                                                                        }
-	StencilOp              :: #force_inline proc "c" (fail, zfail, zpass: u32, loc := #caller_location)                                                                           {        impl_StencilOp(fail, zfail, zpass);                                                          debug_helper(loc, 0, fail, zfail, zpass)                                                                     }
-	DepthFunc              :: #force_inline proc "c" (func: u32, loc := #caller_location)                                                                                         {        impl_DepthFunc(func);                                                                        debug_helper(loc, 0, func)                                                                                   }
-	PixelStoref            :: #force_inline proc "c" (pname: u32, param: f32, loc := #caller_location)                                                                            {        impl_PixelStoref(pname, param);                                                              debug_helper(loc, 0, pname, param)                                                                           }
-	PixelStorei            :: #force_inline proc "c" (pname: u32, param: i32, loc := #caller_location)                                                                            {        impl_PixelStorei(pname, param);                                                              debug_helper(loc, 0, pname, param)                                                                           }
-	ReadBuffer             :: #force_inline proc "c" (src: u32, loc := #caller_location)                                                                                          {        impl_ReadBuffer(src);                                                                        debug_helper(loc, 0, src)                                                                                    }
-	ReadPixels             :: #force_inline proc "c" (x, y, width, height: i32, format, type: u32, pixels: rawptr, loc := #caller_location)                                       {        impl_ReadPixels(x, y, width, height, format, type, pixels);                                  debug_helper(loc, 0, x, y, width, height, format, type, pixels)                                              }
-	GetBooleanv            :: #force_inline proc "c" (pname: u32, data: ^bool, loc := #caller_location)                                                                           {        impl_GetBooleanv(pname, data);                                                               debug_helper(loc, 0, pname, data)                                                                            }
-	GetDoublev             :: #force_inline proc "c" (pname: u32, data: ^f64, loc := #caller_location)                                                                            {        impl_GetDoublev(pname, data);                                                                debug_helper(loc, 0, pname, data)                                                                            }
-	GetError               :: #force_inline proc "c" (loc := #caller_location) -> u32                                                                                             { ret := impl_GetError();                                                                             debug_helper(loc, 1, ret);                                                                        return ret }
-	GetFloatv              :: #force_inline proc "c" (pname: u32, data: ^f32, loc := #caller_location)                                                                            {        impl_GetFloatv(pname, data);                                                                 debug_helper(loc, 0, pname, data)                                                                            }
-	GetIntegerv            :: #force_inline proc "c" (pname: u32, data: ^i32, loc := #caller_location)                                                                            {        impl_GetIntegerv(pname, data);                                                               debug_helper(loc, 0, pname, data)                                                                            }
-	GetString              :: #force_inline proc "c" (name: u32, loc := #caller_location) -> cstring                                                                              { ret := impl_GetString(name);                                                                        debug_helper(loc, 1, ret, name);                                                                  return ret }
-	GetTexImage            :: #force_inline proc "c" (target: u32,  level: i32, format, type: u32, pixels: rawptr, loc := #caller_location)                                       {        impl_GetTexImage(target,  level, format, type, pixels);                                      debug_helper(loc, 0, target,  level, format, type, pixels)                                                   }
-	GetTexParameterfv      :: #force_inline proc "c" (target, pname: u32, params: [^]f32, loc := #caller_location)                                                                {        impl_GetTexParameterfv(target, pname, params);                                               debug_helper(loc, 0, target, pname, params)                                                                  }
-	GetTexParameteriv      :: #force_inline proc "c" (target, pname: u32, params: [^]i32, loc := #caller_location)                                                                {        impl_GetTexParameteriv(target, pname, params);                                               debug_helper(loc, 0, target, pname, params)                                                                  }
-	GetTexLevelParameterfv :: #force_inline proc "c" (target: u32, level: i32, pname: u32, params: [^]f32, loc := #caller_location)                                               {        impl_GetTexLevelParameterfv(target, level, pname, params);                                   debug_helper(loc, 0, target, level, pname, params)                                                           }
-	GetTexLevelParameteriv :: #force_inline proc "c" (target: u32, level: i32, pname: u32, params: [^]i32, loc := #caller_location)                                               {        impl_GetTexLevelParameteriv(target, level, pname, params);                                   debug_helper(loc, 0, target, level, pname, params)                                                           }
-	IsEnabled              :: #force_inline proc "c" (cap: u32, loc := #caller_location) -> bool                                                                                  { ret := impl_IsEnabled(cap);                                                                         debug_helper(loc, 1, ret, cap);                                                                   return ret }
-	DepthRange             :: #force_inline proc "c" (near, far: f64, loc := #caller_location)                                                                                    {        impl_DepthRange(near, far);                                                                  debug_helper(loc, 0, near, far)                                                                              }
-	Viewport               :: #force_inline proc "c" (x, y, width, height: i32, loc := #caller_location)                                                                          {        impl_Viewport(x, y, width, height);                                                          debug_helper(loc, 0, x, y, width, height)                                                                    }
+	CullFace               :: proc "c" (mode: u32, loc := #caller_location)                                                                                         {        impl_CullFace(mode);                                                                         debug_helper(loc, 0, mode)                                                                                   }
+	FrontFace              :: proc "c" (mode: u32, loc := #caller_location)                                                                                         {        impl_FrontFace(mode);                                                                        debug_helper(loc, 0, mode)                                                                                   }
+	Hint                   :: proc "c" (target, mode: u32, loc := #caller_location)                                                                                 {        impl_Hint(target, mode);                                                                     debug_helper(loc, 0, target, mode)                                                                           }
+	LineWidth              :: proc "c" (width: f32, loc := #caller_location)                                                                                        {        impl_LineWidth(width);                                                                       debug_helper(loc, 0, width)                                                                                  }
+	PointSize              :: proc "c" (size: f32, loc := #caller_location)                                                                                         {        impl_PointSize(size);                                                                        debug_helper(loc, 0, size)                                                                                   }
+	PolygonMode            :: proc "c" (face, mode: u32, loc := #caller_location)                                                                                   {        impl_PolygonMode(face, mode);                                                                debug_helper(loc, 0, face, mode)                                                                             }
+	Scissor                :: proc "c" (x, y, width, height: i32, loc := #caller_location)                                                                          {        impl_Scissor(x, y, width, height);                                                           debug_helper(loc, 0, x, y, width, height)                                                                    }
+	TexParameterf          :: proc "c" (target, pname: u32, param: f32, loc := #caller_location)                                                                    {        impl_TexParameterf(target, pname, param);                                                    debug_helper(loc, 0, target, pname, param)                                                                   }
+	TexParameterfv         :: proc "c" (target, pname: u32, params: [^]f32, loc := #caller_location)                                                                {        impl_TexParameterfv(target, pname, params);                                                  debug_helper(loc, 0, target, pname, params)                                                                  }
+	TexParameteri          :: proc "c" (target, pname: u32, param: i32, loc := #caller_location)                                                                    {        impl_TexParameteri(target, pname, param);                                                    debug_helper(loc, 0, target, pname, param)                                                                   }
+	TexParameteriv         :: proc "c" (target, pname: u32, params: [^]i32, loc := #caller_location)                                                                {        impl_TexParameteriv(target, pname, params);                                                  debug_helper(loc, 0, target, pname, params)                                                                  }
+	TexImage1D             :: proc "c" (target: u32, level, internalformat, width, border: i32, format, type: u32, pixels: rawptr, loc := #caller_location)         {        impl_TexImage1D(target, level, internalformat, width, border, format, type, pixels);         debug_helper(loc, 0, target, level, internalformat, width, border, format, type, pixels)                     }
+	TexImage2D             :: proc "c" (target: u32, level, internalformat, width, height, border: i32, format, type: u32, pixels: rawptr, loc := #caller_location) {        impl_TexImage2D(target, level, internalformat, width, height, border, format, type, pixels); debug_helper(loc, 0, target, level, internalformat, width, height, border, format, type, pixels)             }
+	DrawBuffer             :: proc "c" (buf: u32, loc := #caller_location)                                                                                          {        impl_DrawBuffer(buf);                                                                        debug_helper(loc, 0, buf)                                                                                    }
+	Clear                  :: proc "c" (mask: u32, loc := #caller_location)                                                                                         {        impl_Clear(mask);                                                                            debug_helper(loc, 0, mask)                                                                                   }
+	ClearColor             :: proc "c" (red, green, blue, alpha: f32, loc := #caller_location)                                                                      {        impl_ClearColor(red, green, blue, alpha);                                                    debug_helper(loc, 0, red, green, blue, alpha)                                                                }
+	ClearStencil           :: proc "c" (s: i32, loc := #caller_location)                                                                                            {        impl_ClearStencil(s);                                                                        debug_helper(loc, 0, s)                                                                                      }
+	ClearDepth             :: proc "c" (depth: f64, loc := #caller_location)                                                                                        {        impl_ClearDepth(depth);                                                                      debug_helper(loc, 0, depth)                                                                                  }
+	StencilMask            :: proc "c" (mask: u32, loc := #caller_location)                                                                                         {        impl_StencilMask(mask);                                                                      debug_helper(loc, 0, mask)                                                                                   }
+	ColorMask              :: proc "c" (red, green, blue, alpha: bool, loc := #caller_location)                                                                     {        impl_ColorMask(red, green, blue, alpha);                                                     debug_helper(loc, 0, red, green, blue, alpha)                                                                }
+	DepthMask              :: proc "c" (flag: bool, loc := #caller_location)                                                                                        {        impl_DepthMask(flag);                                                                        debug_helper(loc, 0, flag)                                                                                   }
+	Disable                :: proc "c" (cap: u32, loc := #caller_location)                                                                                          {        impl_Disable(cap);                                                                           debug_helper(loc, 0, cap)                                                                                    }
+	Enable                 :: proc "c" (cap: u32, loc := #caller_location)                                                                                          {        impl_Enable(cap);                                                                            debug_helper(loc, 0, cap)                                                                                    }
+	Finish                 :: proc "c" (loc := #caller_location)                                                                                                    {        impl_Finish();                                                                               debug_helper(loc, 0)                                                                                         }
+	Flush                  :: proc "c" (loc := #caller_location)                                                                                                    {        impl_Flush();                                                                                debug_helper(loc, 0)                                                                                         }
+	BlendFunc              :: proc "c" (sfactor, dfactor: u32, loc := #caller_location)                                                                             {        impl_BlendFunc(sfactor, dfactor);                                                            debug_helper(loc, 0, sfactor, dfactor)                                                                       }
+	LogicOp                :: proc "c" (opcode: u32, loc := #caller_location)                                                                                       {        impl_LogicOp(opcode);                                                                        debug_helper(loc, 0, opcode)                                                                                 }
+	StencilFunc            :: proc "c" (func: u32, ref: i32, mask: u32, loc := #caller_location)                                                                    {        impl_StencilFunc(func, ref, mask);                                                           debug_helper(loc, 0, func, ref, mask)                                                                        }
+	StencilOp              :: proc "c" (fail, zfail, zpass: u32, loc := #caller_location)                                                                           {        impl_StencilOp(fail, zfail, zpass);                                                          debug_helper(loc, 0, fail, zfail, zpass)                                                                     }
+	DepthFunc              :: proc "c" (func: u32, loc := #caller_location)                                                                                         {        impl_DepthFunc(func);                                                                        debug_helper(loc, 0, func)                                                                                   }
+	PixelStoref            :: proc "c" (pname: u32, param: f32, loc := #caller_location)                                                                            {        impl_PixelStoref(pname, param);                                                              debug_helper(loc, 0, pname, param)                                                                           }
+	PixelStorei            :: proc "c" (pname: u32, param: i32, loc := #caller_location)                                                                            {        impl_PixelStorei(pname, param);                                                              debug_helper(loc, 0, pname, param)                                                                           }
+	ReadBuffer             :: proc "c" (src: u32, loc := #caller_location)                                                                                          {        impl_ReadBuffer(src);                                                                        debug_helper(loc, 0, src)                                                                                    }
+	ReadPixels             :: proc "c" (x, y, width, height: i32, format, type: u32, pixels: rawptr, loc := #caller_location)                                       {        impl_ReadPixels(x, y, width, height, format, type, pixels);                                  debug_helper(loc, 0, x, y, width, height, format, type, pixels)                                              }
+	GetBooleanv            :: proc "c" (pname: u32, data: ^bool, loc := #caller_location)                                                                           {        impl_GetBooleanv(pname, data);                                                               debug_helper(loc, 0, pname, data)                                                                            }
+	GetDoublev             :: proc "c" (pname: u32, data: ^f64, loc := #caller_location)                                                                            {        impl_GetDoublev(pname, data);                                                                debug_helper(loc, 0, pname, data)                                                                            }
+	GetError               :: proc "c" (loc := #caller_location) -> u32                                                                                             { ret := impl_GetError();                                                                             debug_helper(loc, 1, ret);                                                                        return ret }
+	GetFloatv              :: proc "c" (pname: u32, data: ^f32, loc := #caller_location)                                                                            {        impl_GetFloatv(pname, data);                                                                 debug_helper(loc, 0, pname, data)                                                                            }
+	GetIntegerv            :: proc "c" (pname: u32, data: ^i32, loc := #caller_location)                                                                            {        impl_GetIntegerv(pname, data);                                                               debug_helper(loc, 0, pname, data)                                                                            }
+	GetString              :: proc "c" (name: u32, loc := #caller_location) -> cstring                                                                              { ret := impl_GetString(name);                                                                        debug_helper(loc, 1, ret, name);                                                                  return ret }
+	GetTexImage            :: proc "c" (target: u32,  level: i32, format, type: u32, pixels: rawptr, loc := #caller_location)                                       {        impl_GetTexImage(target,  level, format, type, pixels);                                      debug_helper(loc, 0, target,  level, format, type, pixels)                                                   }
+	GetTexParameterfv      :: proc "c" (target, pname: u32, params: [^]f32, loc := #caller_location)                                                                {        impl_GetTexParameterfv(target, pname, params);                                               debug_helper(loc, 0, target, pname, params)                                                                  }
+	GetTexParameteriv      :: proc "c" (target, pname: u32, params: [^]i32, loc := #caller_location)                                                                {        impl_GetTexParameteriv(target, pname, params);                                               debug_helper(loc, 0, target, pname, params)                                                                  }
+	GetTexLevelParameterfv :: proc "c" (target: u32, level: i32, pname: u32, params: [^]f32, loc := #caller_location)                                               {        impl_GetTexLevelParameterfv(target, level, pname, params);                                   debug_helper(loc, 0, target, level, pname, params)                                                           }
+	GetTexLevelParameteriv :: proc "c" (target: u32, level: i32, pname: u32, params: [^]i32, loc := #caller_location)                                               {        impl_GetTexLevelParameteriv(target, level, pname, params);                                   debug_helper(loc, 0, target, level, pname, params)                                                           }
+	IsEnabled              :: proc "c" (cap: u32, loc := #caller_location) -> bool                                                                                  { ret := impl_IsEnabled(cap);                                                                         debug_helper(loc, 1, ret, cap);                                                                   return ret }
+	DepthRange             :: proc "c" (near, far: f64, loc := #caller_location)                                                                                    {        impl_DepthRange(near, far);                                                                  debug_helper(loc, 0, near, far)                                                                              }
+	Viewport               :: proc "c" (x, y, width, height: i32, loc := #caller_location)                                                                          {        impl_Viewport(x, y, width, height);                                                          debug_helper(loc, 0, x, y, width, height)                                                                    }
 
 	// VERSION_1_1
-	DrawArrays        :: #force_inline proc "c" (mode: u32, first: i32, count: i32, loc := #caller_location)                                                                                    {        impl_DrawArrays(mode, first, count);                                                      debug_helper(loc, 0, mode, first, count)                                                               }
-	DrawElements      :: #force_inline proc "c" (mode: u32, count: i32, type: u32, indices: rawptr, loc := #caller_location)                                                                    {        impl_DrawElements(mode, count, type, indices);                                            debug_helper(loc, 0, mode, count, type, indices)                                                       }
-	PolygonOffset     :: #force_inline proc "c" (factor: f32, units: f32, loc := #caller_location)                                                                                              {        impl_PolygonOffset(factor, units);                                                        debug_helper(loc, 0, factor, units)                                                                    }
-	CopyTexImage1D    :: #force_inline proc "c" (target: u32, level: i32, internalformat: u32, x: i32, y: i32, width: i32, border: i32, loc := #caller_location)                                {        impl_CopyTexImage1D(target, level, internalformat, x, y, width, border);                  debug_helper(loc, 0, target, level, internalformat, x, y, width, border)                               }
-	CopyTexImage2D    :: #force_inline proc "c" (target: u32, level: i32, internalformat: u32, x: i32, y: i32, width: i32, height: i32, border: i32, loc := #caller_location)                   {        impl_CopyTexImage2D(target, level, internalformat, x, y, width, height, border);          debug_helper(loc, 0, target, level, internalformat, x, y, width, height, border)                       }
-	CopyTexSubImage1D :: #force_inline proc "c" (target: u32, level: i32, xoffset: i32, x: i32, y: i32, width: i32, loc := #caller_location)                                                    {        impl_CopyTexSubImage1D(target, level, xoffset, x, y, width);                              debug_helper(loc, 0, target, level, xoffset, x, y, width)                                              }
-	CopyTexSubImage2D :: #force_inline proc "c" (target: u32, level: i32, xoffset: i32, yoffset: i32, x: i32, y: i32, width: i32, height: i32, loc := #caller_location)                         {        impl_CopyTexSubImage2D(target, level, xoffset, yoffset, x, y, width, height);             debug_helper(loc, 0, target, level, xoffset, yoffset, x, y, width, height)                             }
-	TexSubImage1D     :: #force_inline proc "c" (target: u32, level: i32, xoffset: i32, width: i32, format: u32, type: u32, pixels: rawptr, loc := #caller_location)                            {        impl_TexSubImage1D(target, level, xoffset, width, format, type, pixels);                  debug_helper(loc, 0, target, level, xoffset, width, format, type, pixels)                              }
-	TexSubImage2D     :: #force_inline proc "c" (target: u32, level: i32, xoffset: i32, yoffset: i32, width: i32, height: i32, format: u32, type: u32, pixels: rawptr, loc := #caller_location) {        impl_TexSubImage2D(target, level, xoffset, yoffset, width, height, format, type, pixels); debug_helper(loc, 0, target, level, xoffset, yoffset, width, height, format, type, pixels)             }
-	BindTexture       :: #force_inline proc "c" (target: u32, texture: u32, loc := #caller_location)                                                                                            {        impl_BindTexture(target, texture);                                                        debug_helper(loc, 0, target, texture)                                                                  }
-	DeleteTextures    :: #force_inline proc "c" (n: i32, textures: [^]u32, loc := #caller_location)                                                                                             {        impl_DeleteTextures(n, textures);                                                         debug_helper(loc, 0, n, textures)                                                                      }
-	GenTextures       :: #force_inline proc "c" (n: i32, textures: [^]u32, loc := #caller_location)                                                                                             {        impl_GenTextures(n, textures);                                                            debug_helper(loc, 0, n, textures)                                                                      }
-	IsTexture         :: #force_inline proc "c" (texture: u32, loc := #caller_location) -> bool                                                                                                 { ret := impl_IsTexture(texture);                                                                  debug_helper(loc, 1, ret, texture);                                                         return ret }
+	DrawArrays        :: proc "c" (mode: u32, first: i32, count: i32, loc := #caller_location)                                                                                    {        impl_DrawArrays(mode, first, count);                                                      debug_helper(loc, 0, mode, first, count)                                                               }
+	DrawElements      :: proc "c" (mode: u32, count: i32, type: u32, indices: rawptr, loc := #caller_location)                                                                    {        impl_DrawElements(mode, count, type, indices);                                            debug_helper(loc, 0, mode, count, type, indices)                                                       }
+	PolygonOffset     :: proc "c" (factor: f32, units: f32, loc := #caller_location)                                                                                              {        impl_PolygonOffset(factor, units);                                                        debug_helper(loc, 0, factor, units)                                                                    }
+	CopyTexImage1D    :: proc "c" (target: u32, level: i32, internalformat: u32, x: i32, y: i32, width: i32, border: i32, loc := #caller_location)                                {        impl_CopyTexImage1D(target, level, internalformat, x, y, width, border);                  debug_helper(loc, 0, target, level, internalformat, x, y, width, border)                               }
+	CopyTexImage2D    :: proc "c" (target: u32, level: i32, internalformat: u32, x: i32, y: i32, width: i32, height: i32, border: i32, loc := #caller_location)                   {        impl_CopyTexImage2D(target, level, internalformat, x, y, width, height, border);          debug_helper(loc, 0, target, level, internalformat, x, y, width, height, border)                       }
+	CopyTexSubImage1D :: proc "c" (target: u32, level: i32, xoffset: i32, x: i32, y: i32, width: i32, loc := #caller_location)                                                    {        impl_CopyTexSubImage1D(target, level, xoffset, x, y, width);                              debug_helper(loc, 0, target, level, xoffset, x, y, width)                                              }
+	CopyTexSubImage2D :: proc "c" (target: u32, level: i32, xoffset: i32, yoffset: i32, x: i32, y: i32, width: i32, height: i32, loc := #caller_location)                         {        impl_CopyTexSubImage2D(target, level, xoffset, yoffset, x, y, width, height);             debug_helper(loc, 0, target, level, xoffset, yoffset, x, y, width, height)                             }
+	TexSubImage1D     :: proc "c" (target: u32, level: i32, xoffset: i32, width: i32, format: u32, type: u32, pixels: rawptr, loc := #caller_location)                            {        impl_TexSubImage1D(target, level, xoffset, width, format, type, pixels);                  debug_helper(loc, 0, target, level, xoffset, width, format, type, pixels)                              }
+	TexSubImage2D     :: proc "c" (target: u32, level: i32, xoffset: i32, yoffset: i32, width: i32, height: i32, format: u32, type: u32, pixels: rawptr, loc := #caller_location) {        impl_TexSubImage2D(target, level, xoffset, yoffset, width, height, format, type, pixels); debug_helper(loc, 0, target, level, xoffset, yoffset, width, height, format, type, pixels)             }
+	BindTexture       :: proc "c" (target: u32, texture: u32, loc := #caller_location)                                                                                            {        impl_BindTexture(target, texture);                                                        debug_helper(loc, 0, target, texture)                                                                  }
+	DeleteTextures    :: proc "c" (n: i32, textures: [^]u32, loc := #caller_location)                                                                                             {        impl_DeleteTextures(n, textures);                                                         debug_helper(loc, 0, n, textures)                                                                      }
+	GenTextures       :: proc "c" (n: i32, textures: [^]u32, loc := #caller_location)                                                                                             {        impl_GenTextures(n, textures);                                                            debug_helper(loc, 0, n, textures)                                                                      }
+	IsTexture         :: proc "c" (texture: u32, loc := #caller_location) -> bool                                                                                                 { ret := impl_IsTexture(texture);                                                                  debug_helper(loc, 1, ret, texture);                                                         return ret }
 
 	// VERSION_1_2
-	DrawRangeElements :: #force_inline proc "c" (mode, start, end: u32, count: i32, type: u32, indices: rawptr, loc := #caller_location)                                               { impl_DrawRangeElements(mode, start, end, count, type, indices);                                           debug_helper(loc, 0, mode, start, end, count, type, indices)                                               }
-	TexImage3D        :: #force_inline proc "c" (target: u32, level, internalformat, width, height, depth, border: i32, format, type: u32, pixels: rawptr, loc := #caller_location)    { impl_TexImage3D(target, level, internalformat, width, height, depth, border, format, type, pixels);       debug_helper(loc, 0, target, level, internalformat, width, height, depth, border, format, type, pixels)    }
-	TexSubImage3D     :: #force_inline proc "c" (target: u32, level, xoffset, yoffset, zoffset, width, height, depth: i32, format, type: u32, pixels: rawptr, loc := #caller_location) { impl_TexSubImage3D(target, level, xoffset, yoffset, zoffset, width, height, depth, format, type, pixels); debug_helper(loc, 0, target, level, xoffset, yoffset, zoffset, width, height, depth, format, type, pixels) }
-	CopyTexSubImage3D :: #force_inline proc "c" (target: u32, level, xoffset, yoffset, zoffset, x, y, width, height: i32, loc := #caller_location)                                     { impl_CopyTexSubImage3D(target, level, xoffset, yoffset, zoffset, x, y, width, height);                    debug_helper(loc, 0, target, level, xoffset, yoffset, zoffset, x, y, width, height)                        }
+	DrawRangeElements :: proc "c" (mode, start, end: u32, count: i32, type: u32, indices: rawptr, loc := #caller_location)                                               { impl_DrawRangeElements(mode, start, end, count, type, indices);                                           debug_helper(loc, 0, mode, start, end, count, type, indices)                                               }
+	TexImage3D        :: proc "c" (target: u32, level, internalformat, width, height, depth, border: i32, format, type: u32, pixels: rawptr, loc := #caller_location)    { impl_TexImage3D(target, level, internalformat, width, height, depth, border, format, type, pixels);       debug_helper(loc, 0, target, level, internalformat, width, height, depth, border, format, type, pixels)    }
+	TexSubImage3D     :: proc "c" (target: u32, level, xoffset, yoffset, zoffset, width, height, depth: i32, format, type: u32, pixels: rawptr, loc := #caller_location) { impl_TexSubImage3D(target, level, xoffset, yoffset, zoffset, width, height, depth, format, type, pixels); debug_helper(loc, 0, target, level, xoffset, yoffset, zoffset, width, height, depth, format, type, pixels) }
+	CopyTexSubImage3D :: proc "c" (target: u32, level, xoffset, yoffset, zoffset, x, y, width, height: i32, loc := #caller_location)                                     { impl_CopyTexSubImage3D(target, level, xoffset, yoffset, zoffset, x, y, width, height);                    debug_helper(loc, 0, target, level, xoffset, yoffset, zoffset, x, y, width, height)                        }
 
 	// VERSION_1_3
-	ActiveTexture           :: #force_inline proc "c" (texture: u32, loc := #caller_location)                                                                                                                                      { impl_ActiveTexture(texture);                                                                                           debug_helper(loc, 0, texture)                                                                                 }
-	SampleCoverage          :: #force_inline proc "c" (value: f32, invert: bool, loc := #caller_location)                                                                                                                          { impl_SampleCoverage(value, invert);                                                                                    debug_helper(loc, 0, value, invert)                                                                           }
-	CompressedTexImage3D    :: #force_inline proc "c" (target: u32, level: i32, internalformat: u32, width: i32, height: i32, depth: i32, border: i32, imageSize: i32, data: rawptr, loc := #caller_location)                      { impl_CompressedTexImage3D(target, level, internalformat, width, height, depth, border, imageSize, data);               debug_helper(loc, 0, target, level, internalformat, width, height, depth, border, imageSize, data)            }
-	CompressedTexImage2D    :: #force_inline proc "c" (target: u32, level: i32, internalformat: u32, width: i32, height: i32, border: i32, imageSize: i32, data: rawptr, loc := #caller_location)                                  { impl_CompressedTexImage2D(target, level, internalformat, width, height, border, imageSize, data);                      debug_helper(loc, 0, target, level, internalformat, width, height, border, imageSize, data)                   }
-	CompressedTexImage1D    :: #force_inline proc "c" (target: u32, level: i32, internalformat: u32, width: i32, border: i32, imageSize: i32, data: rawptr, loc := #caller_location)                                               { impl_CompressedTexImage1D(target, level, internalformat, width, border, imageSize, data);                              debug_helper(loc, 0, target, level, internalformat, width, border, imageSize, data)                           }
-	CompressedTexSubImage3D :: #force_inline proc "c" (target: u32, level: i32, xoffset: i32, yoffset: i32, zoffset: i32, width: i32, height: i32, depth: i32, format: u32, imageSize: i32, data: rawptr, loc := #caller_location) { impl_CompressedTexSubImage3D(target, level, xoffset, yoffset, zoffset, width, height, depth, format, imageSize, data); debug_helper(loc, 0, target, level, xoffset, yoffset, zoffset, width, height, depth, format, imageSize, data) }
-	CompressedTexSubImage2D :: #force_inline proc "c" (target: u32, level: i32, xoffset: i32, yoffset: i32, width: i32, height: i32, format: u32, imageSize: i32, data: rawptr, loc := #caller_location)                           { impl_CompressedTexSubImage2D(target, level, xoffset, yoffset, width, height, format, imageSize, data);                 debug_helper(loc, 0, target, level, xoffset, yoffset, width, height, format, imageSize, data)                 }
-	CompressedTexSubImage1D :: #force_inline proc "c" (target: u32, level: i32, xoffset: i32, width: i32, format: u32, imageSize: i32, data: rawptr, loc := #caller_location)                                                      { impl_CompressedTexSubImage1D(target, level, xoffset, width, format, imageSize, data);                                  debug_helper(loc, 0, target, level, xoffset, width, format, imageSize, data)                                  }
-	GetCompressedTexImage   :: #force_inline proc "c" (target: u32, level: i32, img: rawptr, loc := #caller_location)                                                                                                              { impl_GetCompressedTexImage(target, level, img);                                                                        debug_helper(loc, 0, target, level, img)                                                                      }
+	ActiveTexture           :: proc "c" (texture: u32, loc := #caller_location)                                                                                                                                      { impl_ActiveTexture(texture);                                                                                           debug_helper(loc, 0, texture)                                                                                 }
+	SampleCoverage          :: proc "c" (value: f32, invert: bool, loc := #caller_location)                                                                                                                          { impl_SampleCoverage(value, invert);                                                                                    debug_helper(loc, 0, value, invert)                                                                           }
+	CompressedTexImage3D    :: proc "c" (target: u32, level: i32, internalformat: u32, width: i32, height: i32, depth: i32, border: i32, imageSize: i32, data: rawptr, loc := #caller_location)                      { impl_CompressedTexImage3D(target, level, internalformat, width, height, depth, border, imageSize, data);               debug_helper(loc, 0, target, level, internalformat, width, height, depth, border, imageSize, data)            }
+	CompressedTexImage2D    :: proc "c" (target: u32, level: i32, internalformat: u32, width: i32, height: i32, border: i32, imageSize: i32, data: rawptr, loc := #caller_location)                                  { impl_CompressedTexImage2D(target, level, internalformat, width, height, border, imageSize, data);                      debug_helper(loc, 0, target, level, internalformat, width, height, border, imageSize, data)                   }
+	CompressedTexImage1D    :: proc "c" (target: u32, level: i32, internalformat: u32, width: i32, border: i32, imageSize: i32, data: rawptr, loc := #caller_location)                                               { impl_CompressedTexImage1D(target, level, internalformat, width, border, imageSize, data);                              debug_helper(loc, 0, target, level, internalformat, width, border, imageSize, data)                           }
+	CompressedTexSubImage3D :: proc "c" (target: u32, level: i32, xoffset: i32, yoffset: i32, zoffset: i32, width: i32, height: i32, depth: i32, format: u32, imageSize: i32, data: rawptr, loc := #caller_location) { impl_CompressedTexSubImage3D(target, level, xoffset, yoffset, zoffset, width, height, depth, format, imageSize, data); debug_helper(loc, 0, target, level, xoffset, yoffset, zoffset, width, height, depth, format, imageSize, data) }
+	CompressedTexSubImage2D :: proc "c" (target: u32, level: i32, xoffset: i32, yoffset: i32, width: i32, height: i32, format: u32, imageSize: i32, data: rawptr, loc := #caller_location)                           { impl_CompressedTexSubImage2D(target, level, xoffset, yoffset, width, height, format, imageSize, data);                 debug_helper(loc, 0, target, level, xoffset, yoffset, width, height, format, imageSize, data)                 }
+	CompressedTexSubImage1D :: proc "c" (target: u32, level: i32, xoffset: i32, width: i32, format: u32, imageSize: i32, data: rawptr, loc := #caller_location)                                                      { impl_CompressedTexSubImage1D(target, level, xoffset, width, format, imageSize, data);                                  debug_helper(loc, 0, target, level, xoffset, width, format, imageSize, data)                                  }
+	GetCompressedTexImage   :: proc "c" (target: u32, level: i32, img: rawptr, loc := #caller_location)                                                                                                              { impl_GetCompressedTexImage(target, level, img);                                                                        debug_helper(loc, 0, target, level, img)                                                                      }
 
 	// VERSION_1_4
-	BlendFuncSeparate :: #force_inline proc "c" (sfactorRGB: u32, dfactorRGB: u32, sfactorAlpha: u32, dfactorAlpha: u32, loc := #caller_location)  { impl_BlendFuncSeparate(sfactorRGB, dfactorRGB, sfactorAlpha, dfactorAlpha); debug_helper(loc, 0, sfactorRGB, dfactorRGB, sfactorAlpha, dfactorAlpha) }
-	MultiDrawArrays   :: #force_inline proc "c" (mode: u32, first: [^]i32, count: [^]i32, drawcount: i32, loc := #caller_location)                 { impl_MultiDrawArrays(mode, first, count, drawcount);                        debug_helper(loc, 0, mode, first, count, drawcount)                      }
-	MultiDrawElements :: #force_inline proc "c" (mode: u32, count: [^]i32, type: u32, indices: [^]rawptr, drawcount: i32, loc := #caller_location) { impl_MultiDrawElements(mode, count, type, indices, drawcount);             debug_helper(loc, 0, mode, count, type, indices, drawcount)             }
-	PointParameterf   :: #force_inline proc "c" (pname: u32, param: f32, loc := #caller_location)                                                  { impl_PointParameterf(pname, param);                                         debug_helper(loc, 0, pname, param)                                       }
-	PointParameterfv  :: #force_inline proc "c" (pname: u32, params: [^]f32, loc := #caller_location)                                              { impl_PointParameterfv(pname, params);                                       debug_helper(loc, 0, pname, params)                                      }
-	PointParameteri   :: #force_inline proc "c" (pname: u32, param: i32, loc := #caller_location)                                                  { impl_PointParameteri(pname, param);                                         debug_helper(loc, 0, pname, param)                                       }
-	PointParameteriv  :: #force_inline proc "c" (pname: u32, params: [^]i32, loc := #caller_location)                                              { impl_PointParameteriv(pname, params);                                       debug_helper(loc, 0, pname, params)                                      }
-	BlendColor        :: #force_inline proc "c" (red: f32, green: f32, blue: f32, alpha: f32, loc := #caller_location)                             { impl_BlendColor(red, green, blue, alpha);                                   debug_helper(loc, 0, red, green, blue, alpha)                            }
-	BlendEquation     :: #force_inline proc "c" (mode: u32, loc := #caller_location)                                                               { impl_BlendEquation(mode);                                                   debug_helper(loc, 0, mode)                                               }
+	BlendFuncSeparate :: proc "c" (sfactorRGB: u32, dfactorRGB: u32, sfactorAlpha: u32, dfactorAlpha: u32, loc := #caller_location)  { impl_BlendFuncSeparate(sfactorRGB, dfactorRGB, sfactorAlpha, dfactorAlpha); debug_helper(loc, 0, sfactorRGB, dfactorRGB, sfactorAlpha, dfactorAlpha) }
+	MultiDrawArrays   :: proc "c" (mode: u32, first: [^]i32, count: [^]i32, drawcount: i32, loc := #caller_location)                 { impl_MultiDrawArrays(mode, first, count, drawcount);                        debug_helper(loc, 0, mode, first, count, drawcount)                      }
+	MultiDrawElements :: proc "c" (mode: u32, count: [^]i32, type: u32, indices: [^]rawptr, drawcount: i32, loc := #caller_location) { impl_MultiDrawElements(mode, count, type, indices, drawcount);             debug_helper(loc, 0, mode, count, type, indices, drawcount)             }
+	PointParameterf   :: proc "c" (pname: u32, param: f32, loc := #caller_location)                                                  { impl_PointParameterf(pname, param);                                         debug_helper(loc, 0, pname, param)                                       }
+	PointParameterfv  :: proc "c" (pname: u32, params: [^]f32, loc := #caller_location)                                              { impl_PointParameterfv(pname, params);                                       debug_helper(loc, 0, pname, params)                                      }
+	PointParameteri   :: proc "c" (pname: u32, param: i32, loc := #caller_location)                                                  { impl_PointParameteri(pname, param);                                         debug_helper(loc, 0, pname, param)                                       }
+	PointParameteriv  :: proc "c" (pname: u32, params: [^]i32, loc := #caller_location)                                              { impl_PointParameteriv(pname, params);                                       debug_helper(loc, 0, pname, params)                                      }
+	BlendColor        :: proc "c" (red: f32, green: f32, blue: f32, alpha: f32, loc := #caller_location)                             { impl_BlendColor(red, green, blue, alpha);                                   debug_helper(loc, 0, red, green, blue, alpha)                            }
+	BlendEquation     :: proc "c" (mode: u32, loc := #caller_location)                                                               { impl_BlendEquation(mode);                                                   debug_helper(loc, 0, mode)                                               }
 
 	// VERSION_1_5
-	GenQueries           :: #force_inline proc "c" (n: i32, ids: [^]u32, loc := #caller_location)                               {        impl_GenQueries(n, ids);                           debug_helper(loc, 0, n, ids)                                 }
-	DeleteQueries        :: #force_inline proc "c" (n: i32, ids: [^]u32, loc := #caller_location)                               {        impl_DeleteQueries(n, ids);                        debug_helper(loc, 0, n, ids)                                 }
-	IsQuery              :: #force_inline proc "c" (id: u32, loc := #caller_location) -> bool                                   { ret := impl_IsQuery(id);                                  debug_helper(loc, 1, ret, id);                    return ret }
-	BeginQuery           :: #force_inline proc "c" (target: u32, id: u32, loc := #caller_location)                              {        impl_BeginQuery(target, id);                       debug_helper(loc, 0, target, id)                             }
-	EndQuery             :: #force_inline proc "c" (target: u32, loc := #caller_location)                                       {        impl_EndQuery(target);                             debug_helper(loc, 0, target)                                 }
-	GetQueryiv           :: #force_inline proc "c" (target: u32, pname: u32, params: [^]i32, loc := #caller_location)           {        impl_GetQueryiv(target, pname, params);            debug_helper(loc, 0, target, pname, params)                  }
-	GetQueryObjectiv     :: #force_inline proc "c" (id: u32, pname: u32, params: [^]i32, loc := #caller_location)               {        impl_GetQueryObjectiv(id, pname, params);          debug_helper(loc, 0, id, pname, params)                      }
-	GetQueryObjectuiv    :: #force_inline proc "c" (id: u32, pname: u32, params: [^]u32, loc := #caller_location)               {        impl_GetQueryObjectuiv(id, pname, params);         debug_helper(loc, 0, id, pname, params)                      }
-	BindBuffer           :: #force_inline proc "c" (target: u32, buffer: u32, loc := #caller_location)                          {        impl_BindBuffer(target, buffer);                   debug_helper(loc, 0, target, buffer)                         }
-	DeleteBuffers        :: #force_inline proc "c" (n: i32, buffers: [^]u32, loc := #caller_location)                           {        impl_DeleteBuffers(n, buffers);                    debug_helper(loc, 0, n, buffers)                             }
-	GenBuffers           :: #force_inline proc "c" (n: i32, buffers: [^]u32, loc := #caller_location)                           {        impl_GenBuffers(n, buffers);                       debug_helper(loc, 0, n, buffers)                             }
-	IsBuffer             :: #force_inline proc "c" (buffer: u32, loc := #caller_location) -> bool                               { ret := impl_IsBuffer(buffer);                             debug_helper(loc, 1, ret, buffer);                return ret }
-	BufferData           :: #force_inline proc "c" (target: u32, size: int, data: rawptr, usage: u32, loc := #caller_location)  {        impl_BufferData(target, size, data, usage);        debug_helper(loc, 0, target, size, data, usage)              }
-	BufferSubData        :: #force_inline proc "c" (target: u32, offset: int, size: int, data: rawptr, loc := #caller_location) {        impl_BufferSubData(target, offset, size, data);    debug_helper(loc, 0, target, offset, size, data)             }
-	GetBufferSubData     :: #force_inline proc "c" (target: u32, offset: int, size: int, data: rawptr, loc := #caller_location) {        impl_GetBufferSubData(target, offset, size, data); debug_helper(loc, 0, target, offset, size, data)             }
-	MapBuffer            :: #force_inline proc "c" (target: u32, access: u32, loc := #caller_location) -> rawptr                { ret := impl_MapBuffer(target, access);                    debug_helper(loc, 1, ret, target, access);        return ret }
-	UnmapBuffer          :: #force_inline proc "c" (target: u32, loc := #caller_location) -> bool                               { ret := impl_UnmapBuffer(target);                          debug_helper(loc, 1, ret, target);                return ret }
-	GetBufferParameteriv :: #force_inline proc "c" (target: u32, pname: u32, params: [^]i32, loc := #caller_location)           {        impl_GetBufferParameteriv(target, pname, params);  debug_helper(loc, 0, target, pname, params)                  }
-	GetBufferPointerv    :: #force_inline proc "c" (target: u32, pname: u32, params: [^]rawptr, loc := #caller_location)        {        impl_GetBufferPointerv(target, pname, params);     debug_helper(loc, 0, target, pname, params)                  }
+	GenQueries           :: proc "c" (n: i32, ids: [^]u32, loc := #caller_location)                               {        impl_GenQueries(n, ids);                           debug_helper(loc, 0, n, ids)                                 }
+	DeleteQueries        :: proc "c" (n: i32, ids: [^]u32, loc := #caller_location)                               {        impl_DeleteQueries(n, ids);                        debug_helper(loc, 0, n, ids)                                 }
+	IsQuery              :: proc "c" (id: u32, loc := #caller_location) -> bool                                   { ret := impl_IsQuery(id);                                  debug_helper(loc, 1, ret, id);                    return ret }
+	BeginQuery           :: proc "c" (target: u32, id: u32, loc := #caller_location)                              {        impl_BeginQuery(target, id);                       debug_helper(loc, 0, target, id)                             }
+	EndQuery             :: proc "c" (target: u32, loc := #caller_location)                                       {        impl_EndQuery(target);                             debug_helper(loc, 0, target)                                 }
+	GetQueryiv           :: proc "c" (target: u32, pname: u32, params: [^]i32, loc := #caller_location)           {        impl_GetQueryiv(target, pname, params);            debug_helper(loc, 0, target, pname, params)                  }
+	GetQueryObjectiv     :: proc "c" (id: u32, pname: u32, params: [^]i32, loc := #caller_location)               {        impl_GetQueryObjectiv(id, pname, params);          debug_helper(loc, 0, id, pname, params)                      }
+	GetQueryObjectuiv    :: proc "c" (id: u32, pname: u32, params: [^]u32, loc := #caller_location)               {        impl_GetQueryObjectuiv(id, pname, params);         debug_helper(loc, 0, id, pname, params)                      }
+	BindBuffer           :: proc "c" (target: u32, buffer: u32, loc := #caller_location)                          {        impl_BindBuffer(target, buffer);                   debug_helper(loc, 0, target, buffer)                         }
+	DeleteBuffers        :: proc "c" (n: i32, buffers: [^]u32, loc := #caller_location)                           {        impl_DeleteBuffers(n, buffers);                    debug_helper(loc, 0, n, buffers)                             }
+	GenBuffers           :: proc "c" (n: i32, buffers: [^]u32, loc := #caller_location)                           {        impl_GenBuffers(n, buffers);                       debug_helper(loc, 0, n, buffers)                             }
+	IsBuffer             :: proc "c" (buffer: u32, loc := #caller_location) -> bool                               { ret := impl_IsBuffer(buffer);                             debug_helper(loc, 1, ret, buffer);                return ret }
+	BufferData           :: proc "c" (target: u32, size: int, data: rawptr, usage: u32, loc := #caller_location)  {        impl_BufferData(target, size, data, usage);        debug_helper(loc, 0, target, size, data, usage)              }
+	BufferSubData        :: proc "c" (target: u32, offset: int, size: int, data: rawptr, loc := #caller_location) {        impl_BufferSubData(target, offset, size, data);    debug_helper(loc, 0, target, offset, size, data)             }
+	GetBufferSubData     :: proc "c" (target: u32, offset: int, size: int, data: rawptr, loc := #caller_location) {        impl_GetBufferSubData(target, offset, size, data); debug_helper(loc, 0, target, offset, size, data)             }
+	MapBuffer            :: proc "c" (target: u32, access: u32, loc := #caller_location) -> rawptr                { ret := impl_MapBuffer(target, access);                    debug_helper(loc, 1, ret, target, access);        return ret }
+	UnmapBuffer          :: proc "c" (target: u32, loc := #caller_location) -> bool                               { ret := impl_UnmapBuffer(target);                          debug_helper(loc, 1, ret, target);                return ret }
+	GetBufferParameteriv :: proc "c" (target: u32, pname: u32, params: [^]i32, loc := #caller_location)           {        impl_GetBufferParameteriv(target, pname, params);  debug_helper(loc, 0, target, pname, params)                  }
+	GetBufferPointerv    :: proc "c" (target: u32, pname: u32, params: [^]rawptr, loc := #caller_location)        {        impl_GetBufferPointerv(target, pname, params);     debug_helper(loc, 0, target, pname, params)                  }
 
 	// VERSION_2_0
-	BlendEquationSeparate    :: #force_inline proc "c" (modeRGB: u32, modeAlpha: u32, loc := #caller_location)                                                              {        impl_BlendEquationSeparate(modeRGB, modeAlpha);                            debug_helper(loc, 0, modeRGB, modeAlpha)                                             }
-	DrawBuffers              :: #force_inline proc "c" (n: i32, bufs: [^]u32, loc := #caller_location)                                                                      {        impl_DrawBuffers(n, bufs);                                                 debug_helper(loc, 0, n, bufs)                                                        }
-	StencilOpSeparate        :: #force_inline proc "c" (face: u32, sfail: u32, dpfail: u32, dppass: u32, loc := #caller_location)                                           {        impl_StencilOpSeparate(face, sfail, dpfail, dppass);                       debug_helper(loc, 0, face, sfail, dpfail, dppass)                                    }
-	StencilFuncSeparate      :: #force_inline proc "c" (face: u32, func: u32, ref: i32, mask: u32, loc := #caller_location)                                                 {        impl_StencilFuncSeparate(face, func, ref, mask);                           debug_helper(loc, 0, face, func, ref, mask)                                          }
-	StencilMaskSeparate      :: #force_inline proc "c" (face: u32, mask: u32, loc := #caller_location)                                                                      {        impl_StencilMaskSeparate(face, mask);                                      debug_helper(loc, 0, face, mask)                                                     }
-	AttachShader             :: #force_inline proc "c" (program: u32, shader: u32, loc := #caller_location)                                                                 {        impl_AttachShader(program, shader);                                        debug_helper(loc, 0, program, shader)                                                }
-	BindAttribLocation       :: #force_inline proc "c" (program: u32, index: u32, name: cstring, loc := #caller_location)                                                   {        impl_BindAttribLocation(program, index, name);                             debug_helper(loc, 0, program, index, name)                                           }
-	CompileShader            :: #force_inline proc "c" (shader: u32, loc := #caller_location)                                                                               {        impl_CompileShader(shader);                                                debug_helper(loc, 0, shader)                                                         }
-	CreateProgram            :: #force_inline proc "c" (loc := #caller_location) -> u32                                                                                     { ret := impl_CreateProgram();                                                      debug_helper(loc, 1, ret);                                                return ret }
-	CreateShader             :: #force_inline proc "c" (type: u32, loc := #caller_location) -> u32                                                                          { ret := impl_CreateShader(type);                                                  debug_helper(loc, 1, ret, type);                                         return ret }
-	DeleteProgram            :: #force_inline proc "c" (program: u32, loc := #caller_location)                                                                              {        impl_DeleteProgram(program);                                               debug_helper(loc, 0, program)                                                        }
-	DeleteShader             :: #force_inline proc "c" (shader: u32, loc := #caller_location)                                                                               {        impl_DeleteShader(shader);                                                 debug_helper(loc, 0, shader)                                                         }
-	DetachShader             :: #force_inline proc "c" (program: u32, shader: u32, loc := #caller_location)                                                                 {        impl_DetachShader(program, shader);                                        debug_helper(loc, 0, program, shader)                                                }
-	DisableVertexAttribArray :: #force_inline proc "c" (index: u32, loc := #caller_location)                                                                                {        impl_DisableVertexAttribArray(index);                                      debug_helper(loc, 0, index)                                                          }
-	EnableVertexAttribArray  :: #force_inline proc "c" (index: u32, loc := #caller_location)                                                                                {        impl_EnableVertexAttribArray(index);                                       debug_helper(loc, 0, index)                                                          }
-	GetActiveAttrib          :: #force_inline proc "c" (program: u32, index: u32, bufSize: i32, length: ^i32, size: ^i32, type: ^u32, name: [^]u8, loc := #caller_location) {        impl_GetActiveAttrib(program, index, bufSize, length, size, type, name);  debug_helper(loc, 0, program, index, bufSize, length, size, type, name)             }
-	GetActiveUniform         :: #force_inline proc "c" (program: u32, index: u32, bufSize: i32, length: ^i32, size: ^i32, type: ^u32, name: [^]u8, loc := #caller_location) {        impl_GetActiveUniform(program, index, bufSize, length, size, type, name); debug_helper(loc, 0, program, index, bufSize, length, size, type, name)             }
-	GetAttachedShaders       :: #force_inline proc "c" (program: u32, maxCount: i32, count: [^]i32, shaders: [^]u32, loc := #caller_location)                               {        impl_GetAttachedShaders(program, maxCount, count, shaders);                debug_helper(loc, 0, program, maxCount, count, shaders)                              }
-	GetAttribLocation        :: #force_inline proc "c" (program: u32, name: cstring, loc := #caller_location) -> i32                                                        { ret := impl_GetAttribLocation(program, name);                                     debug_helper(loc, 1, ret, program, name);                                 return ret }
-	GetProgramiv             :: #force_inline proc "c" (program: u32, pname: u32, params: [^]i32, loc := #caller_location)                                                  {        impl_GetProgramiv(program, pname, params);                                 debug_helper(loc, 0, program, pname, params)                                         }
-	GetProgramInfoLog        :: #force_inline proc "c" (program: u32, bufSize: i32, length: ^i32, infoLog: [^]u8, loc := #caller_location)                                  {        impl_GetProgramInfoLog(program, bufSize, length, infoLog);                 debug_helper(loc, 0, program, bufSize, length, infoLog)                              }
-	GetShaderiv              :: #force_inline proc "c" (shader: u32, pname: u32, params: [^]i32, loc := #caller_location)                                                   {        impl_GetShaderiv(shader, pname, params);                                   debug_helper(loc, 0, shader, pname, params)                                          }
-	GetShaderInfoLog         :: #force_inline proc "c" (shader: u32, bufSize: i32, length: ^i32, infoLog: [^]u8, loc := #caller_location)                                   {        impl_GetShaderInfoLog(shader, bufSize, length, infoLog);                   debug_helper(loc, 0, shader, bufSize, length, infoLog)                               }
-	GetShaderSource          :: #force_inline proc "c" (shader: u32, bufSize: i32, length: ^i32, source: [^]u8, loc := #caller_location)                                    {        impl_GetShaderSource(shader, bufSize, length, source);                     debug_helper(loc, 0, shader, bufSize, length, source)                                }
-	GetUniformLocation       :: #force_inline proc "c" (program: u32, name: cstring, loc := #caller_location) -> i32                                                        { ret := impl_GetUniformLocation(program, name);                                    debug_helper(loc, 1, ret, program, name);                                 return ret }
-	GetUniformfv             :: #force_inline proc "c" (program: u32, location: i32, params: [^]f32, loc := #caller_location)                                               {        impl_GetUniformfv(program, location, params);                              debug_helper(loc, 0, program, location, params)                                      }
-	GetUniformiv             :: #force_inline proc "c" (program: u32, location: i32, params: [^]i32, loc := #caller_location)                                               {        impl_GetUniformiv(program, location, params);                              debug_helper(loc, 0, program, location, params)                                      }
-	GetVertexAttribdv        :: #force_inline proc "c" (index: u32, pname: u32, params: [^]f64, loc := #caller_location)                                                    {        impl_GetVertexAttribdv(index, pname, params);                              debug_helper(loc, 0, index, pname, params)                                           }
-	GetVertexAttribfv        :: #force_inline proc "c" (index: u32, pname: u32, params: [^]f32, loc := #caller_location)                                                    {        impl_GetVertexAttribfv(index, pname, params);                              debug_helper(loc, 0, index, pname, params)                                           }
-	GetVertexAttribiv        :: #force_inline proc "c" (index: u32, pname: u32, params: [^]i32, loc := #caller_location)                                                    {        impl_GetVertexAttribiv(index, pname, params);                              debug_helper(loc, 0, index, pname, params)                                           }
-	GetVertexAttribPointerv  :: #force_inline proc "c" (index: u32, pname: u32, pointer: ^uintptr, loc := #caller_location)                                                  {        impl_GetVertexAttribPointerv(index, pname, pointer);                       debug_helper(loc, 0, index, pname, pointer)                                          }
-	IsProgram                :: #force_inline proc "c" (program: u32, loc := #caller_location) -> bool                                                                      { ret := impl_IsProgram(program);                                                   debug_helper(loc, 1, ret, program);                                       return ret }
-	IsShader                 :: #force_inline proc "c" (shader: u32, loc := #caller_location) -> bool                                                                       { ret := impl_IsShader(shader);                                                     debug_helper(loc, 1, ret, shader);                                        return ret }
-	LinkProgram              :: #force_inline proc "c" (program: u32, loc := #caller_location)                                                                              {        impl_LinkProgram(program);                                                 debug_helper(loc, 0, program)                                                        }
-	ShaderSource             :: #force_inline proc "c" (shader: u32, count: i32, string: [^]cstring, length: [^]i32, loc := #caller_location)                               {        impl_ShaderSource(shader, count, string, length);                          debug_helper(loc, 0, shader, count, string, length)                                  }
-	UseProgram               :: #force_inline proc "c" (program: u32, loc := #caller_location)                                                                              {        impl_UseProgram(program);                                                  debug_helper(loc, 0, program)                                                        }
-	Uniform1f                :: #force_inline proc "c" (location: i32, v0: f32, loc := #caller_location)                                                                    {        impl_Uniform1f(location, v0);                                              debug_helper(loc, 0, location, v0)                                                   }
-	Uniform2f                :: #force_inline proc "c" (location: i32, v0: f32, v1: f32, loc := #caller_location)                                                           {        impl_Uniform2f(location, v0, v1);                                          debug_helper(loc, 0, location, v0, v1)                                               }
-	Uniform3f                :: #force_inline proc "c" (location: i32, v0: f32, v1: f32, v2: f32, loc := #caller_location)                                                  {        impl_Uniform3f(location, v0, v1, v2);                                      debug_helper(loc, 0, location, v0, v1, v2)                                           }
-	Uniform4f                :: #force_inline proc "c" (location: i32, v0: f32, v1: f32, v2: f32, v3: f32, loc := #caller_location)                                         {        impl_Uniform4f(location, v0, v1, v2, v3);                                  debug_helper(loc, 0, location, v0, v1, v2, v3)                                       }
-	Uniform1i                :: #force_inline proc "c" (location: i32, v0: i32, loc := #caller_location)                                                                    {        impl_Uniform1i(location, v0);                                              debug_helper(loc, 0, location, v0)                                                   }
-	Uniform2i                :: #force_inline proc "c" (location: i32, v0: i32, v1: i32, loc := #caller_location)                                                           {        impl_Uniform2i(location, v0, v1);                                          debug_helper(loc, 0, location, v0, v1)                                               }
-	Uniform3i                :: #force_inline proc "c" (location: i32, v0: i32, v1: i32, v2: i32, loc := #caller_location)                                                  {        impl_Uniform3i(location, v0, v1, v2);                                      debug_helper(loc, 0, location, v0, v1, v2)                                           }
-	Uniform4i                :: #force_inline proc "c" (location: i32, v0: i32, v1: i32, v2: i32, v3: i32, loc := #caller_location)                                         {        impl_Uniform4i(location, v0, v1, v2, v3);                                  debug_helper(loc, 0, location, v0, v1, v2, v3)                                       }
-	Uniform1fv               :: #force_inline proc "c" (location: i32, count: i32, value: [^]f32, loc := #caller_location)                                                  {        impl_Uniform1fv(location, count, value);                                   debug_helper(loc, 0, location, count, value)                                         }
-	Uniform2fv               :: #force_inline proc "c" (location: i32, count: i32, value: [^]f32, loc := #caller_location)                                                  {        impl_Uniform2fv(location, count, value);                                   debug_helper(loc, 0, location, count, value)                                         }
-	Uniform3fv               :: #force_inline proc "c" (location: i32, count: i32, value: [^]f32, loc := #caller_location)                                                  {        impl_Uniform3fv(location, count, value);                                   debug_helper(loc, 0, location, count, value)                                         }
-	Uniform4fv               :: #force_inline proc "c" (location: i32, count: i32, value: [^]f32, loc := #caller_location)                                                  {        impl_Uniform4fv(location, count, value);                                   debug_helper(loc, 0, location, count, value)                                         }
-	Uniform1iv               :: #force_inline proc "c" (location: i32, count: i32, value: [^]i32, loc := #caller_location)                                                  {        impl_Uniform1iv(location, count, value);                                   debug_helper(loc, 0, location, count, value)                                         }
-	Uniform2iv               :: #force_inline proc "c" (location: i32, count: i32, value: [^]i32, loc := #caller_location)                                                  {        impl_Uniform2iv(location, count, value);                                   debug_helper(loc, 0, location, count, value)                                         }
-	Uniform3iv               :: #force_inline proc "c" (location: i32, count: i32, value: [^]i32, loc := #caller_location)                                                  {        impl_Uniform3iv(location, count, value);                                   debug_helper(loc, 0, location, count, value)                                         }
-	Uniform4iv               :: #force_inline proc "c" (location: i32, count: i32, value: [^]i32, loc := #caller_location)                                                  {        impl_Uniform4iv(location, count, value);                                   debug_helper(loc, 0, location, count, value)                                         }
-	UniformMatrix2fv         :: #force_inline proc "c" (location: i32, count: i32, transpose: bool, value: [^]f32, loc := #caller_location)                              {        impl_UniformMatrix2fv(location, count, transpose, value);                  debug_helper(loc, 0, location, count, transpose, value)                              }
-	UniformMatrix3fv         :: #force_inline proc "c" (location: i32, count: i32, transpose: bool, value: [^]f32, loc := #caller_location)                              {        impl_UniformMatrix3fv(location, count, transpose, value);                  debug_helper(loc, 0, location, count, transpose, value)                              }
-	UniformMatrix4fv         :: #force_inline proc "c" (location: i32, count: i32, transpose: bool, value: [^]f32, loc := #caller_location)                              {        impl_UniformMatrix4fv(location, count, transpose, value);                  debug_helper(loc, 0, location, count, transpose, value)                              }
-	ValidateProgram          :: #force_inline proc "c" (program: u32, loc := #caller_location)                                                                              {        impl_ValidateProgram(program);                                             debug_helper(loc, 0, program)                                                        }
-	VertexAttrib1d           :: #force_inline proc "c" (index: u32, x: f64, loc := #caller_location)                                                                        {        impl_VertexAttrib1d(index, x);                                             debug_helper(loc, 0, index, x)                                                       }
-	VertexAttrib1dv          :: #force_inline proc "c" (index: u32, v: ^f64, loc := #caller_location)                                                                       {        impl_VertexAttrib1dv(index, v);                                            debug_helper(loc, 0, index, v)                                                       }
-	VertexAttrib1f           :: #force_inline proc "c" (index: u32, x: f32, loc := #caller_location)                                                                        {        impl_VertexAttrib1f(index, x);                                             debug_helper(loc, 0, index, x)                                                       }
-	VertexAttrib1fv          :: #force_inline proc "c" (index: u32, v: ^f32, loc := #caller_location)                                                                       {        impl_VertexAttrib1fv(index, v);                                            debug_helper(loc, 0, index, v)                                                       }
-	VertexAttrib1s           :: #force_inline proc "c" (index: u32, x: i16, loc := #caller_location)                                                                        {        impl_VertexAttrib1s(index, x);                                             debug_helper(loc, 0, index, x)                                                       }
-	VertexAttrib1sv          :: #force_inline proc "c" (index: u32, v: ^i16, loc := #caller_location)                                                                       {        impl_VertexAttrib1sv(index, v);                                            debug_helper(loc, 0, index, v)                                                       }
-	VertexAttrib2d           :: #force_inline proc "c" (index: u32, x: f64, y: f64, loc := #caller_location)                                                                {        impl_VertexAttrib2d(index, x, y);                                          debug_helper(loc, 0, index, x, y)                                                    }
-	VertexAttrib2dv          :: #force_inline proc "c" (index: u32, v: ^[2]f64, loc := #caller_location)                                                                       {        impl_VertexAttrib2dv(index, v);                                            debug_helper(loc, 0, index, v)                                                       }
-	VertexAttrib2f           :: #force_inline proc "c" (index: u32, x: f32, y: f32, loc := #caller_location)                                                                {        impl_VertexAttrib2f(index, x, y);                                          debug_helper(loc, 0, index, x, y)                                                    }
-	VertexAttrib2fv          :: #force_inline proc "c" (index: u32, v: ^[2]f32, loc := #caller_location)                                                                       {        impl_VertexAttrib2fv(index, v);                                            debug_helper(loc, 0, index, v)                                                       }
-	VertexAttrib2s           :: #force_inline proc "c" (index: u32, x: i16, y: i16, loc := #caller_location)                                                                {        impl_VertexAttrib2s(index, x, y);                                          debug_helper(loc, 0, index, x, y)                                                    }
-	VertexAttrib2sv          :: #force_inline proc "c" (index: u32, v: ^[2]i16, loc := #caller_location)                                                                       {        impl_VertexAttrib2sv(index, v);                                            debug_helper(loc, 0, index, v)                                                       }
-	VertexAttrib3d           :: #force_inline proc "c" (index: u32, x: f64, y: f64, z: f64, loc := #caller_location)                                                        {        impl_VertexAttrib3d(index, x, y, z);                                       debug_helper(loc, 0, index, x, y, z)                                                 }
-	VertexAttrib3dv          :: #force_inline proc "c" (index: u32, v: ^[3]f64, loc := #caller_location)                                                                       {        impl_VertexAttrib3dv(index, v);                                            debug_helper(loc, 0, index, v)                                                       }
-	VertexAttrib3f           :: #force_inline proc "c" (index: u32, x: f32, y: f32, z: f32, loc := #caller_location)                                                        {        impl_VertexAttrib3f(index, x, y, z);                                       debug_helper(loc, 0, index, x, y, z)                                                 }
-	VertexAttrib3fv          :: #force_inline proc "c" (index: u32, v: ^[3]f32, loc := #caller_location)                                                                       {        impl_VertexAttrib3fv(index, v);                                            debug_helper(loc, 0, index, v)                                                       }
-	VertexAttrib3s           :: #force_inline proc "c" (index: u32, x: i16, y: i16, z: i16, loc := #caller_location)                                                        {        impl_VertexAttrib3s(index, x, y, z);                                       debug_helper(loc, 0, index, x, y, z)                                                 }
-	VertexAttrib3sv          :: #force_inline proc "c" (index: u32, v: ^[3]i16, loc := #caller_location)                                                                       {        impl_VertexAttrib3sv(index, v);                                            debug_helper(loc, 0, index, v)                                                       }
-	VertexAttrib4Nbv         :: #force_inline proc "c" (index: u32, v: ^[4]i8, loc := #caller_location)                                                                        {        impl_VertexAttrib4Nbv(index, v);                                           debug_helper(loc, 0, index, v)                                                       }
-	VertexAttrib4Niv         :: #force_inline proc "c" (index: u32, v: ^[4]i32, loc := #caller_location)                                                                       {        impl_VertexAttrib4Niv(index, v);                                           debug_helper(loc, 0, index, v)                                                       }
-	VertexAttrib4Nsv         :: #force_inline proc "c" (index: u32, v: ^[4]i16, loc := #caller_location)                                                                       {        impl_VertexAttrib4Nsv(index, v);                                           debug_helper(loc, 0, index, v)                                                       }
-	VertexAttrib4Nub         :: #force_inline proc "c" (index: u32, x: u8, y: u8, z: u8, w: u8, loc := #caller_location)                                                    {        impl_VertexAttrib4Nub(index, x, y, z, w);                                  debug_helper(loc, 0, index, x, y, z, w)                                              }
-	VertexAttrib4Nubv        :: #force_inline proc "c" (index: u32, v: ^[4]u8, loc := #caller_location)                                                                        {        impl_VertexAttrib4Nubv(index, v);                                          debug_helper(loc, 0, index, v)                                                       }
-	VertexAttrib4Nuiv        :: #force_inline proc "c" (index: u32, v: ^[4]u32, loc := #caller_location)                                                                       {        impl_VertexAttrib4Nuiv(index, v);                                          debug_helper(loc, 0, index, v)                                                       }
-	VertexAttrib4Nusv        :: #force_inline proc "c" (index: u32, v: ^[4]u16, loc := #caller_location)                                                                       {        impl_VertexAttrib4Nusv(index, v);                                          debug_helper(loc, 0, index, v)                                                       }
-	VertexAttrib4bv          :: #force_inline proc "c" (index: u32, v: ^[4]i8, loc := #caller_location)                                                                        {        impl_VertexAttrib4bv(index, v);                                            debug_helper(loc, 0, index, v)                                                       }
-	VertexAttrib4d           :: #force_inline proc "c" (index: u32, x: f64, y: f64, z: f64, w: f64, loc := #caller_location)                                                {        impl_VertexAttrib4d(index, x, y, z, w);                                    debug_helper(loc, 0, index, x, y, z, w)                                              }
-	VertexAttrib4dv          :: #force_inline proc "c" (index: u32, v: ^[4]f64, loc := #caller_location)                                                                       {        impl_VertexAttrib4dv(index, v);                                            debug_helper(loc, 0, index, v)                                                       }
-	VertexAttrib4f           :: #force_inline proc "c" (index: u32, x: f32, y: f32, z: f32, w: f32, loc := #caller_location)                                                {        impl_VertexAttrib4f(index, x, y, z, w);                                    debug_helper(loc, 0, index, x, y, z, w)                                              }
-	VertexAttrib4fv          :: #force_inline proc "c" (index: u32, v: ^[4]f32, loc := #caller_location)                                                                       {        impl_VertexAttrib4fv(index, v);                                            debug_helper(loc, 0, index, v)                                                       }
-	VertexAttrib4iv          :: #force_inline proc "c" (index: u32, v: ^[4]i32, loc := #caller_location)                                                                       {        impl_VertexAttrib4iv(index, v);                                            debug_helper(loc, 0, index, v)                                                       }
-	VertexAttrib4s           :: #force_inline proc "c" (index: u32, x: i16, y: i16, z: i16, w: i16, loc := #caller_location)                                                {        impl_VertexAttrib4s(index, x, y, z, w);                                    debug_helper(loc, 0, index, x, y, z, w)                                              }
-	VertexAttrib4sv          :: #force_inline proc "c" (index: u32, v: ^[4]i16, loc := #caller_location)                                                                       {        impl_VertexAttrib4sv(index, v);                                            debug_helper(loc, 0, index, v)                                                       }
-	VertexAttrib4ubv         :: #force_inline proc "c" (index: u32, v: ^[4]u8, loc := #caller_location)                                                                        {        impl_VertexAttrib4ubv(index, v);                                           debug_helper(loc, 0, index, v)                                                       }
-	VertexAttrib4uiv         :: #force_inline proc "c" (index: u32, v: ^[4]u32, loc := #caller_location)                                                                       {        impl_VertexAttrib4uiv(index, v);                                           debug_helper(loc, 0, index, v)                                                       }
-	VertexAttrib4usv         :: #force_inline proc "c" (index: u32, v: ^[4]u16, loc := #caller_location)                                                                       {        impl_VertexAttrib4usv(index, v);                                           debug_helper(loc, 0, index, v)                                                       }
-	VertexAttribPointer      :: #force_inline proc "c" (index: u32, size: i32, type: u32, normalized: bool, stride: i32, pointer: uintptr, loc := #caller_location)          {        impl_VertexAttribPointer(index, size, type, normalized, stride, pointer); debug_helper(loc, 0, index, size, type, normalized, stride, pointer)                }
+	BlendEquationSeparate    :: proc "c" (modeRGB: u32, modeAlpha: u32, loc := #caller_location)                                                              {        impl_BlendEquationSeparate(modeRGB, modeAlpha);                            debug_helper(loc, 0, modeRGB, modeAlpha)                                             }
+	DrawBuffers              :: proc "c" (n: i32, bufs: [^]u32, loc := #caller_location)                                                                      {        impl_DrawBuffers(n, bufs);                                                 debug_helper(loc, 0, n, bufs)                                                        }
+	StencilOpSeparate        :: proc "c" (face: u32, sfail: u32, dpfail: u32, dppass: u32, loc := #caller_location)                                           {        impl_StencilOpSeparate(face, sfail, dpfail, dppass);                       debug_helper(loc, 0, face, sfail, dpfail, dppass)                                    }
+	StencilFuncSeparate      :: proc "c" (face: u32, func: u32, ref: i32, mask: u32, loc := #caller_location)                                                 {        impl_StencilFuncSeparate(face, func, ref, mask);                           debug_helper(loc, 0, face, func, ref, mask)                                          }
+	StencilMaskSeparate      :: proc "c" (face: u32, mask: u32, loc := #caller_location)                                                                      {        impl_StencilMaskSeparate(face, mask);                                      debug_helper(loc, 0, face, mask)                                                     }
+	AttachShader             :: proc "c" (program: u32, shader: u32, loc := #caller_location)                                                                 {        impl_AttachShader(program, shader);                                        debug_helper(loc, 0, program, shader)                                                }
+	BindAttribLocation       :: proc "c" (program: u32, index: u32, name: cstring, loc := #caller_location)                                                   {        impl_BindAttribLocation(program, index, name);                             debug_helper(loc, 0, program, index, name)                                           }
+	CompileShader            :: proc "c" (shader: u32, loc := #caller_location)                                                                               {        impl_CompileShader(shader);                                                debug_helper(loc, 0, shader)                                                         }
+	CreateProgram            :: proc "c" (loc := #caller_location) -> u32                                                                                     { ret := impl_CreateProgram();                                                      debug_helper(loc, 1, ret);                                                return ret }
+	CreateShader             :: proc "c" (type: u32, loc := #caller_location) -> u32                                                                          { ret := impl_CreateShader(type);                                                  debug_helper(loc, 1, ret, type);                                         return ret }
+	DeleteProgram            :: proc "c" (program: u32, loc := #caller_location)                                                                              {        impl_DeleteProgram(program);                                               debug_helper(loc, 0, program)                                                        }
+	DeleteShader             :: proc "c" (shader: u32, loc := #caller_location)                                                                               {        impl_DeleteShader(shader);                                                 debug_helper(loc, 0, shader)                                                         }
+	DetachShader             :: proc "c" (program: u32, shader: u32, loc := #caller_location)                                                                 {        impl_DetachShader(program, shader);                                        debug_helper(loc, 0, program, shader)                                                }
+	DisableVertexAttribArray :: proc "c" (index: u32, loc := #caller_location)                                                                                {        impl_DisableVertexAttribArray(index);                                      debug_helper(loc, 0, index)                                                          }
+	EnableVertexAttribArray  :: proc "c" (index: u32, loc := #caller_location)                                                                                {        impl_EnableVertexAttribArray(index);                                       debug_helper(loc, 0, index)                                                          }
+	GetActiveAttrib          :: proc "c" (program: u32, index: u32, bufSize: i32, length: ^i32, size: ^i32, type: ^u32, name: [^]u8, loc := #caller_location) {        impl_GetActiveAttrib(program, index, bufSize, length, size, type, name);  debug_helper(loc, 0, program, index, bufSize, length, size, type, name)             }
+	GetActiveUniform         :: proc "c" (program: u32, index: u32, bufSize: i32, length: ^i32, size: ^i32, type: ^u32, name: [^]u8, loc := #caller_location) {        impl_GetActiveUniform(program, index, bufSize, length, size, type, name); debug_helper(loc, 0, program, index, bufSize, length, size, type, name)             }
+	GetAttachedShaders       :: proc "c" (program: u32, maxCount: i32, count: [^]i32, shaders: [^]u32, loc := #caller_location)                               {        impl_GetAttachedShaders(program, maxCount, count, shaders);                debug_helper(loc, 0, program, maxCount, count, shaders)                              }
+	GetAttribLocation        :: proc "c" (program: u32, name: cstring, loc := #caller_location) -> i32                                                        { ret := impl_GetAttribLocation(program, name);                                     debug_helper(loc, 1, ret, program, name);                                 return ret }
+	GetProgramiv             :: proc "c" (program: u32, pname: u32, params: [^]i32, loc := #caller_location)                                                  {        impl_GetProgramiv(program, pname, params);                                 debug_helper(loc, 0, program, pname, params)                                         }
+	GetProgramInfoLog        :: proc "c" (program: u32, bufSize: i32, length: ^i32, infoLog: [^]u8, loc := #caller_location)                                  {        impl_GetProgramInfoLog(program, bufSize, length, infoLog);                 debug_helper(loc, 0, program, bufSize, length, infoLog)                              }
+	GetShaderiv              :: proc "c" (shader: u32, pname: u32, params: [^]i32, loc := #caller_location)                                                   {        impl_GetShaderiv(shader, pname, params);                                   debug_helper(loc, 0, shader, pname, params)                                          }
+	GetShaderInfoLog         :: proc "c" (shader: u32, bufSize: i32, length: ^i32, infoLog: [^]u8, loc := #caller_location)                                   {        impl_GetShaderInfoLog(shader, bufSize, length, infoLog);                   debug_helper(loc, 0, shader, bufSize, length, infoLog)                               }
+	GetShaderSource          :: proc "c" (shader: u32, bufSize: i32, length: ^i32, source: [^]u8, loc := #caller_location)                                    {        impl_GetShaderSource(shader, bufSize, length, source);                     debug_helper(loc, 0, shader, bufSize, length, source)                                }
+	GetUniformLocation       :: proc "c" (program: u32, name: cstring, loc := #caller_location) -> i32                                                        { ret := impl_GetUniformLocation(program, name);                                    debug_helper(loc, 1, ret, program, name);                                 return ret }
+	GetUniformfv             :: proc "c" (program: u32, location: i32, params: [^]f32, loc := #caller_location)                                               {        impl_GetUniformfv(program, location, params);                              debug_helper(loc, 0, program, location, params)                                      }
+	GetUniformiv             :: proc "c" (program: u32, location: i32, params: [^]i32, loc := #caller_location)                                               {        impl_GetUniformiv(program, location, params);                              debug_helper(loc, 0, program, location, params)                                      }
+	GetVertexAttribdv        :: proc "c" (index: u32, pname: u32, params: [^]f64, loc := #caller_location)                                                    {        impl_GetVertexAttribdv(index, pname, params);                              debug_helper(loc, 0, index, pname, params)                                           }
+	GetVertexAttribfv        :: proc "c" (index: u32, pname: u32, params: [^]f32, loc := #caller_location)                                                    {        impl_GetVertexAttribfv(index, pname, params);                              debug_helper(loc, 0, index, pname, params)                                           }
+	GetVertexAttribiv        :: proc "c" (index: u32, pname: u32, params: [^]i32, loc := #caller_location)                                                    {        impl_GetVertexAttribiv(index, pname, params);                              debug_helper(loc, 0, index, pname, params)                                           }
+	GetVertexAttribPointerv  :: proc "c" (index: u32, pname: u32, pointer: ^uintptr, loc := #caller_location)                                                  {        impl_GetVertexAttribPointerv(index, pname, pointer);                       debug_helper(loc, 0, index, pname, pointer)                                          }
+	IsProgram                :: proc "c" (program: u32, loc := #caller_location) -> bool                                                                      { ret := impl_IsProgram(program);                                                   debug_helper(loc, 1, ret, program);                                       return ret }
+	IsShader                 :: proc "c" (shader: u32, loc := #caller_location) -> bool                                                                       { ret := impl_IsShader(shader);                                                     debug_helper(loc, 1, ret, shader);                                        return ret }
+	LinkProgram              :: proc "c" (program: u32, loc := #caller_location)                                                                              {        impl_LinkProgram(program);                                                 debug_helper(loc, 0, program)                                                        }
+	ShaderSource             :: proc "c" (shader: u32, count: i32, string: [^]cstring, length: [^]i32, loc := #caller_location)                               {        impl_ShaderSource(shader, count, string, length);                          debug_helper(loc, 0, shader, count, string, length)                                  }
+	UseProgram               :: proc "c" (program: u32, loc := #caller_location)                                                                              {        impl_UseProgram(program);                                                  debug_helper(loc, 0, program)                                                        }
+	Uniform1f                :: proc "c" (location: i32, v0: f32, loc := #caller_location)                                                                    {        impl_Uniform1f(location, v0);                                              debug_helper(loc, 0, location, v0)                                                   }
+	Uniform2f                :: proc "c" (location: i32, v0: f32, v1: f32, loc := #caller_location)                                                           {        impl_Uniform2f(location, v0, v1);                                          debug_helper(loc, 0, location, v0, v1)                                               }
+	Uniform3f                :: proc "c" (location: i32, v0: f32, v1: f32, v2: f32, loc := #caller_location)                                                  {        impl_Uniform3f(location, v0, v1, v2);                                      debug_helper(loc, 0, location, v0, v1, v2)                                           }
+	Uniform4f                :: proc "c" (location: i32, v0: f32, v1: f32, v2: f32, v3: f32, loc := #caller_location)                                         {        impl_Uniform4f(location, v0, v1, v2, v3);                                  debug_helper(loc, 0, location, v0, v1, v2, v3)                                       }
+	Uniform1i                :: proc "c" (location: i32, v0: i32, loc := #caller_location)                                                                    {        impl_Uniform1i(location, v0);                                              debug_helper(loc, 0, location, v0)                                                   }
+	Uniform2i                :: proc "c" (location: i32, v0: i32, v1: i32, loc := #caller_location)                                                           {        impl_Uniform2i(location, v0, v1);                                          debug_helper(loc, 0, location, v0, v1)                                               }
+	Uniform3i                :: proc "c" (location: i32, v0: i32, v1: i32, v2: i32, loc := #caller_location)                                                  {        impl_Uniform3i(location, v0, v1, v2);                                      debug_helper(loc, 0, location, v0, v1, v2)                                           }
+	Uniform4i                :: proc "c" (location: i32, v0: i32, v1: i32, v2: i32, v3: i32, loc := #caller_location)                                         {        impl_Uniform4i(location, v0, v1, v2, v3);                                  debug_helper(loc, 0, location, v0, v1, v2, v3)                                       }
+	Uniform1fv               :: proc "c" (location: i32, count: i32, value: [^]f32, loc := #caller_location)                                                  {        impl_Uniform1fv(location, count, value);                                   debug_helper(loc, 0, location, count, value)                                         }
+	Uniform2fv               :: proc "c" (location: i32, count: i32, value: [^]f32, loc := #caller_location)                                                  {        impl_Uniform2fv(location, count, value);                                   debug_helper(loc, 0, location, count, value)                                         }
+	Uniform3fv               :: proc "c" (location: i32, count: i32, value: [^]f32, loc := #caller_location)                                                  {        impl_Uniform3fv(location, count, value);                                   debug_helper(loc, 0, location, count, value)                                         }
+	Uniform4fv               :: proc "c" (location: i32, count: i32, value: [^]f32, loc := #caller_location)                                                  {        impl_Uniform4fv(location, count, value);                                   debug_helper(loc, 0, location, count, value)                                         }
+	Uniform1iv               :: proc "c" (location: i32, count: i32, value: [^]i32, loc := #caller_location)                                                  {        impl_Uniform1iv(location, count, value);                                   debug_helper(loc, 0, location, count, value)                                         }
+	Uniform2iv               :: proc "c" (location: i32, count: i32, value: [^]i32, loc := #caller_location)                                                  {        impl_Uniform2iv(location, count, value);                                   debug_helper(loc, 0, location, count, value)                                         }
+	Uniform3iv               :: proc "c" (location: i32, count: i32, value: [^]i32, loc := #caller_location)                                                  {        impl_Uniform3iv(location, count, value);                                   debug_helper(loc, 0, location, count, value)                                         }
+	Uniform4iv               :: proc "c" (location: i32, count: i32, value: [^]i32, loc := #caller_location)                                                  {        impl_Uniform4iv(location, count, value);                                   debug_helper(loc, 0, location, count, value)                                         }
+	UniformMatrix2fv         :: proc "c" (location: i32, count: i32, transpose: bool, value: [^]f32, loc := #caller_location)                              {        impl_UniformMatrix2fv(location, count, transpose, value);                  debug_helper(loc, 0, location, count, transpose, value)                              }
+	UniformMatrix3fv         :: proc "c" (location: i32, count: i32, transpose: bool, value: [^]f32, loc := #caller_location)                              {        impl_UniformMatrix3fv(location, count, transpose, value);                  debug_helper(loc, 0, location, count, transpose, value)                              }
+	UniformMatrix4fv         :: proc "c" (location: i32, count: i32, transpose: bool, value: [^]f32, loc := #caller_location)                              {        impl_UniformMatrix4fv(location, count, transpose, value);                  debug_helper(loc, 0, location, count, transpose, value)                              }
+	ValidateProgram          :: proc "c" (program: u32, loc := #caller_location)                                                                              {        impl_ValidateProgram(program);                                             debug_helper(loc, 0, program)                                                        }
+	VertexAttrib1d           :: proc "c" (index: u32, x: f64, loc := #caller_location)                                                                        {        impl_VertexAttrib1d(index, x);                                             debug_helper(loc, 0, index, x)                                                       }
+	VertexAttrib1dv          :: proc "c" (index: u32, v: ^f64, loc := #caller_location)                                                                       {        impl_VertexAttrib1dv(index, v);                                            debug_helper(loc, 0, index, v)                                                       }
+	VertexAttrib1f           :: proc "c" (index: u32, x: f32, loc := #caller_location)                                                                        {        impl_VertexAttrib1f(index, x);                                             debug_helper(loc, 0, index, x)                                                       }
+	VertexAttrib1fv          :: proc "c" (index: u32, v: ^f32, loc := #caller_location)                                                                       {        impl_VertexAttrib1fv(index, v);                                            debug_helper(loc, 0, index, v)                                                       }
+	VertexAttrib1s           :: proc "c" (index: u32, x: i16, loc := #caller_location)                                                                        {        impl_VertexAttrib1s(index, x);                                             debug_helper(loc, 0, index, x)                                                       }
+	VertexAttrib1sv          :: proc "c" (index: u32, v: ^i16, loc := #caller_location)                                                                       {        impl_VertexAttrib1sv(index, v);                                            debug_helper(loc, 0, index, v)                                                       }
+	VertexAttrib2d           :: proc "c" (index: u32, x: f64, y: f64, loc := #caller_location)                                                                {        impl_VertexAttrib2d(index, x, y);                                          debug_helper(loc, 0, index, x, y)                                                    }
+	VertexAttrib2dv          :: proc "c" (index: u32, v: ^[2]f64, loc := #caller_location)                                                                       {        impl_VertexAttrib2dv(index, v);                                            debug_helper(loc, 0, index, v)                                                       }
+	VertexAttrib2f           :: proc "c" (index: u32, x: f32, y: f32, loc := #caller_location)                                                                {        impl_VertexAttrib2f(index, x, y);                                          debug_helper(loc, 0, index, x, y)                                                    }
+	VertexAttrib2fv          :: proc "c" (index: u32, v: ^[2]f32, loc := #caller_location)                                                                       {        impl_VertexAttrib2fv(index, v);                                            debug_helper(loc, 0, index, v)                                                       }
+	VertexAttrib2s           :: proc "c" (index: u32, x: i16, y: i16, loc := #caller_location)                                                                {        impl_VertexAttrib2s(index, x, y);                                          debug_helper(loc, 0, index, x, y)                                                    }
+	VertexAttrib2sv          :: proc "c" (index: u32, v: ^[2]i16, loc := #caller_location)                                                                       {        impl_VertexAttrib2sv(index, v);                                            debug_helper(loc, 0, index, v)                                                       }
+	VertexAttrib3d           :: proc "c" (index: u32, x: f64, y: f64, z: f64, loc := #caller_location)                                                        {        impl_VertexAttrib3d(index, x, y, z);                                       debug_helper(loc, 0, index, x, y, z)                                                 }
+	VertexAttrib3dv          :: proc "c" (index: u32, v: ^[3]f64, loc := #caller_location)                                                                       {        impl_VertexAttrib3dv(index, v);                                            debug_helper(loc, 0, index, v)                                                       }
+	VertexAttrib3f           :: proc "c" (index: u32, x: f32, y: f32, z: f32, loc := #caller_location)                                                        {        impl_VertexAttrib3f(index, x, y, z);                                       debug_helper(loc, 0, index, x, y, z)                                                 }
+	VertexAttrib3fv          :: proc "c" (index: u32, v: ^[3]f32, loc := #caller_location)                                                                       {        impl_VertexAttrib3fv(index, v);                                            debug_helper(loc, 0, index, v)                                                       }
+	VertexAttrib3s           :: proc "c" (index: u32, x: i16, y: i16, z: i16, loc := #caller_location)                                                        {        impl_VertexAttrib3s(index, x, y, z);                                       debug_helper(loc, 0, index, x, y, z)                                                 }
+	VertexAttrib3sv          :: proc "c" (index: u32, v: ^[3]i16, loc := #caller_location)                                                                       {        impl_VertexAttrib3sv(index, v);                                            debug_helper(loc, 0, index, v)                                                       }
+	VertexAttrib4Nbv         :: proc "c" (index: u32, v: ^[4]i8, loc := #caller_location)                                                                        {        impl_VertexAttrib4Nbv(index, v);                                           debug_helper(loc, 0, index, v)                                                       }
+	VertexAttrib4Niv         :: proc "c" (index: u32, v: ^[4]i32, loc := #caller_location)                                                                       {        impl_VertexAttrib4Niv(index, v);                                           debug_helper(loc, 0, index, v)                                                       }
+	VertexAttrib4Nsv         :: proc "c" (index: u32, v: ^[4]i16, loc := #caller_location)                                                                       {        impl_VertexAttrib4Nsv(index, v);                                           debug_helper(loc, 0, index, v)                                                       }
+	VertexAttrib4Nub         :: proc "c" (index: u32, x: u8, y: u8, z: u8, w: u8, loc := #caller_location)                                                    {        impl_VertexAttrib4Nub(index, x, y, z, w);                                  debug_helper(loc, 0, index, x, y, z, w)                                              }
+	VertexAttrib4Nubv        :: proc "c" (index: u32, v: ^[4]u8, loc := #caller_location)                                                                        {        impl_VertexAttrib4Nubv(index, v);                                          debug_helper(loc, 0, index, v)                                                       }
+	VertexAttrib4Nuiv        :: proc "c" (index: u32, v: ^[4]u32, loc := #caller_location)                                                                       {        impl_VertexAttrib4Nuiv(index, v);                                          debug_helper(loc, 0, index, v)                                                       }
+	VertexAttrib4Nusv        :: proc "c" (index: u32, v: ^[4]u16, loc := #caller_location)                                                                       {        impl_VertexAttrib4Nusv(index, v);                                          debug_helper(loc, 0, index, v)                                                       }
+	VertexAttrib4bv          :: proc "c" (index: u32, v: ^[4]i8, loc := #caller_location)                                                                        {        impl_VertexAttrib4bv(index, v);                                            debug_helper(loc, 0, index, v)                                                       }
+	VertexAttrib4d           :: proc "c" (index: u32, x: f64, y: f64, z: f64, w: f64, loc := #caller_location)                                                {        impl_VertexAttrib4d(index, x, y, z, w);                                    debug_helper(loc, 0, index, x, y, z, w)                                              }
+	VertexAttrib4dv          :: proc "c" (index: u32, v: ^[4]f64, loc := #caller_location)                                                                       {        impl_VertexAttrib4dv(index, v);                                            debug_helper(loc, 0, index, v)                                                       }
+	VertexAttrib4f           :: proc "c" (index: u32, x: f32, y: f32, z: f32, w: f32, loc := #caller_location)                                                {        impl_VertexAttrib4f(index, x, y, z, w);                                    debug_helper(loc, 0, index, x, y, z, w)                                              }
+	VertexAttrib4fv          :: proc "c" (index: u32, v: ^[4]f32, loc := #caller_location)                                                                       {        impl_VertexAttrib4fv(index, v);                                            debug_helper(loc, 0, index, v)                                                       }
+	VertexAttrib4iv          :: proc "c" (index: u32, v: ^[4]i32, loc := #caller_location)                                                                       {        impl_VertexAttrib4iv(index, v);                                            debug_helper(loc, 0, index, v)                                                       }
+	VertexAttrib4s           :: proc "c" (index: u32, x: i16, y: i16, z: i16, w: i16, loc := #caller_location)                                                {        impl_VertexAttrib4s(index, x, y, z, w);                                    debug_helper(loc, 0, index, x, y, z, w)                                              }
+	VertexAttrib4sv          :: proc "c" (index: u32, v: ^[4]i16, loc := #caller_location)                                                                       {        impl_VertexAttrib4sv(index, v);                                            debug_helper(loc, 0, index, v)                                                       }
+	VertexAttrib4ubv         :: proc "c" (index: u32, v: ^[4]u8, loc := #caller_location)                                                                        {        impl_VertexAttrib4ubv(index, v);                                           debug_helper(loc, 0, index, v)                                                       }
+	VertexAttrib4uiv         :: proc "c" (index: u32, v: ^[4]u32, loc := #caller_location)                                                                       {        impl_VertexAttrib4uiv(index, v);                                           debug_helper(loc, 0, index, v)                                                       }
+	VertexAttrib4usv         :: proc "c" (index: u32, v: ^[4]u16, loc := #caller_location)                                                                       {        impl_VertexAttrib4usv(index, v);                                           debug_helper(loc, 0, index, v)                                                       }
+	VertexAttribPointer      :: proc "c" (index: u32, size: i32, type: u32, normalized: bool, stride: i32, pointer: uintptr, loc := #caller_location)          {        impl_VertexAttribPointer(index, size, type, normalized, stride, pointer); debug_helper(loc, 0, index, size, type, normalized, stride, pointer)                }
 
 	// VERSION_2_1
-	UniformMatrix2x3fv :: #force_inline proc "c" (location: i32, count: i32, transpose: bool, value: [^]f32, loc := #caller_location) { impl_UniformMatrix2x3fv(location, count, transpose, value); debug_helper(loc, 0, location, count, transpose, value) }
-	UniformMatrix3x2fv :: #force_inline proc "c" (location: i32, count: i32, transpose: bool, value: [^]f32, loc := #caller_location) { impl_UniformMatrix3x2fv(location, count, transpose, value); debug_helper(loc, 0, location, count, transpose, value) }
-	UniformMatrix2x4fv :: #force_inline proc "c" (location: i32, count: i32, transpose: bool, value: [^]f32, loc := #caller_location) { impl_UniformMatrix2x4fv(location, count, transpose, value); debug_helper(loc, 0, location, count, transpose, value) }
-	UniformMatrix4x2fv :: #force_inline proc "c" (location: i32, count: i32, transpose: bool, value: [^]f32, loc := #caller_location) { impl_UniformMatrix4x2fv(location, count, transpose, value); debug_helper(loc, 0, location, count, transpose, value) }
-	UniformMatrix3x4fv :: #force_inline proc "c" (location: i32, count: i32, transpose: bool, value: [^]f32, loc := #caller_location) { impl_UniformMatrix3x4fv(location, count, transpose, value); debug_helper(loc, 0, location, count, transpose, value) }
-	UniformMatrix4x3fv :: #force_inline proc "c" (location: i32, count: i32, transpose: bool, value: [^]f32, loc := #caller_location) { impl_UniformMatrix4x3fv(location, count, transpose, value); debug_helper(loc, 0, location, count, transpose, value) }
+	UniformMatrix2x3fv :: proc "c" (location: i32, count: i32, transpose: bool, value: [^]f32, loc := #caller_location) { impl_UniformMatrix2x3fv(location, count, transpose, value); debug_helper(loc, 0, location, count, transpose, value) }
+	UniformMatrix3x2fv :: proc "c" (location: i32, count: i32, transpose: bool, value: [^]f32, loc := #caller_location) { impl_UniformMatrix3x2fv(location, count, transpose, value); debug_helper(loc, 0, location, count, transpose, value) }
+	UniformMatrix2x4fv :: proc "c" (location: i32, count: i32, transpose: bool, value: [^]f32, loc := #caller_location) { impl_UniformMatrix2x4fv(location, count, transpose, value); debug_helper(loc, 0, location, count, transpose, value) }
+	UniformMatrix4x2fv :: proc "c" (location: i32, count: i32, transpose: bool, value: [^]f32, loc := #caller_location) { impl_UniformMatrix4x2fv(location, count, transpose, value); debug_helper(loc, 0, location, count, transpose, value) }
+	UniformMatrix3x4fv :: proc "c" (location: i32, count: i32, transpose: bool, value: [^]f32, loc := #caller_location) { impl_UniformMatrix3x4fv(location, count, transpose, value); debug_helper(loc, 0, location, count, transpose, value) }
+	UniformMatrix4x3fv :: proc "c" (location: i32, count: i32, transpose: bool, value: [^]f32, loc := #caller_location) { impl_UniformMatrix4x3fv(location, count, transpose, value); debug_helper(loc, 0, location, count, transpose, value) }
 
 		// VERSION_3_0
-	ColorMaski                          :: #force_inline proc "c" (index: u32, r: bool, g: bool, b: bool, a: bool, loc := #caller_location)                                                                         {        impl_ColorMaski(index, r, g, b, a);                                                         debug_helper(loc, 0, index, r, g, b, a)                                                                }
-	GetBooleani_v                       :: #force_inline proc "c" (target: u32, index: u32, data: ^bool, loc := #caller_location)                                                                                   {        impl_GetBooleani_v(target, index, data);                                                    debug_helper(loc, 0, target, index, data)                                                              }
-	GetIntegeri_v                       :: #force_inline proc "c" (target: u32, index: u32, data: ^i32, loc := #caller_location)                                                                                    {        impl_GetIntegeri_v(target, index, data);                                                    debug_helper(loc, 0, target, index, data)                                                              }
-	Enablei                             :: #force_inline proc "c" (target: u32, index: u32, loc := #caller_location)                                                                                                {        impl_Enablei(target, index);                                                                debug_helper(loc, 0, target, index)                                                                    }
-	Disablei                            :: #force_inline proc "c" (target: u32, index: u32, loc := #caller_location)                                                                                                {        impl_Disablei(target, index);                                                               debug_helper(loc, 0, target, index)                                                                    }
-	IsEnabledi                          :: #force_inline proc "c" (target: u32, index: u32, loc := #caller_location) -> bool                                                                                        { ret := impl_IsEnabledi(target, index);                                                             debug_helper(loc, 1, ret, target, index);                                                   return ret }
-	BeginTransformFeedback              :: #force_inline proc "c" (primitiveMode: u32, loc := #caller_location)                                                                                                     {        impl_BeginTransformFeedback(primitiveMode);                                                 debug_helper(loc, 0, primitiveMode)                                                                    }
-	EndTransformFeedback                :: #force_inline proc "c" (loc := #caller_location)                                                                                                                         {        impl_EndTransformFeedback();                                                                debug_helper(loc, 0)                                                                                   }
-	BindBufferRange                     :: #force_inline proc "c" (target: u32, index: u32, buffer: u32, offset: int, size: int, loc := #caller_location)                                                           {        impl_BindBufferRange(target, index, buffer, offset, size);                                  debug_helper(loc, 0, target, index, buffer, offset, size)                                              }
-	BindBufferBase                      :: #force_inline proc "c" (target: u32, index: u32, buffer: u32, loc := #caller_location)                                                                                   {        impl_BindBufferBase(target, index, buffer);                                                 debug_helper(loc, 0, target, index, buffer)                                                            }
-	TransformFeedbackVaryings           :: #force_inline proc "c" (program: u32, count: i32, varyings: [^]cstring, bufferMode: u32, loc := #caller_location)                                                        {        impl_TransformFeedbackVaryings(program, count, varyings, bufferMode);                       debug_helper(loc, 0, program, count, varyings, bufferMode)                                             }
-	GetTransformFeedbackVarying         :: #force_inline proc "c" (program: u32, index: u32, bufSize: i32, length: ^i32, size: ^i32, type: ^u32, name: [^]u8, loc := #caller_location)                              {        impl_GetTransformFeedbackVarying(program, index, bufSize, length, size, type, name);       debug_helper(loc, 0, program, index, bufSize, length, size, type, name)                               }
-	ClampColor                          :: #force_inline proc "c" (target: u32, clamp: u32, loc := #caller_location)                                                                                                {        impl_ClampColor(target, clamp);                                                             debug_helper(loc, 0, target, clamp)                                                                    }
-	BeginConditionalRender              :: #force_inline proc "c" (id: u32, mode: u32, loc := #caller_location)                                                                                                     {        impl_BeginConditionalRender(id, mode);                                                      debug_helper(loc, 0, id, mode)                                                                         }
-	EndConditionalRender                :: #force_inline proc "c" (loc := #caller_location)                                                                                                                         {        impl_EndConditionalRender();                                                                debug_helper(loc, 0)                                                                                   }
-	VertexAttribIPointer                :: #force_inline proc "c" (index: u32, size: i32, type: u32, stride: i32, pointer: uintptr, loc := #caller_location)                                                         {        impl_VertexAttribIPointer(index, size, type, stride, pointer);                             debug_helper(loc, 0, index, size, type, stride, pointer)                                              }
-	GetVertexAttribIiv                  :: #force_inline proc "c" (index: u32, pname: u32, params: [^]i32, loc := #caller_location)                                                                                 {        impl_GetVertexAttribIiv(index, pname, params);                                              debug_helper(loc, 0, index, pname, params)                                                             }
-	GetVertexAttribIuiv                 :: #force_inline proc "c" (index: u32, pname: u32, params: [^]u32, loc := #caller_location)                                                                                 {        impl_GetVertexAttribIuiv(index, pname, params);                                             debug_helper(loc, 0, index, pname, params)                                                             }
-	VertexAttribI1i                     :: #force_inline proc "c" (index: u32, x: i32, loc := #caller_location)                                                                                                     {        impl_VertexAttribI1i(index, x);                                                             debug_helper(loc, 0, index, x)                                                                         }
-	VertexAttribI2i                     :: #force_inline proc "c" (index: u32, x: i32, y: i32, loc := #caller_location)                                                                                             {        impl_VertexAttribI2i(index, x, y);                                                          debug_helper(loc, 0, index, x, y)                                                                      }
-	VertexAttribI3i                     :: #force_inline proc "c" (index: u32, x: i32, y: i32, z: i32, loc := #caller_location)                                                                                     {        impl_VertexAttribI3i(index, x, y, z);                                                       debug_helper(loc, 0, index, x, y, z)                                                                   }
-	VertexAttribI4i                     :: #force_inline proc "c" (index: u32, x: i32, y: i32, z: i32, w: i32, loc := #caller_location)                                                                             {        impl_VertexAttribI4i(index, x, y, z, w);                                                    debug_helper(loc, 0, index, x, y, z, w)                                                                }
-	VertexAttribI1ui                    :: #force_inline proc "c" (index: u32, x: u32, loc := #caller_location)                                                                                                     {        impl_VertexAttribI1ui(index, x);                                                            debug_helper(loc, 0, index, x)                                                                         }
-	VertexAttribI2ui                    :: #force_inline proc "c" (index: u32, x: u32, y: u32, loc := #caller_location)                                                                                             {        impl_VertexAttribI2ui(index, x, y);                                                         debug_helper(loc, 0, index, x, y)                                                                      }
-	VertexAttribI3ui                    :: #force_inline proc "c" (index: u32, x: u32, y: u32, z: u32, loc := #caller_location)                                                                                     {        impl_VertexAttribI3ui(index, x, y, z);                                                      debug_helper(loc, 0, index, x, y, z)                                                                   }
-	VertexAttribI4ui                    :: #force_inline proc "c" (index: u32, x: u32, y: u32, z: u32, w: u32, loc := #caller_location)                                                                             {        impl_VertexAttribI4ui(index, x, y, z, w);                                                   debug_helper(loc, 0, index, x, y, z, w)                                                                }
-	VertexAttribI1iv                    :: #force_inline proc "c" (index: u32, v: [^]i32, loc := #caller_location)                                                                                                    {        impl_VertexAttribI1iv(index, v);                                                            debug_helper(loc, 0, index, v)                                                                         }
-	VertexAttribI2iv                    :: #force_inline proc "c" (index: u32, v: [^]i32, loc := #caller_location)                                                                                                    {        impl_VertexAttribI2iv(index, v);                                                            debug_helper(loc, 0, index, v)                                                                         }
-	VertexAttribI3iv                    :: #force_inline proc "c" (index: u32, v: [^]i32, loc := #caller_location)                                                                                                    {        impl_VertexAttribI3iv(index, v);                                                            debug_helper(loc, 0, index, v)                                                                         }
-	VertexAttribI4iv                    :: #force_inline proc "c" (index: u32, v: [^]i32, loc := #caller_location)                                                                                                    {        impl_VertexAttribI4iv(index, v);                                                            debug_helper(loc, 0, index, v)                                                                         }
-	VertexAttribI1uiv                   :: #force_inline proc "c" (index: u32, v: [^]u32, loc := #caller_location)                                                                                                    {        impl_VertexAttribI1uiv(index, v);                                                           debug_helper(loc, 0, index, v)                                                                         }
-	VertexAttribI2uiv                   :: #force_inline proc "c" (index: u32, v: [^]u32, loc := #caller_location)                                                                                                    {        impl_VertexAttribI2uiv(index, v);                                                           debug_helper(loc, 0, index, v)                                                                         }
-	VertexAttribI3uiv                   :: #force_inline proc "c" (index: u32, v: [^]u32, loc := #caller_location)                                                                                                    {        impl_VertexAttribI3uiv(index, v);                                                           debug_helper(loc, 0, index, v)                                                                         }
-	VertexAttribI4uiv                   :: #force_inline proc "c" (index: u32, v: [^]u32, loc := #caller_location)                                                                                                    {        impl_VertexAttribI4uiv(index, v);                                                           debug_helper(loc, 0, index, v)                                                                         }
-	VertexAttribI4bv                    :: #force_inline proc "c" (index: u32, v: [^]i8, loc := #caller_location)                                                                                                     {        impl_VertexAttribI4bv(index, v);                                                            debug_helper(loc, 0, index, v)                                                                         }
-	VertexAttribI4sv                    :: #force_inline proc "c" (index: u32, v: [^]i16, loc := #caller_location)                                                                                                    {        impl_VertexAttribI4sv(index, v);                                                            debug_helper(loc, 0, index, v)                                                                         }
-	VertexAttribI4ubv                   :: #force_inline proc "c" (index: u32, v: [^]u8, loc := #caller_location)                                                                                                     {        impl_VertexAttribI4ubv(index, v);                                                           debug_helper(loc, 0, index, v)                                                                         }
-	VertexAttribI4usv                   :: #force_inline proc "c" (index: u32, v: [^]u16, loc := #caller_location)                                                                                                    {        impl_VertexAttribI4usv(index, v);                                                           debug_helper(loc, 0, index, v)                                                                         }
-	GetUniformuiv                       :: #force_inline proc "c" (program: u32, location: i32, params: [^]u32, loc := #caller_location)                                                                            {        impl_GetUniformuiv(program, location, params);                                              debug_helper(loc, 0, program, location, params)                                                        }
-	BindFragDataLocation                :: #force_inline proc "c" (program: u32, color: u32, name: cstring, loc := #caller_location)                                                                                {        impl_BindFragDataLocation(program, color, name);                                            debug_helper(loc, 0, program, color, name)                                                             }
-	GetFragDataLocation                 :: #force_inline proc "c" (program: u32, name: cstring, loc := #caller_location) -> i32                                                                                     { ret := impl_GetFragDataLocation(program, name);                                                    debug_helper(loc, 1, ret, program, name);                                                   return ret }
-	Uniform1ui                          :: #force_inline proc "c" (location: i32, v0: u32, loc := #caller_location)                                                                                                 {        impl_Uniform1ui(location, v0);                                                              debug_helper(loc, 0, location, v0)                                                                     }
-	Uniform2ui                          :: #force_inline proc "c" (location: i32, v0: u32, v1: u32, loc := #caller_location)                                                                                        {        impl_Uniform2ui(location, v0, v1);                                                          debug_helper(loc, 0, location, v0, v1)                                                                 }
-	Uniform3ui                          :: #force_inline proc "c" (location: i32, v0: u32, v1: u32, v2: u32, loc := #caller_location)                                                                               {        impl_Uniform3ui(location, v0, v1, v2);                                                      debug_helper(loc, 0, location, v0, v1, v2)                                                             }
-	Uniform4ui                          :: #force_inline proc "c" (location: i32, v0: u32, v1: u32, v2: u32, v3: u32, loc := #caller_location)                                                                      {        impl_Uniform4ui(location, v0, v1, v2, v3);                                                  debug_helper(loc, 0, location, v0, v1, v2, v3)                                                         }
-	Uniform1uiv                         :: #force_inline proc "c" (location: i32, count: i32, value: [^]u32, loc := #caller_location)                                                                               {        impl_Uniform1uiv(location, count, value);                                                   debug_helper(loc, 0, location, count, value)                                                           }
-	Uniform2uiv                         :: #force_inline proc "c" (location: i32, count: i32, value: [^]u32, loc := #caller_location)                                                                               {        impl_Uniform2uiv(location, count, value);                                                   debug_helper(loc, 0, location, count, value)                                                           }
-	Uniform3uiv                         :: #force_inline proc "c" (location: i32, count: i32, value: [^]u32, loc := #caller_location)                                                                               {        impl_Uniform3uiv(location, count, value);                                                   debug_helper(loc, 0, location, count, value)                                                           }
-	Uniform4uiv                         :: #force_inline proc "c" (location: i32, count: i32, value: [^]u32, loc := #caller_location)                                                                               {        impl_Uniform4uiv(location, count, value);                                                   debug_helper(loc, 0, location, count, value)                                                           }
-	TexParameterIiv                     :: #force_inline proc "c" (target: u32, pname: u32, params: [^]i32, loc := #caller_location)                                                                                {        impl_TexParameterIiv(target, pname, params);                                                debug_helper(loc, 0, target, pname, params)                                                            }
-	TexParameterIuiv                    :: #force_inline proc "c" (target: u32, pname: u32, params: [^]u32, loc := #caller_location)                                                                                {        impl_TexParameterIuiv(target, pname, params);                                               debug_helper(loc, 0, target, pname, params)                                                            }
-	GetTexParameterIiv                  :: #force_inline proc "c" (target: u32, pname: u32, params: [^]i32, loc := #caller_location)                                                                                {        impl_GetTexParameterIiv(target, pname, params);                                             debug_helper(loc, 0, target, pname, params)                                                            }
-	GetTexParameterIuiv                 :: #force_inline proc "c" (target: u32, pname: u32, params: [^]u32, loc := #caller_location)                                                                                {        impl_GetTexParameterIuiv(target, pname, params);                                            debug_helper(loc, 0, target, pname, params)                                                            }
-	ClearBufferiv                       :: #force_inline proc "c" (buffer: u32, drawbuffer: i32, value: ^i32, loc := #caller_location)                                                                              {        impl_ClearBufferiv(buffer, drawbuffer, value);                                              debug_helper(loc, 0, buffer, drawbuffer, value)                                                        }
-	ClearBufferuiv                      :: #force_inline proc "c" (buffer: u32, drawbuffer: i32, value: ^u32, loc := #caller_location)                                                                              {        impl_ClearBufferuiv(buffer, drawbuffer, value);                                             debug_helper(loc, 0, buffer, drawbuffer, value)                                                        }
-	ClearBufferfv                       :: #force_inline proc "c" (buffer: u32, drawbuffer: i32, value: ^f32, loc := #caller_location)                                                                              {        impl_ClearBufferfv(buffer, drawbuffer, value);                                              debug_helper(loc, 0, buffer, drawbuffer, value)                                                        }
-	ClearBufferfi                       :: #force_inline proc "c" (buffer: u32, drawbuffer: i32, depth: f32, stencil: i32, loc := #caller_location) -> rawptr                                                       { ret := impl_ClearBufferfi(buffer, drawbuffer, depth, stencil);                                     debug_helper(loc, 1, ret, buffer, drawbuffer, depth, stencil);                              return ret }
-	GetStringi                          :: #force_inline proc "c" (name: u32, index: u32, loc := #caller_location) -> cstring                                                                                       { ret := impl_GetStringi(name, index);                                                               debug_helper(loc, 1, ret, name, index);                                                     return ret }
-	IsRenderbuffer                      :: #force_inline proc "c" (renderbuffer: u32, loc := #caller_location) -> bool                                                                                              { ret := impl_IsRenderbuffer(renderbuffer);                                                          debug_helper(loc, 1, ret, renderbuffer);                                                    return ret }
-	BindRenderbuffer                    :: #force_inline proc "c" (target: u32, renderbuffer: u32, loc := #caller_location)                                                                                         {        impl_BindRenderbuffer(target, renderbuffer);                                                debug_helper(loc, 0, target, renderbuffer)                                                             }
-	DeleteRenderbuffers                 :: #force_inline proc "c" (n: i32, renderbuffers: [^]u32, loc := #caller_location)                                                                                          {        impl_DeleteRenderbuffers(n, renderbuffers);                                                 debug_helper(loc, 0, n, renderbuffers)                                                                 }
-	GenRenderbuffers                    :: #force_inline proc "c" (n: i32, renderbuffers: [^]u32, loc := #caller_location)                                                                                          {        impl_GenRenderbuffers(n, renderbuffers);                                                    debug_helper(loc, 0, n, renderbuffers)                                                                 }
-	RenderbufferStorage                 :: #force_inline proc "c" (target: u32, internalformat: u32, width: i32, height: i32, loc := #caller_location)                                                              {        impl_RenderbufferStorage(target, internalformat, width, height);                            debug_helper(loc, 0, target, internalformat, width, height)                                            }
-	GetRenderbufferParameteriv          :: #force_inline proc "c" (target: u32, pname: u32, params: [^]i32, loc := #caller_location)                                                                                {        impl_GetRenderbufferParameteriv(target, pname, params);                                     debug_helper(loc, 0, target, pname, params)                                                            }
-	IsFramebuffer                       :: #force_inline proc "c" (framebuffer: u32, loc := #caller_location) -> bool                                                                                               { ret := impl_IsFramebuffer(framebuffer);                                                            debug_helper(loc, 1, ret, framebuffer);                                                     return ret }
-	BindFramebuffer                     :: #force_inline proc "c" (target: u32, framebuffer: u32, loc := #caller_location)                                                                                          {        impl_BindFramebuffer(target, framebuffer);                                                  debug_helper(loc, 0, target, framebuffer)                                                              }
-	DeleteFramebuffers                  :: #force_inline proc "c" (n: i32, framebuffers: [^]u32, loc := #caller_location)                                                                                           {        impl_DeleteFramebuffers(n, framebuffers);                                                   debug_helper(loc, 0, n, framebuffers)                                                                  }
-	GenFramebuffers                     :: #force_inline proc "c" (n: i32, framebuffers: [^]u32, loc := #caller_location)                                                                                           {        impl_GenFramebuffers(n, framebuffers);                                                      debug_helper(loc, 0, n, framebuffers)                                                                  }
-	CheckFramebufferStatus              :: #force_inline proc "c" (target: u32, loc := #caller_location) -> u32                                                                                                     { ret := impl_CheckFramebufferStatus(target);                                                        debug_helper(loc, 1, ret, target);                                                          return ret }
-	FramebufferTexture1D                :: #force_inline proc "c" (target: u32, attachment: u32, textarget: u32, texture: u32, level: i32, loc := #caller_location)                                                 {        impl_FramebufferTexture1D(target, attachment, textarget, texture, level);                   debug_helper(loc, 0, target, attachment, textarget, texture, level)                                    }
-	FramebufferTexture2D                :: #force_inline proc "c" (target: u32, attachment: u32, textarget: u32, texture: u32, level: i32, loc := #caller_location)                                                 {        impl_FramebufferTexture2D(target, attachment, textarget, texture, level);                   debug_helper(loc, 0, target, attachment, textarget, texture, level)                                    }
-	FramebufferTexture3D                :: #force_inline proc "c" (target: u32, attachment: u32, textarget: u32, texture: u32, level: i32, zoffset: i32, loc := #caller_location)                                   {        impl_FramebufferTexture3D(target, attachment, textarget, texture, level, zoffset);          debug_helper(loc, 0, target, attachment, textarget, texture, level, zoffset)                           }
-	FramebufferRenderbuffer             :: #force_inline proc "c" (target: u32, attachment: u32, renderbuffertarget: u32, renderbuffer: u32, loc := #caller_location)                                               {        impl_FramebufferRenderbuffer(target, attachment, renderbuffertarget, renderbuffer);         debug_helper(loc, 0, target, attachment, renderbuffertarget, renderbuffer)                             }
-	GetFramebufferAttachmentParameteriv :: #force_inline proc "c" (target: u32, attachment: u32, pname: u32, params: [^]i32, loc := #caller_location)                                                               {        impl_GetFramebufferAttachmentParameteriv(target, attachment, pname, params);                debug_helper(loc, 0, target, attachment, pname, params)                                                }
-	GenerateMipmap                      :: #force_inline proc "c" (target: u32, loc := #caller_location)                                                                                                            {        impl_GenerateMipmap(target);                                                                debug_helper(loc, 0, target)                                                                           }
-	BlitFramebuffer                     :: #force_inline proc "c" (srcX0: i32, srcY0: i32, srcX1: i32, srcY1: i32, dstX0: i32, dstY0: i32, dstX1: i32, dstY1: i32, mask: u32, filter: u32, loc := #caller_location) {        impl_BlitFramebuffer(srcX0, srcY0, srcX1, srcY1, dstX0, dstY0, dstX1, dstY1, mask, filter); debug_helper(loc, 0, srcX0, srcY0, srcX1, srcY1, dstX0, dstY0, dstX1, dstY1, mask, filter)             }
-	RenderbufferStorageMultisample      :: #force_inline proc "c" (target: u32, samples: i32, internalformat: u32, width: i32, height: i32, loc := #caller_location)                                                {        impl_RenderbufferStorageMultisample(target, samples, internalformat, width, height);        debug_helper(loc, 0, target, samples, internalformat, width, height)                                   }
-	FramebufferTextureLayer             :: #force_inline proc "c" (target: u32, attachment: u32, texture: u32, level: i32, layer: i32, loc := #caller_location)                                                     {        impl_FramebufferTextureLayer(target, attachment, texture, level, layer);                    debug_helper(loc, 0, target, attachment, texture, level, layer)                                        }
-	MapBufferRange                      :: #force_inline proc "c" (target: u32, offset: int, length: int, access: u32, loc := #caller_location) -> rawptr                                                           { ret := impl_MapBufferRange(target, offset, length, access);                                        debug_helper(loc, 1, ret, target, offset, length, access);                                  return ret }
-	FlushMappedBufferRange              :: #force_inline proc "c" (target: u32, offset: int, length: int, loc := #caller_location)                                                                                  {        impl_FlushMappedBufferRange(target, offset, length);                                        debug_helper(loc, 0, target, offset, length)                                                           }
-	BindVertexArray                     :: #force_inline proc "c" (array: u32, loc := #caller_location)                                                                                                             {        impl_BindVertexArray(array);                                                                debug_helper(loc, 0, array)                                                                            }
-	DeleteVertexArrays                  :: #force_inline proc "c" (n: i32, arrays: [^]u32, loc := #caller_location)                                                                                                 {        impl_DeleteVertexArrays(n, arrays);                                                         debug_helper(loc, 0, n, arrays)                                                                        }
-	GenVertexArrays                     :: #force_inline proc "c" (n: i32, arrays: [^]u32, loc := #caller_location)                                                                                                 {        impl_GenVertexArrays(n, arrays);                                                            debug_helper(loc, 0, n, arrays)                                                                        }
-	IsVertexArray                       :: #force_inline proc "c" (array: u32, loc := #caller_location) -> bool                                                                                                     { ret := impl_IsVertexArray(array);                                                                  debug_helper(loc, 1, ret, array);                                                           return ret }
+	ColorMaski                          :: proc "c" (index: u32, r: bool, g: bool, b: bool, a: bool, loc := #caller_location)                                                                         {        impl_ColorMaski(index, r, g, b, a);                                                         debug_helper(loc, 0, index, r, g, b, a)                                                                }
+	GetBooleani_v                       :: proc "c" (target: u32, index: u32, data: ^bool, loc := #caller_location)                                                                                   {        impl_GetBooleani_v(target, index, data);                                                    debug_helper(loc, 0, target, index, data)                                                              }
+	GetIntegeri_v                       :: proc "c" (target: u32, index: u32, data: ^i32, loc := #caller_location)                                                                                    {        impl_GetIntegeri_v(target, index, data);                                                    debug_helper(loc, 0, target, index, data)                                                              }
+	Enablei                             :: proc "c" (target: u32, index: u32, loc := #caller_location)                                                                                                {        impl_Enablei(target, index);                                                                debug_helper(loc, 0, target, index)                                                                    }
+	Disablei                            :: proc "c" (target: u32, index: u32, loc := #caller_location)                                                                                                {        impl_Disablei(target, index);                                                               debug_helper(loc, 0, target, index)                                                                    }
+	IsEnabledi                          :: proc "c" (target: u32, index: u32, loc := #caller_location) -> bool                                                                                        { ret := impl_IsEnabledi(target, index);                                                             debug_helper(loc, 1, ret, target, index);                                                   return ret }
+	BeginTransformFeedback              :: proc "c" (primitiveMode: u32, loc := #caller_location)                                                                                                     {        impl_BeginTransformFeedback(primitiveMode);                                                 debug_helper(loc, 0, primitiveMode)                                                                    }
+	EndTransformFeedback                :: proc "c" (loc := #caller_location)                                                                                                                         {        impl_EndTransformFeedback();                                                                debug_helper(loc, 0)                                                                                   }
+	BindBufferRange                     :: proc "c" (target: u32, index: u32, buffer: u32, offset: int, size: int, loc := #caller_location)                                                           {        impl_BindBufferRange(target, index, buffer, offset, size);                                  debug_helper(loc, 0, target, index, buffer, offset, size)                                              }
+	BindBufferBase                      :: proc "c" (target: u32, index: u32, buffer: u32, loc := #caller_location)                                                                                   {        impl_BindBufferBase(target, index, buffer);                                                 debug_helper(loc, 0, target, index, buffer)                                                            }
+	TransformFeedbackVaryings           :: proc "c" (program: u32, count: i32, varyings: [^]cstring, bufferMode: u32, loc := #caller_location)                                                        {        impl_TransformFeedbackVaryings(program, count, varyings, bufferMode);                       debug_helper(loc, 0, program, count, varyings, bufferMode)                                             }
+	GetTransformFeedbackVarying         :: proc "c" (program: u32, index: u32, bufSize: i32, length: ^i32, size: ^i32, type: ^u32, name: [^]u8, loc := #caller_location)                              {        impl_GetTransformFeedbackVarying(program, index, bufSize, length, size, type, name);       debug_helper(loc, 0, program, index, bufSize, length, size, type, name)                               }
+	ClampColor                          :: proc "c" (target: u32, clamp: u32, loc := #caller_location)                                                                                                {        impl_ClampColor(target, clamp);                                                             debug_helper(loc, 0, target, clamp)                                                                    }
+	BeginConditionalRender              :: proc "c" (id: u32, mode: u32, loc := #caller_location)                                                                                                     {        impl_BeginConditionalRender(id, mode);                                                      debug_helper(loc, 0, id, mode)                                                                         }
+	EndConditionalRender                :: proc "c" (loc := #caller_location)                                                                                                                         {        impl_EndConditionalRender();                                                                debug_helper(loc, 0)                                                                                   }
+	VertexAttribIPointer                :: proc "c" (index: u32, size: i32, type: u32, stride: i32, pointer: uintptr, loc := #caller_location)                                                         {        impl_VertexAttribIPointer(index, size, type, stride, pointer);                             debug_helper(loc, 0, index, size, type, stride, pointer)                                              }
+	GetVertexAttribIiv                  :: proc "c" (index: u32, pname: u32, params: [^]i32, loc := #caller_location)                                                                                 {        impl_GetVertexAttribIiv(index, pname, params);                                              debug_helper(loc, 0, index, pname, params)                                                             }
+	GetVertexAttribIuiv                 :: proc "c" (index: u32, pname: u32, params: [^]u32, loc := #caller_location)                                                                                 {        impl_GetVertexAttribIuiv(index, pname, params);                                             debug_helper(loc, 0, index, pname, params)                                                             }
+	VertexAttribI1i                     :: proc "c" (index: u32, x: i32, loc := #caller_location)                                                                                                     {        impl_VertexAttribI1i(index, x);                                                             debug_helper(loc, 0, index, x)                                                                         }
+	VertexAttribI2i                     :: proc "c" (index: u32, x: i32, y: i32, loc := #caller_location)                                                                                             {        impl_VertexAttribI2i(index, x, y);                                                          debug_helper(loc, 0, index, x, y)                                                                      }
+	VertexAttribI3i                     :: proc "c" (index: u32, x: i32, y: i32, z: i32, loc := #caller_location)                                                                                     {        impl_VertexAttribI3i(index, x, y, z);                                                       debug_helper(loc, 0, index, x, y, z)                                                                   }
+	VertexAttribI4i                     :: proc "c" (index: u32, x: i32, y: i32, z: i32, w: i32, loc := #caller_location)                                                                             {        impl_VertexAttribI4i(index, x, y, z, w);                                                    debug_helper(loc, 0, index, x, y, z, w)                                                                }
+	VertexAttribI1ui                    :: proc "c" (index: u32, x: u32, loc := #caller_location)                                                                                                     {        impl_VertexAttribI1ui(index, x);                                                            debug_helper(loc, 0, index, x)                                                                         }
+	VertexAttribI2ui                    :: proc "c" (index: u32, x: u32, y: u32, loc := #caller_location)                                                                                             {        impl_VertexAttribI2ui(index, x, y);                                                         debug_helper(loc, 0, index, x, y)                                                                      }
+	VertexAttribI3ui                    :: proc "c" (index: u32, x: u32, y: u32, z: u32, loc := #caller_location)                                                                                     {        impl_VertexAttribI3ui(index, x, y, z);                                                      debug_helper(loc, 0, index, x, y, z)                                                                   }
+	VertexAttribI4ui                    :: proc "c" (index: u32, x: u32, y: u32, z: u32, w: u32, loc := #caller_location)                                                                             {        impl_VertexAttribI4ui(index, x, y, z, w);                                                   debug_helper(loc, 0, index, x, y, z, w)                                                                }
+	VertexAttribI1iv                    :: proc "c" (index: u32, v: [^]i32, loc := #caller_location)                                                                                                    {        impl_VertexAttribI1iv(index, v);                                                            debug_helper(loc, 0, index, v)                                                                         }
+	VertexAttribI2iv                    :: proc "c" (index: u32, v: [^]i32, loc := #caller_location)                                                                                                    {        impl_VertexAttribI2iv(index, v);                                                            debug_helper(loc, 0, index, v)                                                                         }
+	VertexAttribI3iv                    :: proc "c" (index: u32, v: [^]i32, loc := #caller_location)                                                                                                    {        impl_VertexAttribI3iv(index, v);                                                            debug_helper(loc, 0, index, v)                                                                         }
+	VertexAttribI4iv                    :: proc "c" (index: u32, v: [^]i32, loc := #caller_location)                                                                                                    {        impl_VertexAttribI4iv(index, v);                                                            debug_helper(loc, 0, index, v)                                                                         }
+	VertexAttribI1uiv                   :: proc "c" (index: u32, v: [^]u32, loc := #caller_location)                                                                                                    {        impl_VertexAttribI1uiv(index, v);                                                           debug_helper(loc, 0, index, v)                                                                         }
+	VertexAttribI2uiv                   :: proc "c" (index: u32, v: [^]u32, loc := #caller_location)                                                                                                    {        impl_VertexAttribI2uiv(index, v);                                                           debug_helper(loc, 0, index, v)                                                                         }
+	VertexAttribI3uiv                   :: proc "c" (index: u32, v: [^]u32, loc := #caller_location)                                                                                                    {        impl_VertexAttribI3uiv(index, v);                                                           debug_helper(loc, 0, index, v)                                                                         }
+	VertexAttribI4uiv                   :: proc "c" (index: u32, v: [^]u32, loc := #caller_location)                                                                                                    {        impl_VertexAttribI4uiv(index, v);                                                           debug_helper(loc, 0, index, v)                                                                         }
+	VertexAttribI4bv                    :: proc "c" (index: u32, v: [^]i8, loc := #caller_location)                                                                                                     {        impl_VertexAttribI4bv(index, v);                                                            debug_helper(loc, 0, index, v)                                                                         }
+	VertexAttribI4sv                    :: proc "c" (index: u32, v: [^]i16, loc := #caller_location)                                                                                                    {        impl_VertexAttribI4sv(index, v);                                                            debug_helper(loc, 0, index, v)                                                                         }
+	VertexAttribI4ubv                   :: proc "c" (index: u32, v: [^]u8, loc := #caller_location)                                                                                                     {        impl_VertexAttribI4ubv(index, v);                                                           debug_helper(loc, 0, index, v)                                                                         }
+	VertexAttribI4usv                   :: proc "c" (index: u32, v: [^]u16, loc := #caller_location)                                                                                                    {        impl_VertexAttribI4usv(index, v);                                                           debug_helper(loc, 0, index, v)                                                                         }
+	GetUniformuiv                       :: proc "c" (program: u32, location: i32, params: [^]u32, loc := #caller_location)                                                                            {        impl_GetUniformuiv(program, location, params);                                              debug_helper(loc, 0, program, location, params)                                                        }
+	BindFragDataLocation                :: proc "c" (program: u32, color: u32, name: cstring, loc := #caller_location)                                                                                {        impl_BindFragDataLocation(program, color, name);                                            debug_helper(loc, 0, program, color, name)                                                             }
+	GetFragDataLocation                 :: proc "c" (program: u32, name: cstring, loc := #caller_location) -> i32                                                                                     { ret := impl_GetFragDataLocation(program, name);                                                    debug_helper(loc, 1, ret, program, name);                                                   return ret }
+	Uniform1ui                          :: proc "c" (location: i32, v0: u32, loc := #caller_location)                                                                                                 {        impl_Uniform1ui(location, v0);                                                              debug_helper(loc, 0, location, v0)                                                                     }
+	Uniform2ui                          :: proc "c" (location: i32, v0: u32, v1: u32, loc := #caller_location)                                                                                        {        impl_Uniform2ui(location, v0, v1);                                                          debug_helper(loc, 0, location, v0, v1)                                                                 }
+	Uniform3ui                          :: proc "c" (location: i32, v0: u32, v1: u32, v2: u32, loc := #caller_location)                                                                               {        impl_Uniform3ui(location, v0, v1, v2);                                                      debug_helper(loc, 0, location, v0, v1, v2)                                                             }
+	Uniform4ui                          :: proc "c" (location: i32, v0: u32, v1: u32, v2: u32, v3: u32, loc := #caller_location)                                                                      {        impl_Uniform4ui(location, v0, v1, v2, v3);                                                  debug_helper(loc, 0, location, v0, v1, v2, v3)                                                         }
+	Uniform1uiv                         :: proc "c" (location: i32, count: i32, value: [^]u32, loc := #caller_location)                                                                               {        impl_Uniform1uiv(location, count, value);                                                   debug_helper(loc, 0, location, count, value)                                                           }
+	Uniform2uiv                         :: proc "c" (location: i32, count: i32, value: [^]u32, loc := #caller_location)                                                                               {        impl_Uniform2uiv(location, count, value);                                                   debug_helper(loc, 0, location, count, value)                                                           }
+	Uniform3uiv                         :: proc "c" (location: i32, count: i32, value: [^]u32, loc := #caller_location)                                                                               {        impl_Uniform3uiv(location, count, value);                                                   debug_helper(loc, 0, location, count, value)                                                           }
+	Uniform4uiv                         :: proc "c" (location: i32, count: i32, value: [^]u32, loc := #caller_location)                                                                               {        impl_Uniform4uiv(location, count, value);                                                   debug_helper(loc, 0, location, count, value)                                                           }
+	TexParameterIiv                     :: proc "c" (target: u32, pname: u32, params: [^]i32, loc := #caller_location)                                                                                {        impl_TexParameterIiv(target, pname, params);                                                debug_helper(loc, 0, target, pname, params)                                                            }
+	TexParameterIuiv                    :: proc "c" (target: u32, pname: u32, params: [^]u32, loc := #caller_location)                                                                                {        impl_TexParameterIuiv(target, pname, params);                                               debug_helper(loc, 0, target, pname, params)                                                            }
+	GetTexParameterIiv                  :: proc "c" (target: u32, pname: u32, params: [^]i32, loc := #caller_location)                                                                                {        impl_GetTexParameterIiv(target, pname, params);                                             debug_helper(loc, 0, target, pname, params)                                                            }
+	GetTexParameterIuiv                 :: proc "c" (target: u32, pname: u32, params: [^]u32, loc := #caller_location)                                                                                {        impl_GetTexParameterIuiv(target, pname, params);                                            debug_helper(loc, 0, target, pname, params)                                                            }
+	ClearBufferiv                       :: proc "c" (buffer: u32, drawbuffer: i32, value: ^i32, loc := #caller_location)                                                                              {        impl_ClearBufferiv(buffer, drawbuffer, value);                                              debug_helper(loc, 0, buffer, drawbuffer, value)                                                        }
+	ClearBufferuiv                      :: proc "c" (buffer: u32, drawbuffer: i32, value: ^u32, loc := #caller_location)                                                                              {        impl_ClearBufferuiv(buffer, drawbuffer, value);                                             debug_helper(loc, 0, buffer, drawbuffer, value)                                                        }
+	ClearBufferfv                       :: proc "c" (buffer: u32, drawbuffer: i32, value: ^f32, loc := #caller_location)                                                                              {        impl_ClearBufferfv(buffer, drawbuffer, value);                                              debug_helper(loc, 0, buffer, drawbuffer, value)                                                        }
+	ClearBufferfi                       :: proc "c" (buffer: u32, drawbuffer: i32, depth: f32, stencil: i32, loc := #caller_location) -> rawptr                                                       { ret := impl_ClearBufferfi(buffer, drawbuffer, depth, stencil);                                     debug_helper(loc, 1, ret, buffer, drawbuffer, depth, stencil);                              return ret }
+	GetStringi                          :: proc "c" (name: u32, index: u32, loc := #caller_location) -> cstring                                                                                       { ret := impl_GetStringi(name, index);                                                               debug_helper(loc, 1, ret, name, index);                                                     return ret }
+	IsRenderbuffer                      :: proc "c" (renderbuffer: u32, loc := #caller_location) -> bool                                                                                              { ret := impl_IsRenderbuffer(renderbuffer);                                                          debug_helper(loc, 1, ret, renderbuffer);                                                    return ret }
+	BindRenderbuffer                    :: proc "c" (target: u32, renderbuffer: u32, loc := #caller_location)                                                                                         {        impl_BindRenderbuffer(target, renderbuffer);                                                debug_helper(loc, 0, target, renderbuffer)                                                             }
+	DeleteRenderbuffers                 :: proc "c" (n: i32, renderbuffers: [^]u32, loc := #caller_location)                                                                                          {        impl_DeleteRenderbuffers(n, renderbuffers);                                                 debug_helper(loc, 0, n, renderbuffers)                                                                 }
+	GenRenderbuffers                    :: proc "c" (n: i32, renderbuffers: [^]u32, loc := #caller_location)                                                                                          {        impl_GenRenderbuffers(n, renderbuffers);                                                    debug_helper(loc, 0, n, renderbuffers)                                                                 }
+	RenderbufferStorage                 :: proc "c" (target: u32, internalformat: u32, width: i32, height: i32, loc := #caller_location)                                                              {        impl_RenderbufferStorage(target, internalformat, width, height);                            debug_helper(loc, 0, target, internalformat, width, height)                                            }
+	GetRenderbufferParameteriv          :: proc "c" (target: u32, pname: u32, params: [^]i32, loc := #caller_location)                                                                                {        impl_GetRenderbufferParameteriv(target, pname, params);                                     debug_helper(loc, 0, target, pname, params)                                                            }
+	IsFramebuffer                       :: proc "c" (framebuffer: u32, loc := #caller_location) -> bool                                                                                               { ret := impl_IsFramebuffer(framebuffer);                                                            debug_helper(loc, 1, ret, framebuffer);                                                     return ret }
+	BindFramebuffer                     :: proc "c" (target: u32, framebuffer: u32, loc := #caller_location)                                                                                          {        impl_BindFramebuffer(target, framebuffer);                                                  debug_helper(loc, 0, target, framebuffer)                                                              }
+	DeleteFramebuffers                  :: proc "c" (n: i32, framebuffers: [^]u32, loc := #caller_location)                                                                                           {        impl_DeleteFramebuffers(n, framebuffers);                                                   debug_helper(loc, 0, n, framebuffers)                                                                  }
+	GenFramebuffers                     :: proc "c" (n: i32, framebuffers: [^]u32, loc := #caller_location)                                                                                           {        impl_GenFramebuffers(n, framebuffers);                                                      debug_helper(loc, 0, n, framebuffers)                                                                  }
+	CheckFramebufferStatus              :: proc "c" (target: u32, loc := #caller_location) -> u32                                                                                                     { ret := impl_CheckFramebufferStatus(target);                                                        debug_helper(loc, 1, ret, target);                                                          return ret }
+	FramebufferTexture1D                :: proc "c" (target: u32, attachment: u32, textarget: u32, texture: u32, level: i32, loc := #caller_location)                                                 {        impl_FramebufferTexture1D(target, attachment, textarget, texture, level);                   debug_helper(loc, 0, target, attachment, textarget, texture, level)                                    }
+	FramebufferTexture2D                :: proc "c" (target: u32, attachment: u32, textarget: u32, texture: u32, level: i32, loc := #caller_location)                                                 {        impl_FramebufferTexture2D(target, attachment, textarget, texture, level);                   debug_helper(loc, 0, target, attachment, textarget, texture, level)                                    }
+	FramebufferTexture3D                :: proc "c" (target: u32, attachment: u32, textarget: u32, texture: u32, level: i32, zoffset: i32, loc := #caller_location)                                   {        impl_FramebufferTexture3D(target, attachment, textarget, texture, level, zoffset);          debug_helper(loc, 0, target, attachment, textarget, texture, level, zoffset)                           }
+	FramebufferRenderbuffer             :: proc "c" (target: u32, attachment: u32, renderbuffertarget: u32, renderbuffer: u32, loc := #caller_location)                                               {        impl_FramebufferRenderbuffer(target, attachment, renderbuffertarget, renderbuffer);         debug_helper(loc, 0, target, attachment, renderbuffertarget, renderbuffer)                             }
+	GetFramebufferAttachmentParameteriv :: proc "c" (target: u32, attachment: u32, pname: u32, params: [^]i32, loc := #caller_location)                                                               {        impl_GetFramebufferAttachmentParameteriv(target, attachment, pname, params);                debug_helper(loc, 0, target, attachment, pname, params)                                                }
+	GenerateMipmap                      :: proc "c" (target: u32, loc := #caller_location)                                                                                                            {        impl_GenerateMipmap(target);                                                                debug_helper(loc, 0, target)                                                                           }
+	BlitFramebuffer                     :: proc "c" (srcX0: i32, srcY0: i32, srcX1: i32, srcY1: i32, dstX0: i32, dstY0: i32, dstX1: i32, dstY1: i32, mask: u32, filter: u32, loc := #caller_location) {        impl_BlitFramebuffer(srcX0, srcY0, srcX1, srcY1, dstX0, dstY0, dstX1, dstY1, mask, filter); debug_helper(loc, 0, srcX0, srcY0, srcX1, srcY1, dstX0, dstY0, dstX1, dstY1, mask, filter)             }
+	RenderbufferStorageMultisample      :: proc "c" (target: u32, samples: i32, internalformat: u32, width: i32, height: i32, loc := #caller_location)                                                {        impl_RenderbufferStorageMultisample(target, samples, internalformat, width, height);        debug_helper(loc, 0, target, samples, internalformat, width, height)                                   }
+	FramebufferTextureLayer             :: proc "c" (target: u32, attachment: u32, texture: u32, level: i32, layer: i32, loc := #caller_location)                                                     {        impl_FramebufferTextureLayer(target, attachment, texture, level, layer);                    debug_helper(loc, 0, target, attachment, texture, level, layer)                                        }
+	MapBufferRange                      :: proc "c" (target: u32, offset: int, length: int, access: u32, loc := #caller_location) -> rawptr                                                           { ret := impl_MapBufferRange(target, offset, length, access);                                        debug_helper(loc, 1, ret, target, offset, length, access);                                  return ret }
+	FlushMappedBufferRange              :: proc "c" (target: u32, offset: int, length: int, loc := #caller_location)                                                                                  {        impl_FlushMappedBufferRange(target, offset, length);                                        debug_helper(loc, 0, target, offset, length)                                                           }
+	BindVertexArray                     :: proc "c" (array: u32, loc := #caller_location)                                                                                                             {        impl_BindVertexArray(array);                                                                debug_helper(loc, 0, array)                                                                            }
+	DeleteVertexArrays                  :: proc "c" (n: i32, arrays: [^]u32, loc := #caller_location)                                                                                                 {        impl_DeleteVertexArrays(n, arrays);                                                         debug_helper(loc, 0, n, arrays)                                                                        }
+	GenVertexArrays                     :: proc "c" (n: i32, arrays: [^]u32, loc := #caller_location)                                                                                                 {        impl_GenVertexArrays(n, arrays);                                                            debug_helper(loc, 0, n, arrays)                                                                        }
+	IsVertexArray                       :: proc "c" (array: u32, loc := #caller_location) -> bool                                                                                                     { ret := impl_IsVertexArray(array);                                                                  debug_helper(loc, 1, ret, array);                                                           return ret }
 
 	// VERSION_3_1
-	DrawArraysInstanced       :: #force_inline proc "c" (mode: u32, first: i32, count: i32, instancecount: i32, loc := #caller_location)                                     {        impl_DrawArraysInstanced(mode, first, count, instancecount);                                   debug_helper(loc, 0, mode, first, count, instancecount)            }
-	DrawElementsInstanced     :: #force_inline proc "c" (mode: u32, count: i32, type: u32, indices: rawptr, instancecount: i32, loc := #caller_location)                     {        impl_DrawElementsInstanced(mode, count, type, indices, instancecount);                        debug_helper(loc, 0, mode, count, type, indices, instancecount)            }
-	TexBuffer                 :: #force_inline proc "c" (target: u32, internalformat: u32, buffer: u32, loc := #caller_location)                                             {        impl_TexBuffer(target, internalformat, buffer);                                                debug_helper(loc, 0, target, internalformat, buffer)            }
-	PrimitiveRestartIndex     :: #force_inline proc "c" (index: u32, loc := #caller_location)                                                                                {        impl_PrimitiveRestartIndex(index);                                                             debug_helper(loc, 0, index)            }
-	CopyBufferSubData         :: #force_inline proc "c" (readTarget: u32, writeTarget: u32, readOffset: int, writeOffset: int, size: int, loc := #caller_location)           {        impl_CopyBufferSubData(readTarget, writeTarget, readOffset, writeOffset, size);                debug_helper(loc, 0, readTarget, writeTarget, readOffset, writeOffset, size)            }
-	GetUniformIndices         :: #force_inline proc "c" (program: u32, uniformCount: i32, uniformNames: [^]cstring, uniformIndices: [^]u32, loc := #caller_location)         {        impl_GetUniformIndices(program, uniformCount, uniformNames, uniformIndices);                   debug_helper(loc, 0, program, uniformCount, uniformNames, uniformIndices)            }
-	GetActiveUniformsiv       :: #force_inline proc "c" (program: u32, uniformCount: i32, uniformIndices: [^]u32, pname: u32, params: [^]i32, loc := #caller_location)       {        impl_GetActiveUniformsiv(program, uniformCount, uniformIndices, pname, params);                debug_helper(loc, 0, program, uniformCount, uniformIndices, pname, params)            }
-	GetActiveUniformName      :: #force_inline proc "c" (program: u32, uniformIndex: u32, bufSize: i32, length: ^i32, uniformName: [^]u8, loc := #caller_location)           {        impl_GetActiveUniformName(program, uniformIndex, bufSize, length, uniformName);                debug_helper(loc, 0, program, uniformIndex, bufSize, length, uniformName)            }
-	GetUniformBlockIndex      :: #force_inline proc "c" (program: u32, uniformBlockName: cstring, loc := #caller_location) -> u32                                            { ret := impl_GetUniformBlockIndex(program, uniformBlockName);                                          debug_helper(loc, 1, ret, program, uniformBlockName); return ret }
-	GetActiveUniformBlockiv   :: #force_inline proc "c" (program: u32, uniformBlockIndex: u32, pname: u32, params: [^]i32, loc := #caller_location)                          {        impl_GetActiveUniformBlockiv(program, uniformBlockIndex, pname, params);                       debug_helper(loc, 0, program, uniformBlockIndex, pname, params)            }
-	GetActiveUniformBlockName :: #force_inline proc "c" (program: u32, uniformBlockIndex: u32, bufSize: i32, length: ^i32, uniformBlockName: [^]u8, loc := #caller_location) {        impl_GetActiveUniformBlockName(program, uniformBlockIndex, bufSize, length, uniformBlockName); debug_helper(loc, 0, program, uniformBlockIndex, bufSize, length, uniformBlockName)            }
-	UniformBlockBinding       :: #force_inline proc "c" (program: u32, uniformBlockIndex: u32, uniformBlockBinding: u32, loc := #caller_location)                            {        impl_UniformBlockBinding(program, uniformBlockIndex, uniformBlockBinding);                     debug_helper(loc, 0, program, uniformBlockIndex, uniformBlockBinding)            }
+	DrawArraysInstanced       :: proc "c" (mode: u32, first: i32, count: i32, instancecount: i32, loc := #caller_location)                                     {        impl_DrawArraysInstanced(mode, first, count, instancecount);                                   debug_helper(loc, 0, mode, first, count, instancecount)            }
+	DrawElementsInstanced     :: proc "c" (mode: u32, count: i32, type: u32, indices: rawptr, instancecount: i32, loc := #caller_location)                     {        impl_DrawElementsInstanced(mode, count, type, indices, instancecount);                        debug_helper(loc, 0, mode, count, type, indices, instancecount)            }
+	TexBuffer                 :: proc "c" (target: u32, internalformat: u32, buffer: u32, loc := #caller_location)                                             {        impl_TexBuffer(target, internalformat, buffer);                                                debug_helper(loc, 0, target, internalformat, buffer)            }
+	PrimitiveRestartIndex     :: proc "c" (index: u32, loc := #caller_location)                                                                                {        impl_PrimitiveRestartIndex(index);                                                             debug_helper(loc, 0, index)            }
+	CopyBufferSubData         :: proc "c" (readTarget: u32, writeTarget: u32, readOffset: int, writeOffset: int, size: int, loc := #caller_location)           {        impl_CopyBufferSubData(readTarget, writeTarget, readOffset, writeOffset, size);                debug_helper(loc, 0, readTarget, writeTarget, readOffset, writeOffset, size)            }
+	GetUniformIndices         :: proc "c" (program: u32, uniformCount: i32, uniformNames: [^]cstring, uniformIndices: [^]u32, loc := #caller_location)         {        impl_GetUniformIndices(program, uniformCount, uniformNames, uniformIndices);                   debug_helper(loc, 0, program, uniformCount, uniformNames, uniformIndices)            }
+	GetActiveUniformsiv       :: proc "c" (program: u32, uniformCount: i32, uniformIndices: [^]u32, pname: u32, params: [^]i32, loc := #caller_location)       {        impl_GetActiveUniformsiv(program, uniformCount, uniformIndices, pname, params);                debug_helper(loc, 0, program, uniformCount, uniformIndices, pname, params)            }
+	GetActiveUniformName      :: proc "c" (program: u32, uniformIndex: u32, bufSize: i32, length: ^i32, uniformName: [^]u8, loc := #caller_location)           {        impl_GetActiveUniformName(program, uniformIndex, bufSize, length, uniformName);                debug_helper(loc, 0, program, uniformIndex, bufSize, length, uniformName)            }
+	GetUniformBlockIndex      :: proc "c" (program: u32, uniformBlockName: cstring, loc := #caller_location) -> u32                                            { ret := impl_GetUniformBlockIndex(program, uniformBlockName);                                          debug_helper(loc, 1, ret, program, uniformBlockName); return ret }
+	GetActiveUniformBlockiv   :: proc "c" (program: u32, uniformBlockIndex: u32, pname: u32, params: [^]i32, loc := #caller_location)                          {        impl_GetActiveUniformBlockiv(program, uniformBlockIndex, pname, params);                       debug_helper(loc, 0, program, uniformBlockIndex, pname, params)            }
+	GetActiveUniformBlockName :: proc "c" (program: u32, uniformBlockIndex: u32, bufSize: i32, length: ^i32, uniformBlockName: [^]u8, loc := #caller_location) {        impl_GetActiveUniformBlockName(program, uniformBlockIndex, bufSize, length, uniformBlockName); debug_helper(loc, 0, program, uniformBlockIndex, bufSize, length, uniformBlockName)            }
+	UniformBlockBinding       :: proc "c" (program: u32, uniformBlockIndex: u32, uniformBlockBinding: u32, loc := #caller_location)                            {        impl_UniformBlockBinding(program, uniformBlockIndex, uniformBlockBinding);                     debug_helper(loc, 0, program, uniformBlockIndex, uniformBlockBinding)            }
 
 	// VERSION_3_2
-	DrawElementsBaseVertex          :: #force_inline proc "c" (mode: u32, count: i32, type: u32, indices: rawptr, basevertex: i32, loc := #caller_location)                                            {        impl_DrawElementsBaseVertex(mode, count, type, indices, basevertex);                                    debug_helper(loc, 0, mode, count, type, indices, basevertex)                                                 }
-	DrawRangeElementsBaseVertex     :: #force_inline proc "c" (mode: u32, start: u32, end: u32, count: i32, type: u32, indices: rawptr, basevertex: i32, loc := #caller_location)                      {        impl_DrawRangeElementsBaseVertex(mode, start, end, count, type, indices, basevertex);                   debug_helper(loc, 0, mode, start, end, count, type, indices, basevertex)                                     }
-	DrawElementsInstancedBaseVertex :: #force_inline proc "c" (mode: u32, count: i32, type: u32, indices: rawptr, instancecount: i32, basevertex: i32, loc := #caller_location)                        {        impl_DrawElementsInstancedBaseVertex(mode, count, type, indices, instancecount, basevertex);            debug_helper(loc, 0, mode, count, type, indices, instancecount, basevertex)                                  }
-	MultiDrawElementsBaseVertex     :: #force_inline proc "c" (mode: u32, count: [^]i32, type: u32, indices: [^]rawptr, drawcount: i32, basevertex: [^]i32, loc := #caller_location)                   {        impl_MultiDrawElementsBaseVertex(mode, count, type, indices, drawcount, basevertex);                    debug_helper(loc, 0, mode, count, type, indices, drawcount, basevertex)                                      }
-	ProvokingVertex                 :: #force_inline proc "c" (mode: u32, loc := #caller_location)                                                                                                     {        impl_ProvokingVertex(mode);                                                                              debug_helper(loc, 0, mode)                                                                                    }
-	FenceSync                       :: #force_inline proc "c" (condition: u32, flags: u32, loc := #caller_location) -> sync_t                                                                          { ret := impl_FenceSync(condition, flags);                                                                        debug_helper(loc, 1, ret, condition, flags);                                                       return ret }
-	IsSync                          :: #force_inline proc "c" (sync: sync_t, loc := #caller_location) -> bool                                                                                          { ret := impl_IsSync(sync);                                                                                       debug_helper(loc, 1, ret, sync);                                                                   return ret }
-	DeleteSync                      :: #force_inline proc "c" (sync: sync_t, loc := #caller_location)                                                                                                  {        impl_DeleteSync(sync);                                                                                   debug_helper(loc, 0, sync)                                                                                    }
-	ClientWaitSync                  :: #force_inline proc "c" (sync: sync_t, flags: u32, timeout: u64, loc := #caller_location) -> u32                                                                 { ret := impl_ClientWaitSync(sync, flags, timeout);                                                               debug_helper(loc, 1, ret, sync, flags, timeout);                                                   return ret }
-	WaitSync                        :: #force_inline proc "c" (sync: sync_t, flags: u32, timeout: u64, loc := #caller_location)                                                                        {        impl_WaitSync(sync, flags, timeout);                                                                     debug_helper(loc, 0, sync, flags, timeout)                                                                    }
-	GetInteger64v                   :: #force_inline proc "c" (pname: u32, data: ^i64, loc := #caller_location)                                                                                        {        impl_GetInteger64v(pname, data);                                                                         debug_helper(loc, 0, pname, data)                                                                             }
-	GetSynciv                       :: #force_inline proc "c" (sync: sync_t, pname: u32, bufSize: i32, length: ^i32, values: [^]i32, loc := #caller_location)                                          {        impl_GetSynciv(sync, pname, bufSize, length, values);                                                    debug_helper(loc, 0, sync, pname, bufSize, length, values)                                                    }
-	GetInteger64i_v                 :: #force_inline proc "c" (target: u32, index: u32, data: ^i64, loc := #caller_location)                                                                           {        impl_GetInteger64i_v(target, index, data);                                                               debug_helper(loc, 0, target, index, data)                                                                     }
-	GetBufferParameteri64v          :: #force_inline proc "c" (target: u32, pname: u32, params: [^]i64, loc := #caller_location)                                                                       {        impl_GetBufferParameteri64v(target, pname, params);                                                      debug_helper(loc, 0, target, pname, params)                                                                   }
-	FramebufferTexture              :: #force_inline proc "c" (target: u32, attachment: u32, texture: u32, level: i32, loc := #caller_location)                                                        {        impl_FramebufferTexture(target, attachment, texture, level);                                             debug_helper(loc, 0, target, attachment, texture, level)                                                      }
-	TexImage2DMultisample           :: #force_inline proc "c" (target: u32, samples: i32, internalformat: u32, width: i32, height: i32, fixedsamplelocations: bool, loc := #caller_location)             {        impl_TexImage2DMultisample(target, samples, internalformat, width, height, fixedsamplelocations);        debug_helper(loc, 0, target, samples, internalformat, width, height, fixedsamplelocations)                    }
-	TexImage3DMultisample           :: #force_inline proc "c" (target: u32, samples: i32, internalformat: u32, width: i32, height: i32, depth: i32, fixedsamplelocations: bool, loc := #caller_location) {        impl_TexImage3DMultisample(target, samples, internalformat, width, height, depth, fixedsamplelocations); debug_helper(loc, 0, target, samples, internalformat, width, height, depth, fixedsamplelocations)             }
-	GetMultisamplefv                :: #force_inline proc "c" (pname: u32, index: u32, val: ^f32, loc := #caller_location)                                                                             {        impl_GetMultisamplefv(pname, index, val);                                                                debug_helper(loc, 0, pname, index, val)                                                                       }
-	SampleMaski                     :: #force_inline proc "c" (maskNumber: u32, mask: u32, loc := #caller_location)                                                                                    {        impl_SampleMaski(maskNumber, mask);                                                                      debug_helper(loc, 0, maskNumber, mask)                                                                        }
+	DrawElementsBaseVertex          :: proc "c" (mode: u32, count: i32, type: u32, indices: rawptr, basevertex: i32, loc := #caller_location)                                            {        impl_DrawElementsBaseVertex(mode, count, type, indices, basevertex);                                    debug_helper(loc, 0, mode, count, type, indices, basevertex)                                                 }
+	DrawRangeElementsBaseVertex     :: proc "c" (mode: u32, start: u32, end: u32, count: i32, type: u32, indices: rawptr, basevertex: i32, loc := #caller_location)                      {        impl_DrawRangeElementsBaseVertex(mode, start, end, count, type, indices, basevertex);                   debug_helper(loc, 0, mode, start, end, count, type, indices, basevertex)                                     }
+	DrawElementsInstancedBaseVertex :: proc "c" (mode: u32, count: i32, type: u32, indices: rawptr, instancecount: i32, basevertex: i32, loc := #caller_location)                        {        impl_DrawElementsInstancedBaseVertex(mode, count, type, indices, instancecount, basevertex);            debug_helper(loc, 0, mode, count, type, indices, instancecount, basevertex)                                  }
+	MultiDrawElementsBaseVertex     :: proc "c" (mode: u32, count: [^]i32, type: u32, indices: [^]rawptr, drawcount: i32, basevertex: [^]i32, loc := #caller_location)                   {        impl_MultiDrawElementsBaseVertex(mode, count, type, indices, drawcount, basevertex);                    debug_helper(loc, 0, mode, count, type, indices, drawcount, basevertex)                                      }
+	ProvokingVertex                 :: proc "c" (mode: u32, loc := #caller_location)                                                                                                     {        impl_ProvokingVertex(mode);                                                                              debug_helper(loc, 0, mode)                                                                                    }
+	FenceSync                       :: proc "c" (condition: u32, flags: u32, loc := #caller_location) -> sync_t                                                                          { ret := impl_FenceSync(condition, flags);                                                                        debug_helper(loc, 1, ret, condition, flags);                                                       return ret }
+	IsSync                          :: proc "c" (sync: sync_t, loc := #caller_location) -> bool                                                                                          { ret := impl_IsSync(sync);                                                                                       debug_helper(loc, 1, ret, sync);                                                                   return ret }
+	DeleteSync                      :: proc "c" (sync: sync_t, loc := #caller_location)                                                                                                  {        impl_DeleteSync(sync);                                                                                   debug_helper(loc, 0, sync)                                                                                    }
+	ClientWaitSync                  :: proc "c" (sync: sync_t, flags: u32, timeout: u64, loc := #caller_location) -> u32                                                                 { ret := impl_ClientWaitSync(sync, flags, timeout);                                                               debug_helper(loc, 1, ret, sync, flags, timeout);                                                   return ret }
+	WaitSync                        :: proc "c" (sync: sync_t, flags: u32, timeout: u64, loc := #caller_location)                                                                        {        impl_WaitSync(sync, flags, timeout);                                                                     debug_helper(loc, 0, sync, flags, timeout)                                                                    }
+	GetInteger64v                   :: proc "c" (pname: u32, data: ^i64, loc := #caller_location)                                                                                        {        impl_GetInteger64v(pname, data);                                                                         debug_helper(loc, 0, pname, data)                                                                             }
+	GetSynciv                       :: proc "c" (sync: sync_t, pname: u32, bufSize: i32, length: ^i32, values: [^]i32, loc := #caller_location)                                          {        impl_GetSynciv(sync, pname, bufSize, length, values);                                                    debug_helper(loc, 0, sync, pname, bufSize, length, values)                                                    }
+	GetInteger64i_v                 :: proc "c" (target: u32, index: u32, data: ^i64, loc := #caller_location)                                                                           {        impl_GetInteger64i_v(target, index, data);                                                               debug_helper(loc, 0, target, index, data)                                                                     }
+	GetBufferParameteri64v          :: proc "c" (target: u32, pname: u32, params: [^]i64, loc := #caller_location)                                                                       {        impl_GetBufferParameteri64v(target, pname, params);                                                      debug_helper(loc, 0, target, pname, params)                                                                   }
+	FramebufferTexture              :: proc "c" (target: u32, attachment: u32, texture: u32, level: i32, loc := #caller_location)                                                        {        impl_FramebufferTexture(target, attachment, texture, level);                                             debug_helper(loc, 0, target, attachment, texture, level)                                                      }
+	TexImage2DMultisample           :: proc "c" (target: u32, samples: i32, internalformat: u32, width: i32, height: i32, fixedsamplelocations: bool, loc := #caller_location)             {        impl_TexImage2DMultisample(target, samples, internalformat, width, height, fixedsamplelocations);        debug_helper(loc, 0, target, samples, internalformat, width, height, fixedsamplelocations)                    }
+	TexImage3DMultisample           :: proc "c" (target: u32, samples: i32, internalformat: u32, width: i32, height: i32, depth: i32, fixedsamplelocations: bool, loc := #caller_location) {        impl_TexImage3DMultisample(target, samples, internalformat, width, height, depth, fixedsamplelocations); debug_helper(loc, 0, target, samples, internalformat, width, height, depth, fixedsamplelocations)             }
+	GetMultisamplefv                :: proc "c" (pname: u32, index: u32, val: ^f32, loc := #caller_location)                                                                             {        impl_GetMultisamplefv(pname, index, val);                                                                debug_helper(loc, 0, pname, index, val)                                                                       }
+	SampleMaski                     :: proc "c" (maskNumber: u32, mask: u32, loc := #caller_location)                                                                                    {        impl_SampleMaski(maskNumber, mask);                                                                      debug_helper(loc, 0, maskNumber, mask)                                                                        }
 
 	// VERSION_3_3
-	BindFragDataLocationIndexed :: #force_inline proc "c" (program: u32, colorNumber: u32, index: u32, name: cstring, loc := #caller_location) {        impl_BindFragDataLocationIndexed(program, colorNumber, index, name); debug_helper(loc, 0, program, colorNumber, index, name)             }
-	GetFragDataIndex            :: #force_inline proc "c" (program: u32, name: cstring, loc := #caller_location) -> i32                        { ret := impl_GetFragDataIndex(program, name);                                debug_helper(loc, 1, ret, program, name);                return ret }
-	GenSamplers                 :: #force_inline proc "c" (count: i32, samplers: [^]u32, loc := #caller_location)                              {        impl_GenSamplers(count, samplers);                                   debug_helper(loc, 0, count, samplers)                               }
-	DeleteSamplers              :: #force_inline proc "c" (count: i32, samplers: [^]u32, loc := #caller_location)                              {        impl_DeleteSamplers(count, samplers);                                debug_helper(loc, 0, count, samplers)                               }
-	IsSampler                   :: #force_inline proc "c" (sampler: u32, loc := #caller_location) -> bool                                      { ret := impl_IsSampler(sampler);                                             debug_helper(loc, 1, ret, sampler);                      return ret }
-	BindSampler                 :: #force_inline proc "c" (unit: u32, sampler: u32, loc := #caller_location)                                   {        impl_BindSampler(unit, sampler);                                     debug_helper(loc, 0, unit, sampler)                                 }
-	SamplerParameteri           :: #force_inline proc "c" (sampler: u32, pname: u32, param: i32, loc := #caller_location)                      {        impl_SamplerParameteri(sampler, pname, param);                       debug_helper(loc, 0, sampler, pname, param)                         }
-	SamplerParameteriv          :: #force_inline proc "c" (sampler: u32, pname: u32, param: ^i32, loc := #caller_location)                     {        impl_SamplerParameteriv(sampler, pname, param);                      debug_helper(loc, 0, sampler, pname, param)                         }
-	SamplerParameterf           :: #force_inline proc "c" (sampler: u32, pname: u32, param: f32, loc := #caller_location)                      {        impl_SamplerParameterf(sampler, pname, param);                       debug_helper(loc, 0, sampler, pname, param)                         }
-	SamplerParameterfv          :: #force_inline proc "c" (sampler: u32, pname: u32, param: ^f32, loc := #caller_location)                     {        impl_SamplerParameterfv(sampler, pname, param);                      debug_helper(loc, 0, sampler, pname, param)                         }
-	SamplerParameterIiv         :: #force_inline proc "c" (sampler: u32, pname: u32, param: ^i32, loc := #caller_location)                     {        impl_SamplerParameterIiv(sampler, pname, param);                     debug_helper(loc, 0, sampler, pname, param)                         }
-	SamplerParameterIuiv        :: #force_inline proc "c" (sampler: u32, pname: u32, param: ^u32, loc := #caller_location)                     {        impl_SamplerParameterIuiv(sampler, pname, param);                    debug_helper(loc, 0, sampler, pname, param)                         }
-	GetSamplerParameteriv       :: #force_inline proc "c" (sampler: u32, pname: u32, params: [^]i32, loc := #caller_location)                  {        impl_GetSamplerParameteriv(sampler, pname, params);                  debug_helper(loc, 0, sampler, pname, params)                        }
-	GetSamplerParameterIiv      :: #force_inline proc "c" (sampler: u32, pname: u32, params: [^]i32, loc := #caller_location)                  {        impl_GetSamplerParameterIiv(sampler, pname, params);                 debug_helper(loc, 0, sampler, pname, params)                        }
-	GetSamplerParameterfv       :: #force_inline proc "c" (sampler: u32, pname: u32, params: [^]f32, loc := #caller_location)                  {        impl_GetSamplerParameterfv(sampler, pname, params);                  debug_helper(loc, 0, sampler, pname, params)                        }
-	GetSamplerParameterIuiv     :: #force_inline proc "c" (sampler: u32, pname: u32, params: [^]u32, loc := #caller_location)                  {        impl_GetSamplerParameterIuiv(sampler, pname, params);                debug_helper(loc, 0, sampler, pname, params)                        }
-	QueryCounter                :: #force_inline proc "c" (id: u32, target: u32, loc := #caller_location)                                      {        impl_QueryCounter(id, target);                                       debug_helper(loc, 0, id, target)                                    }
-	GetQueryObjecti64v          :: #force_inline proc "c" (id: u32, pname: u32, params: [^]i64, loc := #caller_location)                       {        impl_GetQueryObjecti64v(id, pname, params);                          debug_helper(loc, 0, id, pname, params)                             }
-	GetQueryObjectui64v         :: #force_inline proc "c" (id: u32, pname: u32, params: [^]u64, loc := #caller_location)                       {        impl_GetQueryObjectui64v(id, pname, params);                         debug_helper(loc, 0, id, pname, params)                             }
-	VertexAttribDivisor         :: #force_inline proc "c" (index: u32, divisor: u32, loc := #caller_location)                                  {        impl_VertexAttribDivisor(index, divisor);                            debug_helper(loc, 0, index, divisor)                                }
-	VertexAttribP1ui            :: #force_inline proc "c" (index: u32, type: u32, normalized: bool, value: u32, loc := #caller_location)       {        impl_VertexAttribP1ui(index, type, normalized, value);              debug_helper(loc, 0, index, type, normalized, value)               }
-	VertexAttribP1uiv           :: #force_inline proc "c" (index: u32, type: u32, normalized: bool, value: ^u32, loc := #caller_location)      {        impl_VertexAttribP1uiv(index, type, normalized, value);             debug_helper(loc, 0, index, type, normalized, value)               }
-	VertexAttribP2ui            :: #force_inline proc "c" (index: u32, type: u32, normalized: bool, value: u32, loc := #caller_location)       {        impl_VertexAttribP2ui(index, type, normalized, value);              debug_helper(loc, 0, index, type, normalized, value)               }
-	VertexAttribP2uiv           :: #force_inline proc "c" (index: u32, type: u32, normalized: bool, value: ^u32, loc := #caller_location)      {        impl_VertexAttribP2uiv(index, type, normalized, value);             debug_helper(loc, 0, index, type, normalized, value)               }
-	VertexAttribP3ui            :: #force_inline proc "c" (index: u32, type: u32, normalized: bool, value: u32, loc := #caller_location)       {        impl_VertexAttribP3ui(index, type, normalized, value);              debug_helper(loc, 0, index, type, normalized, value)               }
-	VertexAttribP3uiv           :: #force_inline proc "c" (index: u32, type: u32, normalized: bool, value: ^u32, loc := #caller_location)      {        impl_VertexAttribP3uiv(index, type, normalized, value);             debug_helper(loc, 0, index, type, normalized, value)               }
-	VertexAttribP4ui            :: #force_inline proc "c" (index: u32, type: u32, normalized: bool, value: u32, loc := #caller_location)       {        impl_VertexAttribP4ui(index, type, normalized, value);              debug_helper(loc, 0, index, type, normalized, value)               }
-	VertexAttribP4uiv           :: #force_inline proc "c" (index: u32, type: u32, normalized: bool, value: ^u32, loc := #caller_location)      {        impl_VertexAttribP4uiv(index, type, normalized, value);             debug_helper(loc, 0, index, type, normalized, value)               }
-	VertexP2ui                  :: #force_inline proc "c" (type: u32, value: u32, loc := #caller_location)                                     {        impl_VertexP2ui(type, value);                                       debug_helper(loc, 0, type, value)                                  }
-	VertexP2uiv                 :: #force_inline proc "c" (type: u32, value: ^u32, loc := #caller_location)                                    {        impl_VertexP2uiv(type, value);                                      debug_helper(loc, 0, type, value)                                  }
-	VertexP3ui                  :: #force_inline proc "c" (type: u32, value: u32, loc := #caller_location)                                     {        impl_VertexP3ui(type, value);                                       debug_helper(loc, 0, type, value)                                  }
-	VertexP3uiv                 :: #force_inline proc "c" (type: u32, value: ^u32, loc := #caller_location)                                    {        impl_VertexP3uiv(type, value);                                      debug_helper(loc, 0, type, value)                                  }
-	VertexP4ui                  :: #force_inline proc "c" (type: u32, value: u32, loc := #caller_location)                                     {        impl_VertexP4ui(type, value);                                       debug_helper(loc, 0, type, value)                                  }
-	VertexP4uiv                 :: #force_inline proc "c" (type: u32, value: ^u32, loc := #caller_location)                                    {        impl_VertexP4uiv(type, value);                                      debug_helper(loc, 0, type, value)                                  }
-	TexCoordP1ui                :: #force_inline proc "c" (type: u32, coords: u32, loc := #caller_location)                                    {        impl_TexCoordP1ui(type, coords);                                    debug_helper(loc, 0, type, coords)                                 }
-	TexCoordP1uiv               :: #force_inline proc "c" (type: u32, coords: [^]u32, loc := #caller_location)                                 {        impl_TexCoordP1uiv(type, coords);                                   debug_helper(loc, 0, type, coords)                                 }
-	TexCoordP2ui                :: #force_inline proc "c" (type: u32, coords: u32, loc := #caller_location)                                    {        impl_TexCoordP2ui(type, coords);                                    debug_helper(loc, 0, type, coords)                                 }
-	TexCoordP2uiv               :: #force_inline proc "c" (type: u32, coords: [^]u32, loc := #caller_location)                                 {        impl_TexCoordP2uiv(type, coords);                                   debug_helper(loc, 0, type, coords)                                 }
-	TexCoordP3ui                :: #force_inline proc "c" (type: u32, coords: u32, loc := #caller_location)                                    {        impl_TexCoordP3ui(type, coords);                                    debug_helper(loc, 0, type, coords)                                 }
-	TexCoordP3uiv               :: #force_inline proc "c" (type: u32, coords: [^]u32, loc := #caller_location)                                 {        impl_TexCoordP3uiv(type, coords);                                   debug_helper(loc, 0, type, coords)                                 }
-	TexCoordP4ui                :: #force_inline proc "c" (type: u32, coords: u32, loc := #caller_location)                                    {        impl_TexCoordP4ui(type, coords);                                    debug_helper(loc, 0, type, coords)                                 }
-	TexCoordP4uiv               :: #force_inline proc "c" (type: u32, coords: [^]u32, loc := #caller_location)                                 {        impl_TexCoordP4uiv(type, coords);                                   debug_helper(loc, 0, type, coords)                                 }
-	MultiTexCoordP1ui           :: #force_inline proc "c" (texture: u32, type: u32, coords: u32, loc := #caller_location)                      {        impl_MultiTexCoordP1ui(texture, type, coords);                      debug_helper(loc, 0, texture, type, coords)                        }
-	MultiTexCoordP1uiv          :: #force_inline proc "c" (texture: u32, type: u32, coords: [^]u32, loc := #caller_location)                   {        impl_MultiTexCoordP1uiv(texture, type, coords);                     debug_helper(loc, 0, texture, type, coords)                        }
-	MultiTexCoordP2ui           :: #force_inline proc "c" (texture: u32, type: u32, coords: u32, loc := #caller_location)                      {        impl_MultiTexCoordP2ui(texture, type, coords);                      debug_helper(loc, 0, texture, type, coords)                        }
-	MultiTexCoordP2uiv          :: #force_inline proc "c" (texture: u32, type: u32, coords: [^]u32, loc := #caller_location)                   {        impl_MultiTexCoordP2uiv(texture, type, coords);                     debug_helper(loc, 0, texture, type, coords)                        }
-	MultiTexCoordP3ui           :: #force_inline proc "c" (texture: u32, type: u32, coords: u32, loc := #caller_location)                      {        impl_MultiTexCoordP3ui(texture, type, coords);                      debug_helper(loc, 0, texture, type, coords)                        }
-	MultiTexCoordP3uiv          :: #force_inline proc "c" (texture: u32, type: u32, coords: [^]u32, loc := #caller_location)                   {        impl_MultiTexCoordP3uiv(texture, type, coords);                     debug_helper(loc, 0, texture, type, coords)                        }
-	MultiTexCoordP4ui           :: #force_inline proc "c" (texture: u32, type: u32, coords: u32, loc := #caller_location)                      {        impl_MultiTexCoordP4ui(texture, type, coords);                      debug_helper(loc, 0, texture, type, coords)                        }
-	MultiTexCoordP4uiv          :: #force_inline proc "c" (texture: u32, type: u32, coords: [^]u32, loc := #caller_location)                   {        impl_MultiTexCoordP4uiv(texture, type, coords);                     debug_helper(loc, 0, texture, type, coords)                        }
-	NormalP3ui                  :: #force_inline proc "c" (type: u32, coords: u32, loc := #caller_location)                                    {        impl_NormalP3ui(type, coords);                                      debug_helper(loc, 0, type, coords)                                 }
-	NormalP3uiv                 :: #force_inline proc "c" (type: u32, coords: [^]u32, loc := #caller_location)                                 {        impl_NormalP3uiv(type, coords);                                     debug_helper(loc, 0, type, coords)                                 }
-	ColorP3ui                   :: #force_inline proc "c" (type: u32, color: u32, loc := #caller_location)                                     {        impl_ColorP3ui(type, color);                                        debug_helper(loc, 0, type, color)                                  }
-	ColorP3uiv                  :: #force_inline proc "c" (type: u32, color: ^u32, loc := #caller_location)                                    {        impl_ColorP3uiv(type, color);                                       debug_helper(loc, 0, type, color)                                  }
-	ColorP4ui                   :: #force_inline proc "c" (type: u32, color: u32, loc := #caller_location)                                     {        impl_ColorP4ui(type, color);                                        debug_helper(loc, 0, type, color)                                  }
-	ColorP4uiv                  :: #force_inline proc "c" (type: u32, color: ^u32, loc := #caller_location)                                    {        impl_ColorP4uiv(type, color);                                       debug_helper(loc, 0, type, color)                                  }
-	SecondaryColorP3ui          :: #force_inline proc "c" (type: u32, color: u32, loc := #caller_location)                                     {        impl_SecondaryColorP3ui(type, color);                               debug_helper(loc, 0, type, color)                                  }
-	SecondaryColorP3uiv         :: #force_inline proc "c" (type: u32, color: ^u32, loc := #caller_location)                                    {        impl_SecondaryColorP3uiv(type, color);                              debug_helper(loc, 0, type, color)                                  }
+	BindFragDataLocationIndexed :: proc "c" (program: u32, colorNumber: u32, index: u32, name: cstring, loc := #caller_location) {        impl_BindFragDataLocationIndexed(program, colorNumber, index, name); debug_helper(loc, 0, program, colorNumber, index, name)             }
+	GetFragDataIndex            :: proc "c" (program: u32, name: cstring, loc := #caller_location) -> i32                        { ret := impl_GetFragDataIndex(program, name);                                debug_helper(loc, 1, ret, program, name);                return ret }
+	GenSamplers                 :: proc "c" (count: i32, samplers: [^]u32, loc := #caller_location)                              {        impl_GenSamplers(count, samplers);                                   debug_helper(loc, 0, count, samplers)                               }
+	DeleteSamplers              :: proc "c" (count: i32, samplers: [^]u32, loc := #caller_location)                              {        impl_DeleteSamplers(count, samplers);                                debug_helper(loc, 0, count, samplers)                               }
+	IsSampler                   :: proc "c" (sampler: u32, loc := #caller_location) -> bool                                      { ret := impl_IsSampler(sampler);                                             debug_helper(loc, 1, ret, sampler);                      return ret }
+	BindSampler                 :: proc "c" (unit: u32, sampler: u32, loc := #caller_location)                                   {        impl_BindSampler(unit, sampler);                                     debug_helper(loc, 0, unit, sampler)                                 }
+	SamplerParameteri           :: proc "c" (sampler: u32, pname: u32, param: i32, loc := #caller_location)                      {        impl_SamplerParameteri(sampler, pname, param);                       debug_helper(loc, 0, sampler, pname, param)                         }
+	SamplerParameteriv          :: proc "c" (sampler: u32, pname: u32, param: ^i32, loc := #caller_location)                     {        impl_SamplerParameteriv(sampler, pname, param);                      debug_helper(loc, 0, sampler, pname, param)                         }
+	SamplerParameterf           :: proc "c" (sampler: u32, pname: u32, param: f32, loc := #caller_location)                      {        impl_SamplerParameterf(sampler, pname, param);                       debug_helper(loc, 0, sampler, pname, param)                         }
+	SamplerParameterfv          :: proc "c" (sampler: u32, pname: u32, param: ^f32, loc := #caller_location)                     {        impl_SamplerParameterfv(sampler, pname, param);                      debug_helper(loc, 0, sampler, pname, param)                         }
+	SamplerParameterIiv         :: proc "c" (sampler: u32, pname: u32, param: ^i32, loc := #caller_location)                     {        impl_SamplerParameterIiv(sampler, pname, param);                     debug_helper(loc, 0, sampler, pname, param)                         }
+	SamplerParameterIuiv        :: proc "c" (sampler: u32, pname: u32, param: ^u32, loc := #caller_location)                     {        impl_SamplerParameterIuiv(sampler, pname, param);                    debug_helper(loc, 0, sampler, pname, param)                         }
+	GetSamplerParameteriv       :: proc "c" (sampler: u32, pname: u32, params: [^]i32, loc := #caller_location)                  {        impl_GetSamplerParameteriv(sampler, pname, params);                  debug_helper(loc, 0, sampler, pname, params)                        }
+	GetSamplerParameterIiv      :: proc "c" (sampler: u32, pname: u32, params: [^]i32, loc := #caller_location)                  {        impl_GetSamplerParameterIiv(sampler, pname, params);                 debug_helper(loc, 0, sampler, pname, params)                        }
+	GetSamplerParameterfv       :: proc "c" (sampler: u32, pname: u32, params: [^]f32, loc := #caller_location)                  {        impl_GetSamplerParameterfv(sampler, pname, params);                  debug_helper(loc, 0, sampler, pname, params)                        }
+	GetSamplerParameterIuiv     :: proc "c" (sampler: u32, pname: u32, params: [^]u32, loc := #caller_location)                  {        impl_GetSamplerParameterIuiv(sampler, pname, params);                debug_helper(loc, 0, sampler, pname, params)                        }
+	QueryCounter                :: proc "c" (id: u32, target: u32, loc := #caller_location)                                      {        impl_QueryCounter(id, target);                                       debug_helper(loc, 0, id, target)                                    }
+	GetQueryObjecti64v          :: proc "c" (id: u32, pname: u32, params: [^]i64, loc := #caller_location)                       {        impl_GetQueryObjecti64v(id, pname, params);                          debug_helper(loc, 0, id, pname, params)                             }
+	GetQueryObjectui64v         :: proc "c" (id: u32, pname: u32, params: [^]u64, loc := #caller_location)                       {        impl_GetQueryObjectui64v(id, pname, params);                         debug_helper(loc, 0, id, pname, params)                             }
+	VertexAttribDivisor         :: proc "c" (index: u32, divisor: u32, loc := #caller_location)                                  {        impl_VertexAttribDivisor(index, divisor);                            debug_helper(loc, 0, index, divisor)                                }
+	VertexAttribP1ui            :: proc "c" (index: u32, type: u32, normalized: bool, value: u32, loc := #caller_location)       {        impl_VertexAttribP1ui(index, type, normalized, value);              debug_helper(loc, 0, index, type, normalized, value)               }
+	VertexAttribP1uiv           :: proc "c" (index: u32, type: u32, normalized: bool, value: ^u32, loc := #caller_location)      {        impl_VertexAttribP1uiv(index, type, normalized, value);             debug_helper(loc, 0, index, type, normalized, value)               }
+	VertexAttribP2ui            :: proc "c" (index: u32, type: u32, normalized: bool, value: u32, loc := #caller_location)       {        impl_VertexAttribP2ui(index, type, normalized, value);              debug_helper(loc, 0, index, type, normalized, value)               }
+	VertexAttribP2uiv           :: proc "c" (index: u32, type: u32, normalized: bool, value: ^u32, loc := #caller_location)      {        impl_VertexAttribP2uiv(index, type, normalized, value);             debug_helper(loc, 0, index, type, normalized, value)               }
+	VertexAttribP3ui            :: proc "c" (index: u32, type: u32, normalized: bool, value: u32, loc := #caller_location)       {        impl_VertexAttribP3ui(index, type, normalized, value);              debug_helper(loc, 0, index, type, normalized, value)               }
+	VertexAttribP3uiv           :: proc "c" (index: u32, type: u32, normalized: bool, value: ^u32, loc := #caller_location)      {        impl_VertexAttribP3uiv(index, type, normalized, value);             debug_helper(loc, 0, index, type, normalized, value)               }
+	VertexAttribP4ui            :: proc "c" (index: u32, type: u32, normalized: bool, value: u32, loc := #caller_location)       {        impl_VertexAttribP4ui(index, type, normalized, value);              debug_helper(loc, 0, index, type, normalized, value)               }
+	VertexAttribP4uiv           :: proc "c" (index: u32, type: u32, normalized: bool, value: ^u32, loc := #caller_location)      {        impl_VertexAttribP4uiv(index, type, normalized, value);             debug_helper(loc, 0, index, type, normalized, value)               }
+	VertexP2ui                  :: proc "c" (type: u32, value: u32, loc := #caller_location)                                     {        impl_VertexP2ui(type, value);                                       debug_helper(loc, 0, type, value)                                  }
+	VertexP2uiv                 :: proc "c" (type: u32, value: ^u32, loc := #caller_location)                                    {        impl_VertexP2uiv(type, value);                                      debug_helper(loc, 0, type, value)                                  }
+	VertexP3ui                  :: proc "c" (type: u32, value: u32, loc := #caller_location)                                     {        impl_VertexP3ui(type, value);                                       debug_helper(loc, 0, type, value)                                  }
+	VertexP3uiv                 :: proc "c" (type: u32, value: ^u32, loc := #caller_location)                                    {        impl_VertexP3uiv(type, value);                                      debug_helper(loc, 0, type, value)                                  }
+	VertexP4ui                  :: proc "c" (type: u32, value: u32, loc := #caller_location)                                     {        impl_VertexP4ui(type, value);                                       debug_helper(loc, 0, type, value)                                  }
+	VertexP4uiv                 :: proc "c" (type: u32, value: ^u32, loc := #caller_location)                                    {        impl_VertexP4uiv(type, value);                                      debug_helper(loc, 0, type, value)                                  }
+	TexCoordP1ui                :: proc "c" (type: u32, coords: u32, loc := #caller_location)                                    {        impl_TexCoordP1ui(type, coords);                                    debug_helper(loc, 0, type, coords)                                 }
+	TexCoordP1uiv               :: proc "c" (type: u32, coords: [^]u32, loc := #caller_location)                                 {        impl_TexCoordP1uiv(type, coords);                                   debug_helper(loc, 0, type, coords)                                 }
+	TexCoordP2ui                :: proc "c" (type: u32, coords: u32, loc := #caller_location)                                    {        impl_TexCoordP2ui(type, coords);                                    debug_helper(loc, 0, type, coords)                                 }
+	TexCoordP2uiv               :: proc "c" (type: u32, coords: [^]u32, loc := #caller_location)                                 {        impl_TexCoordP2uiv(type, coords);                                   debug_helper(loc, 0, type, coords)                                 }
+	TexCoordP3ui                :: proc "c" (type: u32, coords: u32, loc := #caller_location)                                    {        impl_TexCoordP3ui(type, coords);                                    debug_helper(loc, 0, type, coords)                                 }
+	TexCoordP3uiv               :: proc "c" (type: u32, coords: [^]u32, loc := #caller_location)                                 {        impl_TexCoordP3uiv(type, coords);                                   debug_helper(loc, 0, type, coords)                                 }
+	TexCoordP4ui                :: proc "c" (type: u32, coords: u32, loc := #caller_location)                                    {        impl_TexCoordP4ui(type, coords);                                    debug_helper(loc, 0, type, coords)                                 }
+	TexCoordP4uiv               :: proc "c" (type: u32, coords: [^]u32, loc := #caller_location)                                 {        impl_TexCoordP4uiv(type, coords);                                   debug_helper(loc, 0, type, coords)                                 }
+	MultiTexCoordP1ui           :: proc "c" (texture: u32, type: u32, coords: u32, loc := #caller_location)                      {        impl_MultiTexCoordP1ui(texture, type, coords);                      debug_helper(loc, 0, texture, type, coords)                        }
+	MultiTexCoordP1uiv          :: proc "c" (texture: u32, type: u32, coords: [^]u32, loc := #caller_location)                   {        impl_MultiTexCoordP1uiv(texture, type, coords);                     debug_helper(loc, 0, texture, type, coords)                        }
+	MultiTexCoordP2ui           :: proc "c" (texture: u32, type: u32, coords: u32, loc := #caller_location)                      {        impl_MultiTexCoordP2ui(texture, type, coords);                      debug_helper(loc, 0, texture, type, coords)                        }
+	MultiTexCoordP2uiv          :: proc "c" (texture: u32, type: u32, coords: [^]u32, loc := #caller_location)                   {        impl_MultiTexCoordP2uiv(texture, type, coords);                     debug_helper(loc, 0, texture, type, coords)                        }
+	MultiTexCoordP3ui           :: proc "c" (texture: u32, type: u32, coords: u32, loc := #caller_location)                      {        impl_MultiTexCoordP3ui(texture, type, coords);                      debug_helper(loc, 0, texture, type, coords)                        }
+	MultiTexCoordP3uiv          :: proc "c" (texture: u32, type: u32, coords: [^]u32, loc := #caller_location)                   {        impl_MultiTexCoordP3uiv(texture, type, coords);                     debug_helper(loc, 0, texture, type, coords)                        }
+	MultiTexCoordP4ui           :: proc "c" (texture: u32, type: u32, coords: u32, loc := #caller_location)                      {        impl_MultiTexCoordP4ui(texture, type, coords);                      debug_helper(loc, 0, texture, type, coords)                        }
+	MultiTexCoordP4uiv          :: proc "c" (texture: u32, type: u32, coords: [^]u32, loc := #caller_location)                   {        impl_MultiTexCoordP4uiv(texture, type, coords);                     debug_helper(loc, 0, texture, type, coords)                        }
+	NormalP3ui                  :: proc "c" (type: u32, coords: u32, loc := #caller_location)                                    {        impl_NormalP3ui(type, coords);                                      debug_helper(loc, 0, type, coords)                                 }
+	NormalP3uiv                 :: proc "c" (type: u32, coords: [^]u32, loc := #caller_location)                                 {        impl_NormalP3uiv(type, coords);                                     debug_helper(loc, 0, type, coords)                                 }
+	ColorP3ui                   :: proc "c" (type: u32, color: u32, loc := #caller_location)                                     {        impl_ColorP3ui(type, color);                                        debug_helper(loc, 0, type, color)                                  }
+	ColorP3uiv                  :: proc "c" (type: u32, color: ^u32, loc := #caller_location)                                    {        impl_ColorP3uiv(type, color);                                       debug_helper(loc, 0, type, color)                                  }
+	ColorP4ui                   :: proc "c" (type: u32, color: u32, loc := #caller_location)                                     {        impl_ColorP4ui(type, color);                                        debug_helper(loc, 0, type, color)                                  }
+	ColorP4uiv                  :: proc "c" (type: u32, color: ^u32, loc := #caller_location)                                    {        impl_ColorP4uiv(type, color);                                       debug_helper(loc, 0, type, color)                                  }
+	SecondaryColorP3ui          :: proc "c" (type: u32, color: u32, loc := #caller_location)                                     {        impl_SecondaryColorP3ui(type, color);                               debug_helper(loc, 0, type, color)                                  }
+	SecondaryColorP3uiv         :: proc "c" (type: u32, color: ^u32, loc := #caller_location)                                    {        impl_SecondaryColorP3uiv(type, color);                              debug_helper(loc, 0, type, color)                                  }
 
 	// VERSION_4_0
-	MinSampleShading               :: #force_inline proc "c" (value: f32, loc := #caller_location)                                                                         {        impl_MinSampleShading(value);                                                            debug_helper(loc, 0, value)                                                          }
-	BlendEquationi                 :: #force_inline proc "c" (buf: u32, mode: u32, loc := #caller_location)                                                                {        impl_BlendEquationi(buf, mode);                                                          debug_helper(loc, 0, buf, mode)                                                      }
-	BlendEquationSeparatei         :: #force_inline proc "c" (buf: u32, modeRGB: u32, modeAlpha: u32, loc := #caller_location)                                             {        impl_BlendEquationSeparatei(buf, modeRGB, modeAlpha);                                    debug_helper(loc, 0, buf, modeRGB, modeAlpha)                                        }
-	BlendFunci                     :: #force_inline proc "c" (buf: u32, src: u32, dst: u32, loc := #caller_location)                                                       {        impl_BlendFunci(buf, src, dst);                                                          debug_helper(loc, 0, buf, src, dst)                                                  }
-	BlendFuncSeparatei             :: #force_inline proc "c" (buf: u32, srcRGB: u32, dstRGB: u32, srcAlpha: u32, dstAlpha: u32, loc := #caller_location)                   {        impl_BlendFuncSeparatei(buf, srcRGB, dstRGB, srcAlpha, dstAlpha);                        debug_helper(loc, 0, buf, srcRGB, dstRGB, srcAlpha, dstAlpha)                        }
-	DrawArraysIndirect             :: #force_inline proc "c" (mode: u32, indirect: ^DrawArraysIndirectCommand, loc := #caller_location)                                    {        impl_DrawArraysIndirect(mode, indirect);                                                 debug_helper(loc, 0, mode, indirect)                                                 }
-	DrawElementsIndirect           :: #force_inline proc "c" (mode: u32, type: u32, indirect: ^DrawElementsIndirectCommand, loc := #caller_location)                       {        impl_DrawElementsIndirect(mode, type, indirect);                                        debug_helper(loc, 0, mode, type, indirect)                                          }
-	Uniform1d                      :: #force_inline proc "c" (location: i32, x: f64, loc := #caller_location)                                                              {        impl_Uniform1d(location, x);                                                             debug_helper(loc, 0, location, x)                                                    }
-	Uniform2d                      :: #force_inline proc "c" (location: i32, x: f64, y: f64, loc := #caller_location)                                                      {        impl_Uniform2d(location, x, y);                                                          debug_helper(loc, 0, location, x, y)                                                 }
-	Uniform3d                      :: #force_inline proc "c" (location: i32, x: f64, y: f64, z: f64, loc := #caller_location)                                              {        impl_Uniform3d(location, x, y, z);                                                       debug_helper(loc, 0, location, x, y, z)                                              }
-	Uniform4d                      :: #force_inline proc "c" (location: i32, x: f64, y: f64, z: f64, w: f64, loc := #caller_location)                                      {        impl_Uniform4d(location, x, y, z, w);                                                    debug_helper(loc, 0, location, x, y, z, w)                                           }
-	Uniform1dv                     :: #force_inline proc "c" (location: i32, count: i32, value: [^]f64, loc := #caller_location)                                           {        impl_Uniform1dv(location, count, value);                                                 debug_helper(loc, 0, location, count, value)                                         }
-	Uniform2dv                     :: #force_inline proc "c" (location: i32, count: i32, value: [^]f64, loc := #caller_location)                                           {        impl_Uniform2dv(location, count, value);                                                 debug_helper(loc, 0, location, count, value)                                         }
-	Uniform3dv                     :: #force_inline proc "c" (location: i32, count: i32, value: [^]f64, loc := #caller_location)                                           {        impl_Uniform3dv(location, count, value);                                                 debug_helper(loc, 0, location, count, value)                                         }
-	Uniform4dv                     :: #force_inline proc "c" (location: i32, count: i32, value: [^]f64, loc := #caller_location)                                           {        impl_Uniform4dv(location, count, value);                                                 debug_helper(loc, 0, location, count, value)                                         }
-	UniformMatrix2dv               :: #force_inline proc "c" (location: i32, count: i32, transpose: bool, value: [^]f64, loc := #caller_location)                          {        impl_UniformMatrix2dv(location, count, transpose, value);                                debug_helper(loc, 0, location, count, transpose, value)                              }
-	UniformMatrix3dv               :: #force_inline proc "c" (location: i32, count: i32, transpose: bool, value: [^]f64, loc := #caller_location)                          {        impl_UniformMatrix3dv(location, count, transpose, value);                                debug_helper(loc, 0, location, count, transpose, value)                              }
-	UniformMatrix4dv               :: #force_inline proc "c" (location: i32, count: i32, transpose: bool, value: [^]f64, loc := #caller_location)                          {        impl_UniformMatrix4dv(location, count, transpose, value);                                debug_helper(loc, 0, location, count, transpose, value)                              }
-	UniformMatrix2x3dv             :: #force_inline proc "c" (location: i32, count: i32, transpose: bool, value: [^]f64, loc := #caller_location)                          {        impl_UniformMatrix2x3dv(location, count, transpose, value);                              debug_helper(loc, 0, location, count, transpose, value)                              }
-	UniformMatrix2x4dv             :: #force_inline proc "c" (location: i32, count: i32, transpose: bool, value: [^]f64, loc := #caller_location)                          {        impl_UniformMatrix2x4dv(location, count, transpose, value);                              debug_helper(loc, 0, location, count, transpose, value)                              }
-	UniformMatrix3x2dv             :: #force_inline proc "c" (location: i32, count: i32, transpose: bool, value: [^]f64, loc := #caller_location)                          {        impl_UniformMatrix3x2dv(location, count, transpose, value);                              debug_helper(loc, 0, location, count, transpose, value)                              }
-	UniformMatrix3x4dv             :: #force_inline proc "c" (location: i32, count: i32, transpose: bool, value: [^]f64, loc := #caller_location)                          {        impl_UniformMatrix3x4dv(location, count, transpose, value);                              debug_helper(loc, 0, location, count, transpose, value)                              }
-	UniformMatrix4x2dv             :: #force_inline proc "c" (location: i32, count: i32, transpose: bool, value: [^]f64, loc := #caller_location)                          {        impl_UniformMatrix4x2dv(location, count, transpose, value);                              debug_helper(loc, 0, location, count, transpose, value)                              }
-	UniformMatrix4x3dv             :: #force_inline proc "c" (location: i32, count: i32, transpose: bool, value: [^]f64, loc := #caller_location)                          {        impl_UniformMatrix4x3dv(location, count, transpose, value);                              debug_helper(loc, 0, location, count, transpose, value)                              }
-	GetUniformdv                   :: #force_inline proc "c" (program: u32, location: i32, params: [^]f64, loc := #caller_location)                                        {        impl_GetUniformdv(program, location, params);                                            debug_helper(loc, 0, program, location, params)                                      }
-	GetSubroutineUniformLocation   :: #force_inline proc "c" (program: u32, shadertype: u32, name: cstring, loc := #caller_location) -> i32                                { ret := impl_GetSubroutineUniformLocation(program, shadertype, name);                           debug_helper(loc, 1, ret, program, shadertype, name);                    return ret }
-	GetSubroutineIndex             :: #force_inline proc "c" (program: u32, shadertype: u32, name: cstring, loc := #caller_location) -> u32                                { ret := impl_GetSubroutineIndex(program, shadertype, name);                                     debug_helper(loc, 1, ret, program, shadertype, name);                    return ret }
-	GetActiveSubroutineUniformiv   :: #force_inline proc "c" (program: u32, shadertype: u32, index: u32, pname: u32, values: [^]i32, loc := #caller_location)              {        impl_GetActiveSubroutineUniformiv(program, shadertype, index, pname, values);           debug_helper(loc, 0, program, shadertype, index, pname, values)                     }
-	GetActiveSubroutineUniformName :: #force_inline proc "c" (program: u32, shadertype: u32, index: u32, bufsize: i32, length: ^i32, name: [^]u8, loc := #caller_location) {        impl_GetActiveSubroutineUniformName(program, shadertype, index, bufsize, length, name); debug_helper(loc, 0, program, shadertype, index, bufsize, length, name)             }
-	GetActiveSubroutineName        :: #force_inline proc "c" (program: u32, shadertype: u32, index: u32, bufsize: i32, length: ^i32, name: [^]u8, loc := #caller_location) {        impl_GetActiveSubroutineName(program, shadertype, index, bufsize, length, name);        debug_helper(loc, 0, program, shadertype, index, bufsize, length, name)             }
-	UniformSubroutinesuiv          :: #force_inline proc "c" (shadertype: u32, count: i32, indices: [^]u32, loc := #caller_location)                                         {        impl_UniformSubroutinesuiv(shadertype, count, indices);                                 debug_helper(loc, 0, shadertype, count, indices)                                    }
-	GetUniformSubroutineuiv        :: #force_inline proc "c" (shadertype: u32, location: i32, params: [^]u32, loc := #caller_location)                                     {        impl_GetUniformSubroutineuiv(shadertype, location, params);                             debug_helper(loc, 0, shadertype, location, params)                                  }
-	GetProgramStageiv              :: #force_inline proc "c" (program: u32, shadertype: u32, pname: u32, values: [^]i32, loc := #caller_location)                          {        impl_GetProgramStageiv(program, shadertype, pname, values);                             debug_helper(loc, 0, program, shadertype, pname, values)                            }
-	PatchParameteri                :: #force_inline proc "c" (pname: u32, value: i32, loc := #caller_location)                                                             {        impl_PatchParameteri(pname, value);                                                      debug_helper(loc, 0, pname, value)                                                   }
-	PatchParameterfv               :: #force_inline proc "c" (pname: u32, values: [^]f32, loc := #caller_location)                                                         {        impl_PatchParameterfv(pname, values);                                                    debug_helper(loc, 0, pname, values)                                                  }
-	BindTransformFeedback          :: #force_inline proc "c" (target: u32, id: u32, loc := #caller_location)                                                               {        impl_BindTransformFeedback(target, id);                                                  debug_helper(loc, 0, target, id)                                                     }
-	DeleteTransformFeedbacks       :: #force_inline proc "c" (n: i32, ids: [^]u32, loc := #caller_location)                                                                {        impl_DeleteTransformFeedbacks(n, ids);                                                   debug_helper(loc, 0, n, ids)                                                         }
-	GenTransformFeedbacks          :: #force_inline proc "c" (n: i32, ids: [^]u32, loc := #caller_location)                                                                {        impl_GenTransformFeedbacks(n, ids);                                                      debug_helper(loc, 0, n, ids)                                                         }
-	IsTransformFeedback            :: #force_inline proc "c" (id: u32, loc := #caller_location) -> bool                                                                    { ret := impl_IsTransformFeedback(id);                                                            debug_helper(loc, 1, ret, id);                                            return ret }
-	PauseTransformFeedback         :: #force_inline proc "c" (loc := #caller_location)                                                                                     {        impl_PauseTransformFeedback();                                                           debug_helper(loc, 0)                                                                 }
-	ResumeTransformFeedback        :: #force_inline proc "c" (loc := #caller_location)                                                                                     {        impl_ResumeTransformFeedback();                                                          debug_helper(loc, 0)                                                                 }
-	DrawTransformFeedback          :: #force_inline proc "c" (mode: u32, id: u32, loc := #caller_location)                                                                 {        impl_DrawTransformFeedback(mode, id);                                                    debug_helper(loc, 0, mode, id)                                                       }
-	DrawTransformFeedbackStream    :: #force_inline proc "c" (mode: u32, id: u32, stream: u32, loc := #caller_location)                                                    {        impl_DrawTransformFeedbackStream(mode, id, stream);                                      debug_helper(loc, 0, mode, id, stream)                                               }
-	BeginQueryIndexed              :: #force_inline proc "c" (target: u32, index: u32, id: u32, loc := #caller_location)                                                   {        impl_BeginQueryIndexed(target, index, id);                                               debug_helper(loc, 0, target, index, id)                                              }
-	EndQueryIndexed                :: #force_inline proc "c" (target: u32, index: u32, loc := #caller_location)                                                            {        impl_EndQueryIndexed(target, index);                                                     debug_helper(loc, 0, target, index)                                                  }
-	GetQueryIndexediv              :: #force_inline proc "c" (target: u32, index: u32, pname: u32, params: [^]i32, loc := #caller_location)                                {        impl_GetQueryIndexediv(target, index, pname, params);                                    debug_helper(loc, 0, target, index, pname, params)                                   }
+	MinSampleShading               :: proc "c" (value: f32, loc := #caller_location)                                                                         {        impl_MinSampleShading(value);                                                            debug_helper(loc, 0, value)                                                          }
+	BlendEquationi                 :: proc "c" (buf: u32, mode: u32, loc := #caller_location)                                                                {        impl_BlendEquationi(buf, mode);                                                          debug_helper(loc, 0, buf, mode)                                                      }
+	BlendEquationSeparatei         :: proc "c" (buf: u32, modeRGB: u32, modeAlpha: u32, loc := #caller_location)                                             {        impl_BlendEquationSeparatei(buf, modeRGB, modeAlpha);                                    debug_helper(loc, 0, buf, modeRGB, modeAlpha)                                        }
+	BlendFunci                     :: proc "c" (buf: u32, src: u32, dst: u32, loc := #caller_location)                                                       {        impl_BlendFunci(buf, src, dst);                                                          debug_helper(loc, 0, buf, src, dst)                                                  }
+	BlendFuncSeparatei             :: proc "c" (buf: u32, srcRGB: u32, dstRGB: u32, srcAlpha: u32, dstAlpha: u32, loc := #caller_location)                   {        impl_BlendFuncSeparatei(buf, srcRGB, dstRGB, srcAlpha, dstAlpha);                        debug_helper(loc, 0, buf, srcRGB, dstRGB, srcAlpha, dstAlpha)                        }
+	DrawArraysIndirect             :: proc "c" (mode: u32, indirect: ^DrawArraysIndirectCommand, loc := #caller_location)                                    {        impl_DrawArraysIndirect(mode, indirect);                                                 debug_helper(loc, 0, mode, indirect)                                                 }
+	DrawElementsIndirect           :: proc "c" (mode: u32, type: u32, indirect: ^DrawElementsIndirectCommand, loc := #caller_location)                       {        impl_DrawElementsIndirect(mode, type, indirect);                                        debug_helper(loc, 0, mode, type, indirect)                                          }
+	Uniform1d                      :: proc "c" (location: i32, x: f64, loc := #caller_location)                                                              {        impl_Uniform1d(location, x);                                                             debug_helper(loc, 0, location, x)                                                    }
+	Uniform2d                      :: proc "c" (location: i32, x: f64, y: f64, loc := #caller_location)                                                      {        impl_Uniform2d(location, x, y);                                                          debug_helper(loc, 0, location, x, y)                                                 }
+	Uniform3d                      :: proc "c" (location: i32, x: f64, y: f64, z: f64, loc := #caller_location)                                              {        impl_Uniform3d(location, x, y, z);                                                       debug_helper(loc, 0, location, x, y, z)                                              }
+	Uniform4d                      :: proc "c" (location: i32, x: f64, y: f64, z: f64, w: f64, loc := #caller_location)                                      {        impl_Uniform4d(location, x, y, z, w);                                                    debug_helper(loc, 0, location, x, y, z, w)                                           }
+	Uniform1dv                     :: proc "c" (location: i32, count: i32, value: [^]f64, loc := #caller_location)                                           {        impl_Uniform1dv(location, count, value);                                                 debug_helper(loc, 0, location, count, value)                                         }
+	Uniform2dv                     :: proc "c" (location: i32, count: i32, value: [^]f64, loc := #caller_location)                                           {        impl_Uniform2dv(location, count, value);                                                 debug_helper(loc, 0, location, count, value)                                         }
+	Uniform3dv                     :: proc "c" (location: i32, count: i32, value: [^]f64, loc := #caller_location)                                           {        impl_Uniform3dv(location, count, value);                                                 debug_helper(loc, 0, location, count, value)                                         }
+	Uniform4dv                     :: proc "c" (location: i32, count: i32, value: [^]f64, loc := #caller_location)                                           {        impl_Uniform4dv(location, count, value);                                                 debug_helper(loc, 0, location, count, value)                                         }
+	UniformMatrix2dv               :: proc "c" (location: i32, count: i32, transpose: bool, value: [^]f64, loc := #caller_location)                          {        impl_UniformMatrix2dv(location, count, transpose, value);                                debug_helper(loc, 0, location, count, transpose, value)                              }
+	UniformMatrix3dv               :: proc "c" (location: i32, count: i32, transpose: bool, value: [^]f64, loc := #caller_location)                          {        impl_UniformMatrix3dv(location, count, transpose, value);                                debug_helper(loc, 0, location, count, transpose, value)                              }
+	UniformMatrix4dv               :: proc "c" (location: i32, count: i32, transpose: bool, value: [^]f64, loc := #caller_location)                          {        impl_UniformMatrix4dv(location, count, transpose, value);                                debug_helper(loc, 0, location, count, transpose, value)                              }
+	UniformMatrix2x3dv             :: proc "c" (location: i32, count: i32, transpose: bool, value: [^]f64, loc := #caller_location)                          {        impl_UniformMatrix2x3dv(location, count, transpose, value);                              debug_helper(loc, 0, location, count, transpose, value)                              }
+	UniformMatrix2x4dv             :: proc "c" (location: i32, count: i32, transpose: bool, value: [^]f64, loc := #caller_location)                          {        impl_UniformMatrix2x4dv(location, count, transpose, value);                              debug_helper(loc, 0, location, count, transpose, value)                              }
+	UniformMatrix3x2dv             :: proc "c" (location: i32, count: i32, transpose: bool, value: [^]f64, loc := #caller_location)                          {        impl_UniformMatrix3x2dv(location, count, transpose, value);                              debug_helper(loc, 0, location, count, transpose, value)                              }
+	UniformMatrix3x4dv             :: proc "c" (location: i32, count: i32, transpose: bool, value: [^]f64, loc := #caller_location)                          {        impl_UniformMatrix3x4dv(location, count, transpose, value);                              debug_helper(loc, 0, location, count, transpose, value)                              }
+	UniformMatrix4x2dv             :: proc "c" (location: i32, count: i32, transpose: bool, value: [^]f64, loc := #caller_location)                          {        impl_UniformMatrix4x2dv(location, count, transpose, value);                              debug_helper(loc, 0, location, count, transpose, value)                              }
+	UniformMatrix4x3dv             :: proc "c" (location: i32, count: i32, transpose: bool, value: [^]f64, loc := #caller_location)                          {        impl_UniformMatrix4x3dv(location, count, transpose, value);                              debug_helper(loc, 0, location, count, transpose, value)                              }
+	GetUniformdv                   :: proc "c" (program: u32, location: i32, params: [^]f64, loc := #caller_location)                                        {        impl_GetUniformdv(program, location, params);                                            debug_helper(loc, 0, program, location, params)                                      }
+	GetSubroutineUniformLocation   :: proc "c" (program: u32, shadertype: u32, name: cstring, loc := #caller_location) -> i32                                { ret := impl_GetSubroutineUniformLocation(program, shadertype, name);                           debug_helper(loc, 1, ret, program, shadertype, name);                    return ret }
+	GetSubroutineIndex             :: proc "c" (program: u32, shadertype: u32, name: cstring, loc := #caller_location) -> u32                                { ret := impl_GetSubroutineIndex(program, shadertype, name);                                     debug_helper(loc, 1, ret, program, shadertype, name);                    return ret }
+	GetActiveSubroutineUniformiv   :: proc "c" (program: u32, shadertype: u32, index: u32, pname: u32, values: [^]i32, loc := #caller_location)              {        impl_GetActiveSubroutineUniformiv(program, shadertype, index, pname, values);           debug_helper(loc, 0, program, shadertype, index, pname, values)                     }
+	GetActiveSubroutineUniformName :: proc "c" (program: u32, shadertype: u32, index: u32, bufsize: i32, length: ^i32, name: [^]u8, loc := #caller_location) {        impl_GetActiveSubroutineUniformName(program, shadertype, index, bufsize, length, name); debug_helper(loc, 0, program, shadertype, index, bufsize, length, name)             }
+	GetActiveSubroutineName        :: proc "c" (program: u32, shadertype: u32, index: u32, bufsize: i32, length: ^i32, name: [^]u8, loc := #caller_location) {        impl_GetActiveSubroutineName(program, shadertype, index, bufsize, length, name);        debug_helper(loc, 0, program, shadertype, index, bufsize, length, name)             }
+	UniformSubroutinesuiv          :: proc "c" (shadertype: u32, count: i32, indices: [^]u32, loc := #caller_location)                                         {        impl_UniformSubroutinesuiv(shadertype, count, indices);                                 debug_helper(loc, 0, shadertype, count, indices)                                    }
+	GetUniformSubroutineuiv        :: proc "c" (shadertype: u32, location: i32, params: [^]u32, loc := #caller_location)                                     {        impl_GetUniformSubroutineuiv(shadertype, location, params);                             debug_helper(loc, 0, shadertype, location, params)                                  }
+	GetProgramStageiv              :: proc "c" (program: u32, shadertype: u32, pname: u32, values: [^]i32, loc := #caller_location)                          {        impl_GetProgramStageiv(program, shadertype, pname, values);                             debug_helper(loc, 0, program, shadertype, pname, values)                            }
+	PatchParameteri                :: proc "c" (pname: u32, value: i32, loc := #caller_location)                                                             {        impl_PatchParameteri(pname, value);                                                      debug_helper(loc, 0, pname, value)                                                   }
+	PatchParameterfv               :: proc "c" (pname: u32, values: [^]f32, loc := #caller_location)                                                         {        impl_PatchParameterfv(pname, values);                                                    debug_helper(loc, 0, pname, values)                                                  }
+	BindTransformFeedback          :: proc "c" (target: u32, id: u32, loc := #caller_location)                                                               {        impl_BindTransformFeedback(target, id);                                                  debug_helper(loc, 0, target, id)                                                     }
+	DeleteTransformFeedbacks       :: proc "c" (n: i32, ids: [^]u32, loc := #caller_location)                                                                {        impl_DeleteTransformFeedbacks(n, ids);                                                   debug_helper(loc, 0, n, ids)                                                         }
+	GenTransformFeedbacks          :: proc "c" (n: i32, ids: [^]u32, loc := #caller_location)                                                                {        impl_GenTransformFeedbacks(n, ids);                                                      debug_helper(loc, 0, n, ids)                                                         }
+	IsTransformFeedback            :: proc "c" (id: u32, loc := #caller_location) -> bool                                                                    { ret := impl_IsTransformFeedback(id);                                                            debug_helper(loc, 1, ret, id);                                            return ret }
+	PauseTransformFeedback         :: proc "c" (loc := #caller_location)                                                                                     {        impl_PauseTransformFeedback();                                                           debug_helper(loc, 0)                                                                 }
+	ResumeTransformFeedback        :: proc "c" (loc := #caller_location)                                                                                     {        impl_ResumeTransformFeedback();                                                          debug_helper(loc, 0)                                                                 }
+	DrawTransformFeedback          :: proc "c" (mode: u32, id: u32, loc := #caller_location)                                                                 {        impl_DrawTransformFeedback(mode, id);                                                    debug_helper(loc, 0, mode, id)                                                       }
+	DrawTransformFeedbackStream    :: proc "c" (mode: u32, id: u32, stream: u32, loc := #caller_location)                                                    {        impl_DrawTransformFeedbackStream(mode, id, stream);                                      debug_helper(loc, 0, mode, id, stream)                                               }
+	BeginQueryIndexed              :: proc "c" (target: u32, index: u32, id: u32, loc := #caller_location)                                                   {        impl_BeginQueryIndexed(target, index, id);                                               debug_helper(loc, 0, target, index, id)                                              }
+	EndQueryIndexed                :: proc "c" (target: u32, index: u32, loc := #caller_location)                                                            {        impl_EndQueryIndexed(target, index);                                                     debug_helper(loc, 0, target, index)                                                  }
+	GetQueryIndexediv              :: proc "c" (target: u32, index: u32, pname: u32, params: [^]i32, loc := #caller_location)                                {        impl_GetQueryIndexediv(target, index, pname, params);                                    debug_helper(loc, 0, target, index, pname, params)                                   }
 
 	// VERSION_4_1
-	ReleaseShaderCompiler     :: #force_inline proc "c" (loc := #caller_location)                                                                               {        impl_ReleaseShaderCompiler();                                                 debug_helper(loc, 0)                                                             }
-	ShaderBinary              :: #force_inline proc "c" (count: i32, shaders: ^u32, binaryformat: u32, binary: rawptr, length: i32, loc := #caller_location)    {        impl_ShaderBinary(count, shaders, binaryformat, binary, length);              debug_helper(loc, 0, count, shaders, binaryformat, binary, length)               }
-	GetShaderPrecisionFormat  :: #force_inline proc "c" (shadertype: u32, precisiontype: u32, range: ^i32, precision: ^i32, loc := #caller_location)            {        impl_GetShaderPrecisionFormat(shadertype, precisiontype, range, precision); debug_helper(loc, 0, shadertype, precisiontype, range, precision)              }
-	DepthRangef               :: #force_inline proc "c" (n: f32, f: f32, loc := #caller_location)                                                               {        impl_DepthRangef(n, f);                                                       debug_helper(loc, 0, n, f)                                                       }
-	ClearDepthf               :: #force_inline proc "c" (d: f32, loc := #caller_location)                                                                       {        impl_ClearDepthf(d);                                                          debug_helper(loc, 0, d)                                                          }
-	GetProgramBinary          :: #force_inline proc "c" (program: u32, bufSize: i32, length: ^i32, binaryFormat: ^u32, binary: rawptr, loc := #caller_location) {        impl_GetProgramBinary(program, bufSize, length, binaryFormat, binary);        debug_helper(loc, 0, program, bufSize, length, binaryFormat, binary)             }
-	ProgramBinary             :: #force_inline proc "c" (program: u32, binaryFormat: u32, binary: rawptr, length: i32, loc := #caller_location)                 {        impl_ProgramBinary(program, binaryFormat, binary, length);                    debug_helper(loc, 0, program, binaryFormat, binary, length)                      }
-	ProgramParameteri         :: #force_inline proc "c" (program: u32, pname: u32, value: i32, loc := #caller_location)                                         {        impl_ProgramParameteri(program, pname, value);                                debug_helper(loc, 0, program, pname, value)                                      }
-	UseProgramStages          :: #force_inline proc "c" (pipeline: u32, stages: u32, program: u32, loc := #caller_location)                                     {        impl_UseProgramStages(pipeline, stages, program);                             debug_helper(loc, 0, pipeline, stages, program)                                  }
-	ActiveShaderProgram       :: #force_inline proc "c" (pipeline: u32, program: u32, loc := #caller_location)                                                  {        impl_ActiveShaderProgram(pipeline, program);                                  debug_helper(loc, 0, pipeline, program)                                          }
-	CreateShaderProgramv      :: #force_inline proc "c" (type: u32, count: i32, strings: [^]cstring, loc := #caller_location) -> u32                            { ret := impl_CreateShaderProgramv(type, count, strings);                             debug_helper(loc, 1, ret, type, count, strings);                    return ret }
-	BindProgramPipeline       :: #force_inline proc "c" (pipeline: u32, loc := #caller_location)                                                                {        impl_BindProgramPipeline(pipeline);                                           debug_helper(loc, 0, pipeline)                                                   }
-	DeleteProgramPipelines    :: #force_inline proc "c" (n: i32, pipelines: [^]u32, loc := #caller_location)                                                    {        impl_DeleteProgramPipelines(n, pipelines);                                    debug_helper(loc, 0, n, pipelines)                                               }
-	GenProgramPipelines       :: #force_inline proc "c" (n: i32, pipelines: [^]u32, loc := #caller_location)                                                    {        impl_GenProgramPipelines(n, pipelines);                                       debug_helper(loc, 0, n, pipelines)                                               }
-	IsProgramPipeline         :: #force_inline proc "c" (pipeline: u32, loc := #caller_location) -> bool                                                        { ret := impl_IsProgramPipeline(pipeline);                                             debug_helper(loc, 1, ret, pipeline);                                 return ret }
-	GetProgramPipelineiv      :: #force_inline proc "c" (pipeline: u32, pname: u32, params: [^]i32, loc := #caller_location)                                    {        impl_GetProgramPipelineiv(pipeline, pname, params);                           debug_helper(loc, 0, pipeline, pname, params)                                    }
-	ProgramUniform1i          :: #force_inline proc "c" (program: u32, location: i32, v0: i32, loc := #caller_location)                                         {        impl_ProgramUniform1i(program, location, v0);                                 debug_helper(loc, 0, program, location, v0)                                      }
-	ProgramUniform1iv         :: #force_inline proc "c" (program: u32, location: i32, count: i32, value: [^]i32, loc := #caller_location)                       {        impl_ProgramUniform1iv(program, location, count, value);                      debug_helper(loc, 0, program, location, count, value)                            }
-	ProgramUniform1f          :: #force_inline proc "c" (program: u32, location: i32, v0: f32, loc := #caller_location)                                         {        impl_ProgramUniform1f(program, location, v0);                                 debug_helper(loc, 0, program, location, v0)                                      }
-	ProgramUniform1fv         :: #force_inline proc "c" (program: u32, location: i32, count: i32, value: [^]f32, loc := #caller_location)                       {        impl_ProgramUniform1fv(program, location, count, value);                      debug_helper(loc, 0, program, location, count, value)                            }
-	ProgramUniform1d          :: #force_inline proc "c" (program: u32, location: i32, v0: f64, loc := #caller_location)                                         {        impl_ProgramUniform1d(program, location, v0);                                 debug_helper(loc, 0, program, location, v0)                                      }
-	ProgramUniform1dv         :: #force_inline proc "c" (program: u32, location: i32, count: i32, value: [^]f64, loc := #caller_location)                       {        impl_ProgramUniform1dv(program, location, count, value);                      debug_helper(loc, 0, program, location, count, value)                            }
-	ProgramUniform1ui         :: #force_inline proc "c" (program: u32, location: i32, v0: u32, loc := #caller_location)                                         {        impl_ProgramUniform1ui(program, location, v0);                                debug_helper(loc, 0, program, location, v0)                                      }
-	ProgramUniform1uiv        :: #force_inline proc "c" (program: u32, location: i32, count: i32, value: [^]u32, loc := #caller_location)                       {        impl_ProgramUniform1uiv(program, location, count, value);                     debug_helper(loc, 0, program, location, count, value)                            }
-	ProgramUniform2i          :: #force_inline proc "c" (program: u32, location: i32, v0: i32, v1: i32, loc := #caller_location)                                {        impl_ProgramUniform2i(program, location, v0, v1);                             debug_helper(loc, 0, program, location, v0, v1)                                  }
-	ProgramUniform2iv         :: #force_inline proc "c" (program: u32, location: i32, count: i32, value: [^]i32, loc := #caller_location)                       {        impl_ProgramUniform2iv(program, location, count, value);                      debug_helper(loc, 0, program, location, count, value)                            }
-	ProgramUniform2f          :: #force_inline proc "c" (program: u32, location: i32, v0: f32, v1: f32, loc := #caller_location)                                {        impl_ProgramUniform2f(program, location, v0, v1);                             debug_helper(loc, 0, program, location, v0, v1)                                  }
-	ProgramUniform2fv         :: #force_inline proc "c" (program: u32, location: i32, count: i32, value: [^]f32, loc := #caller_location)                       {        impl_ProgramUniform2fv(program, location, count, value);                      debug_helper(loc, 0, program, location, count, value)                            }
-	ProgramUniform2d          :: #force_inline proc "c" (program: u32, location: i32, v0: f64, v1: f64, loc := #caller_location)                                {        impl_ProgramUniform2d(program, location, v0, v1);                             debug_helper(loc, 0, program, location, v0, v1)                                  }
-	ProgramUniform2dv         :: #force_inline proc "c" (program: u32, location: i32, count: i32, value: [^]f64, loc := #caller_location)                       {        impl_ProgramUniform2dv(program, location, count, value);                      debug_helper(loc, 0, program, location, count, value)                            }
-	ProgramUniform2ui         :: #force_inline proc "c" (program: u32, location: i32, v0: u32, v1: u32, loc := #caller_location)                                {        impl_ProgramUniform2ui(program, location, v0, v1);                            debug_helper(loc, 0, program, location, v0, v1)                                  }
-	ProgramUniform2uiv        :: #force_inline proc "c" (program: u32, location: i32, count: i32, value: [^]u32, loc := #caller_location)                       {        impl_ProgramUniform2uiv(program, location, count, value);                     debug_helper(loc, 0, program, location, count, value)                            }
-	ProgramUniform3i          :: #force_inline proc "c" (program: u32, location: i32, v0: i32, v1: i32, v2: i32, loc := #caller_location)                       {        impl_ProgramUniform3i(program, location, v0, v1, v2);                         debug_helper(loc, 0, program, location, v0, v1, v2)                              }
-	ProgramUniform3iv         :: #force_inline proc "c" (program: u32, location: i32, count: i32, value: [^]i32, loc := #caller_location)                       {        impl_ProgramUniform3iv(program, location, count, value);                      debug_helper(loc, 0, program, location, count, value)                            }
-	ProgramUniform3f          :: #force_inline proc "c" (program: u32, location: i32, v0: f32, v1: f32, v2: f32, loc := #caller_location)                       {        impl_ProgramUniform3f(program, location, v0, v1, v2);                         debug_helper(loc, 0, program, location, v0, v1, v2)                              }
-	ProgramUniform3fv         :: #force_inline proc "c" (program: u32, location: i32, count: i32, value: [^]f32, loc := #caller_location)                       {        impl_ProgramUniform3fv(program, location, count, value);                      debug_helper(loc, 0, program, location, count, value)                            }
-	ProgramUniform3d          :: #force_inline proc "c" (program: u32, location: i32, v0: f64, v1: f64, v2: f64, loc := #caller_location)                       {        impl_ProgramUniform3d(program, location, v0, v1, v2);                         debug_helper(loc, 0, program, location, v0, v1, v2)                              }
-	ProgramUniform3dv         :: #force_inline proc "c" (program: u32, location: i32, count: i32, value: [^]f64, loc := #caller_location)                       {        impl_ProgramUniform3dv(program, location, count, value);                      debug_helper(loc, 0, program, location, count, value)                            }
-	ProgramUniform3ui         :: #force_inline proc "c" (program: u32, location: i32, v0: u32, v1: u32, v2: u32, loc := #caller_location)                       {        impl_ProgramUniform3ui(program, location, v0, v1, v2);                        debug_helper(loc, 0, program, location, v0, v1, v2)                              }
-	ProgramUniform3uiv        :: #force_inline proc "c" (program: u32, location: i32, count: i32, value: [^]u32, loc := #caller_location)                       {        impl_ProgramUniform3uiv(program, location, count, value);                     debug_helper(loc, 0, program, location, count, value)                            }
-	ProgramUniform4i          :: #force_inline proc "c" (program: u32, location: i32, v0: i32, v1: i32, v2: i32, v3: i32, loc := #caller_location)              {        impl_ProgramUniform4i(program, location, v0, v1, v2, v3);                     debug_helper(loc, 0, program, location, v0, v1, v2, v3)                          }
-	ProgramUniform4iv         :: #force_inline proc "c" (program: u32, location: i32, count: i32, value: [^]i32, loc := #caller_location)                       {        impl_ProgramUniform4iv(program, location, count, value);                      debug_helper(loc, 0, program, location, count, value)                            }
-	ProgramUniform4f          :: #force_inline proc "c" (program: u32, location: i32, v0: f32, v1: f32, v2: f32, v3: f32, loc := #caller_location)              {        impl_ProgramUniform4f(program, location, v0, v1, v2, v3);                     debug_helper(loc, 0, program, location, v0, v1, v2, v3)                          }
-	ProgramUniform4fv         :: #force_inline proc "c" (program: u32, location: i32, count: i32, value: [^]f32, loc := #caller_location)                       {        impl_ProgramUniform4fv(program, location, count, value);                      debug_helper(loc, 0, program, location, count, value)                            }
-	ProgramUniform4d          :: #force_inline proc "c" (program: u32, location: i32, v0: f64, v1: f64, v2: f64, v3: f64, loc := #caller_location)              {        impl_ProgramUniform4d(program, location, v0, v1, v2, v3);                     debug_helper(loc, 0, program, location, v0, v1, v2, v3)                          }
-	ProgramUniform4dv         :: #force_inline proc "c" (program: u32, location: i32, count: i32, value: [^]f64, loc := #caller_location)                       {        impl_ProgramUniform4dv(program, location, count, value);                      debug_helper(loc, 0, program, location, count, value)                            }
-	ProgramUniform4ui         :: #force_inline proc "c" (program: u32, location: i32, v0: u32, v1: u32, v2: u32, v3: u32, loc := #caller_location)              {        impl_ProgramUniform4ui(program, location, v0, v1, v2, v3);                    debug_helper(loc, 0, program, location, v0, v1, v2, v3)                          }
-	ProgramUniform4uiv        :: #force_inline proc "c" (program: u32, location: i32, count: i32, value: [^]u32, loc := #caller_location)                       {        impl_ProgramUniform4uiv(program, location, count, value);                     debug_helper(loc, 0, program, location, count, value)                            }
-	ProgramUniformMatrix2fv   :: #force_inline proc "c" (program: u32, location: i32, count: i32, transpose: bool, value: [^]f32, loc := #caller_location)      {        impl_ProgramUniformMatrix2fv(program, location, count, transpose, value);     debug_helper(loc, 0, program, location, count, transpose, value)                 }
-	ProgramUniformMatrix3fv   :: #force_inline proc "c" (program: u32, location: i32, count: i32, transpose: bool, value: [^]f32, loc := #caller_location)      {        impl_ProgramUniformMatrix3fv(program, location, count, transpose, value);     debug_helper(loc, 0, program, location, count, transpose, value)                 }
-	ProgramUniformMatrix4fv   :: #force_inline proc "c" (program: u32, location: i32, count: i32, transpose: bool, value: [^]f32, loc := #caller_location)      {        impl_ProgramUniformMatrix4fv(program, location, count, transpose, value);     debug_helper(loc, 0, program, location, count, transpose, value)                 }
-	ProgramUniformMatrix2dv   :: #force_inline proc "c" (program: u32, location: i32, count: i32, transpose: bool, value: [^]f64, loc := #caller_location)      {        impl_ProgramUniformMatrix2dv(program, location, count, transpose, value);     debug_helper(loc, 0, program, location, count, transpose, value)                 }
-	ProgramUniformMatrix3dv   :: #force_inline proc "c" (program: u32, location: i32, count: i32, transpose: bool, value: [^]f64, loc := #caller_location)      {        impl_ProgramUniformMatrix3dv(program, location, count, transpose, value);     debug_helper(loc, 0, program, location, count, transpose, value)                 }
-	ProgramUniformMatrix4dv   :: #force_inline proc "c" (program: u32, location: i32, count: i32, transpose: bool, value: [^]f64, loc := #caller_location)      {        impl_ProgramUniformMatrix4dv(program, location, count, transpose, value);     debug_helper(loc, 0, program, location, count, transpose, value)                 }
-	ProgramUniformMatrix2x3fv :: #force_inline proc "c" (program: u32, location: i32, count: i32, transpose: bool, value: [^]f32, loc := #caller_location)      {        impl_ProgramUniformMatrix2x3fv(program, location, count, transpose, value);   debug_helper(loc, 0, program, location, count, transpose, value)                 }
-	ProgramUniformMatrix3x2fv :: #force_inline proc "c" (program: u32, location: i32, count: i32, transpose: bool, value: [^]f32, loc := #caller_location)      {        impl_ProgramUniformMatrix3x2fv(program, location, count, transpose, value);   debug_helper(loc, 0, program, location, count, transpose, value)                 }
-	ProgramUniformMatrix2x4fv :: #force_inline proc "c" (program: u32, location: i32, count: i32, transpose: bool, value: [^]f32, loc := #caller_location)      {        impl_ProgramUniformMatrix2x4fv(program, location, count, transpose, value);   debug_helper(loc, 0, program, location, count, transpose, value)                 }
-	ProgramUniformMatrix4x2fv :: #force_inline proc "c" (program: u32, location: i32, count: i32, transpose: bool, value: [^]f32, loc := #caller_location)      {        impl_ProgramUniformMatrix4x2fv(program, location, count, transpose, value);   debug_helper(loc, 0, program, location, count, transpose, value)                 }
-	ProgramUniformMatrix3x4fv :: #force_inline proc "c" (program: u32, location: i32, count: i32, transpose: bool, value: [^]f32, loc := #caller_location)      {        impl_ProgramUniformMatrix3x4fv(program, location, count, transpose, value);   debug_helper(loc, 0, program, location, count, transpose, value)                 }
-	ProgramUniformMatrix4x3fv :: #force_inline proc "c" (program: u32, location: i32, count: i32, transpose: bool, value: [^]f32, loc := #caller_location)      {        impl_ProgramUniformMatrix4x3fv(program, location, count, transpose, value);   debug_helper(loc, 0, program, location, count, transpose, value)                 }
-	ProgramUniformMatrix2x3dv :: #force_inline proc "c" (program: u32, location: i32, count: i32, transpose: bool, value: [^]f64, loc := #caller_location)      {        impl_ProgramUniformMatrix2x3dv(program, location, count, transpose, value);   debug_helper(loc, 0, program, location, count, transpose, value)                 }
-	ProgramUniformMatrix3x2dv :: #force_inline proc "c" (program: u32, location: i32, count: i32, transpose: bool, value: [^]f64, loc := #caller_location)      {        impl_ProgramUniformMatrix3x2dv(program, location, count, transpose, value);   debug_helper(loc, 0, program, location, count, transpose, value)                 }
-	ProgramUniformMatrix2x4dv :: #force_inline proc "c" (program: u32, location: i32, count: i32, transpose: bool, value: [^]f64, loc := #caller_location)      {        impl_ProgramUniformMatrix2x4dv(program, location, count, transpose, value);   debug_helper(loc, 0, program, location, count, transpose, value)                 }
-	ProgramUniformMatrix4x2dv :: #force_inline proc "c" (program: u32, location: i32, count: i32, transpose: bool, value: [^]f64, loc := #caller_location)      {        impl_ProgramUniformMatrix4x2dv(program, location, count, transpose, value);   debug_helper(loc, 0, program, location, count, transpose, value)                 }
-	ProgramUniformMatrix3x4dv :: #force_inline proc "c" (program: u32, location: i32, count: i32, transpose: bool, value: [^]f64, loc := #caller_location)      {        impl_ProgramUniformMatrix3x4dv(program, location, count, transpose, value);   debug_helper(loc, 0, program, location, count, transpose, value)                 }
-	ProgramUniformMatrix4x3dv :: #force_inline proc "c" (program: u32, location: i32, count: i32, transpose: bool, value: [^]f64, loc := #caller_location)      {        impl_ProgramUniformMatrix4x3dv(program, location, count, transpose, value);   debug_helper(loc, 0, program, location, count, transpose, value)                 }
-	ValidateProgramPipeline   :: #force_inline proc "c" (pipeline: u32, loc := #caller_location)                                                                {        impl_ValidateProgramPipeline(pipeline);                                       debug_helper(loc, 0, pipeline)                                                   }
-	GetProgramPipelineInfoLog :: #force_inline proc "c" (pipeline: u32, bufSize: i32, length: ^i32, infoLog: [^]u8, loc := #caller_location)                    {        impl_GetProgramPipelineInfoLog(pipeline, bufSize, length, infoLog);           debug_helper(loc, 0, pipeline, bufSize, length, infoLog)                         }
-	VertexAttribL1d           :: #force_inline proc "c" (index: u32, x: f64, loc := #caller_location)                                                           {        impl_VertexAttribL1d(index, x);                                               debug_helper(loc, 0, index, x)                                                   }
-	VertexAttribL2d           :: #force_inline proc "c" (index: u32, x: f64, y: f64, loc := #caller_location)                                                   {        impl_VertexAttribL2d(index, x, y);                                            debug_helper(loc, 0, index, x, y)                                                }
-	VertexAttribL3d           :: #force_inline proc "c" (index: u32, x: f64, y: f64, z: f64, loc := #caller_location)                                           {        impl_VertexAttribL3d(index, x, y, z);                                         debug_helper(loc, 0, index, x, y, z)                                             }
-	VertexAttribL4d           :: #force_inline proc "c" (index: u32, x: f64, y: f64, z: f64, w: f64, loc := #caller_location)                                   {        impl_VertexAttribL4d(index, x, y, z, w);                                      debug_helper(loc, 0, index, x, y, z, w)                                          }
-	VertexAttribL1dv          :: #force_inline proc "c" (index: u32, v: ^f64, loc := #caller_location)                                                          {        impl_VertexAttribL1dv(index, v);                                              debug_helper(loc, 0, index, v)                                                   }
-	VertexAttribL2dv          :: #force_inline proc "c" (index: u32, v: ^[2]f64, loc := #caller_location)                                                          {        impl_VertexAttribL2dv(index, v);                                              debug_helper(loc, 0, index, v)                                                   }
-	VertexAttribL3dv          :: #force_inline proc "c" (index: u32, v: ^[3]f64, loc := #caller_location)                                                          {        impl_VertexAttribL3dv(index, v);                                              debug_helper(loc, 0, index, v)                                                   }
-	VertexAttribL4dv          :: #force_inline proc "c" (index: u32, v: ^[4]f64, loc := #caller_location)                                                          {        impl_VertexAttribL4dv(index, v);                                              debug_helper(loc, 0, index, v)                                                   }
-	VertexAttribLPointer      :: #force_inline proc "c" (index: u32, size: i32, type: u32, stride: i32, pointer: uintptr, loc := #caller_location)               {        impl_VertexAttribLPointer(index, size, type, stride, pointer);               debug_helper(loc, 0, index, size, type, stride, pointer)                        }
-	GetVertexAttribLdv        :: #force_inline proc "c" (index: u32, pname: u32, params: [^]f64, loc := #caller_location)                                       {        impl_GetVertexAttribLdv(index, pname, params);                                debug_helper(loc, 0, index, pname, params)                                       }
-	ViewportArrayv            :: #force_inline proc "c" (first: u32, count: i32, v: [^]f32, loc := #caller_location)                                            {        impl_ViewportArrayv(first, count, v);                                         debug_helper(loc, 0, first, count, v)                                            }
-	ViewportIndexedf          :: #force_inline proc "c" (index: u32, x: f32, y: f32, w: f32, h: f32, loc := #caller_location)                                   {        impl_ViewportIndexedf(index, x, y, w, h);                                     debug_helper(loc, 0, index, x, y, w, h)                                          }
-	ViewportIndexedfv         :: #force_inline proc "c" (index: u32, v: ^[4]f32, loc := #caller_location)                                                          {        impl_ViewportIndexedfv(index, v);                                             debug_helper(loc, 0, index, v)                                                   }
-	ScissorArrayv             :: #force_inline proc "c" (first: u32, count: i32, v: [^]i32, loc := #caller_location)                                            {        impl_ScissorArrayv(first, count, v);                                          debug_helper(loc, 0, first, count, v)                                            }
-	ScissorIndexed            :: #force_inline proc "c" (index: u32, left: i32, bottom: i32, width: i32, height: i32, loc := #caller_location)                  {        impl_ScissorIndexed(index, left, bottom, width, height);                      debug_helper(loc, 0, index, left, bottom, width, height)                         }
-	ScissorIndexedv           :: #force_inline proc "c" (index: u32, v: ^[4]i32, loc := #caller_location)                                                          {        impl_ScissorIndexedv(index, v);                                               debug_helper(loc, 0, index, v)                                                   }
-	DepthRangeArrayv          :: #force_inline proc "c" (first: u32, count: i32, v: [^]f64, loc := #caller_location)                                            {        impl_DepthRangeArrayv(first, count, v);                                       debug_helper(loc, 0, first, count, v)                                            }
-	DepthRangeIndexed         :: #force_inline proc "c" (index: u32, n: f64, f: f64, loc := #caller_location)                                                   {        impl_DepthRangeIndexed(index, n, f);                                          debug_helper(loc, 0, index, n, f)                                                }
-	GetFloati_v               :: #force_inline proc "c" (target: u32, index: u32, data: ^f32, loc := #caller_location)                                          {        impl_GetFloati_v(target, index, data);                                        debug_helper(loc, 0, target, index, data)                                        }
-	GetDoublei_v              :: #force_inline proc "c" (target: u32, index: u32, data: ^f64, loc := #caller_location)                                          {        impl_GetDoublei_v(target, index, data);                                       debug_helper(loc, 0, target, index, data)                                        }
+	ReleaseShaderCompiler     :: proc "c" (loc := #caller_location)                                                                               {        impl_ReleaseShaderCompiler();                                                 debug_helper(loc, 0)                                                             }
+	ShaderBinary              :: proc "c" (count: i32, shaders: ^u32, binaryformat: u32, binary: rawptr, length: i32, loc := #caller_location)    {        impl_ShaderBinary(count, shaders, binaryformat, binary, length);              debug_helper(loc, 0, count, shaders, binaryformat, binary, length)               }
+	GetShaderPrecisionFormat  :: proc "c" (shadertype: u32, precisiontype: u32, range: ^i32, precision: ^i32, loc := #caller_location)            {        impl_GetShaderPrecisionFormat(shadertype, precisiontype, range, precision); debug_helper(loc, 0, shadertype, precisiontype, range, precision)              }
+	DepthRangef               :: proc "c" (n: f32, f: f32, loc := #caller_location)                                                               {        impl_DepthRangef(n, f);                                                       debug_helper(loc, 0, n, f)                                                       }
+	ClearDepthf               :: proc "c" (d: f32, loc := #caller_location)                                                                       {        impl_ClearDepthf(d);                                                          debug_helper(loc, 0, d)                                                          }
+	GetProgramBinary          :: proc "c" (program: u32, bufSize: i32, length: ^i32, binaryFormat: ^u32, binary: rawptr, loc := #caller_location) {        impl_GetProgramBinary(program, bufSize, length, binaryFormat, binary);        debug_helper(loc, 0, program, bufSize, length, binaryFormat, binary)             }
+	ProgramBinary             :: proc "c" (program: u32, binaryFormat: u32, binary: rawptr, length: i32, loc := #caller_location)                 {        impl_ProgramBinary(program, binaryFormat, binary, length);                    debug_helper(loc, 0, program, binaryFormat, binary, length)                      }
+	ProgramParameteri         :: proc "c" (program: u32, pname: u32, value: i32, loc := #caller_location)                                         {        impl_ProgramParameteri(program, pname, value);                                debug_helper(loc, 0, program, pname, value)                                      }
+	UseProgramStages          :: proc "c" (pipeline: u32, stages: u32, program: u32, loc := #caller_location)                                     {        impl_UseProgramStages(pipeline, stages, program);                             debug_helper(loc, 0, pipeline, stages, program)                                  }
+	ActiveShaderProgram       :: proc "c" (pipeline: u32, program: u32, loc := #caller_location)                                                  {        impl_ActiveShaderProgram(pipeline, program);                                  debug_helper(loc, 0, pipeline, program)                                          }
+	CreateShaderProgramv      :: proc "c" (type: u32, count: i32, strings: [^]cstring, loc := #caller_location) -> u32                            { ret := impl_CreateShaderProgramv(type, count, strings);                             debug_helper(loc, 1, ret, type, count, strings);                    return ret }
+	BindProgramPipeline       :: proc "c" (pipeline: u32, loc := #caller_location)                                                                {        impl_BindProgramPipeline(pipeline);                                           debug_helper(loc, 0, pipeline)                                                   }
+	DeleteProgramPipelines    :: proc "c" (n: i32, pipelines: [^]u32, loc := #caller_location)                                                    {        impl_DeleteProgramPipelines(n, pipelines);                                    debug_helper(loc, 0, n, pipelines)                                               }
+	GenProgramPipelines       :: proc "c" (n: i32, pipelines: [^]u32, loc := #caller_location)                                                    {        impl_GenProgramPipelines(n, pipelines);                                       debug_helper(loc, 0, n, pipelines)                                               }
+	IsProgramPipeline         :: proc "c" (pipeline: u32, loc := #caller_location) -> bool                                                        { ret := impl_IsProgramPipeline(pipeline);                                             debug_helper(loc, 1, ret, pipeline);                                 return ret }
+	GetProgramPipelineiv      :: proc "c" (pipeline: u32, pname: u32, params: [^]i32, loc := #caller_location)                                    {        impl_GetProgramPipelineiv(pipeline, pname, params);                           debug_helper(loc, 0, pipeline, pname, params)                                    }
+	ProgramUniform1i          :: proc "c" (program: u32, location: i32, v0: i32, loc := #caller_location)                                         {        impl_ProgramUniform1i(program, location, v0);                                 debug_helper(loc, 0, program, location, v0)                                      }
+	ProgramUniform1iv         :: proc "c" (program: u32, location: i32, count: i32, value: [^]i32, loc := #caller_location)                       {        impl_ProgramUniform1iv(program, location, count, value);                      debug_helper(loc, 0, program, location, count, value)                            }
+	ProgramUniform1f          :: proc "c" (program: u32, location: i32, v0: f32, loc := #caller_location)                                         {        impl_ProgramUniform1f(program, location, v0);                                 debug_helper(loc, 0, program, location, v0)                                      }
+	ProgramUniform1fv         :: proc "c" (program: u32, location: i32, count: i32, value: [^]f32, loc := #caller_location)                       {        impl_ProgramUniform1fv(program, location, count, value);                      debug_helper(loc, 0, program, location, count, value)                            }
+	ProgramUniform1d          :: proc "c" (program: u32, location: i32, v0: f64, loc := #caller_location)                                         {        impl_ProgramUniform1d(program, location, v0);                                 debug_helper(loc, 0, program, location, v0)                                      }
+	ProgramUniform1dv         :: proc "c" (program: u32, location: i32, count: i32, value: [^]f64, loc := #caller_location)                       {        impl_ProgramUniform1dv(program, location, count, value);                      debug_helper(loc, 0, program, location, count, value)                            }
+	ProgramUniform1ui         :: proc "c" (program: u32, location: i32, v0: u32, loc := #caller_location)                                         {        impl_ProgramUniform1ui(program, location, v0);                                debug_helper(loc, 0, program, location, v0)                                      }
+	ProgramUniform1uiv        :: proc "c" (program: u32, location: i32, count: i32, value: [^]u32, loc := #caller_location)                       {        impl_ProgramUniform1uiv(program, location, count, value);                     debug_helper(loc, 0, program, location, count, value)                            }
+	ProgramUniform2i          :: proc "c" (program: u32, location: i32, v0: i32, v1: i32, loc := #caller_location)                                {        impl_ProgramUniform2i(program, location, v0, v1);                             debug_helper(loc, 0, program, location, v0, v1)                                  }
+	ProgramUniform2iv         :: proc "c" (program: u32, location: i32, count: i32, value: [^]i32, loc := #caller_location)                       {        impl_ProgramUniform2iv(program, location, count, value);                      debug_helper(loc, 0, program, location, count, value)                            }
+	ProgramUniform2f          :: proc "c" (program: u32, location: i32, v0: f32, v1: f32, loc := #caller_location)                                {        impl_ProgramUniform2f(program, location, v0, v1);                             debug_helper(loc, 0, program, location, v0, v1)                                  }
+	ProgramUniform2fv         :: proc "c" (program: u32, location: i32, count: i32, value: [^]f32, loc := #caller_location)                       {        impl_ProgramUniform2fv(program, location, count, value);                      debug_helper(loc, 0, program, location, count, value)                            }
+	ProgramUniform2d          :: proc "c" (program: u32, location: i32, v0: f64, v1: f64, loc := #caller_location)                                {        impl_ProgramUniform2d(program, location, v0, v1);                             debug_helper(loc, 0, program, location, v0, v1)                                  }
+	ProgramUniform2dv         :: proc "c" (program: u32, location: i32, count: i32, value: [^]f64, loc := #caller_location)                       {        impl_ProgramUniform2dv(program, location, count, value);                      debug_helper(loc, 0, program, location, count, value)                            }
+	ProgramUniform2ui         :: proc "c" (program: u32, location: i32, v0: u32, v1: u32, loc := #caller_location)                                {        impl_ProgramUniform2ui(program, location, v0, v1);                            debug_helper(loc, 0, program, location, v0, v1)                                  }
+	ProgramUniform2uiv        :: proc "c" (program: u32, location: i32, count: i32, value: [^]u32, loc := #caller_location)                       {        impl_ProgramUniform2uiv(program, location, count, value);                     debug_helper(loc, 0, program, location, count, value)                            }
+	ProgramUniform3i          :: proc "c" (program: u32, location: i32, v0: i32, v1: i32, v2: i32, loc := #caller_location)                       {        impl_ProgramUniform3i(program, location, v0, v1, v2);                         debug_helper(loc, 0, program, location, v0, v1, v2)                              }
+	ProgramUniform3iv         :: proc "c" (program: u32, location: i32, count: i32, value: [^]i32, loc := #caller_location)                       {        impl_ProgramUniform3iv(program, location, count, value);                      debug_helper(loc, 0, program, location, count, value)                            }
+	ProgramUniform3f          :: proc "c" (program: u32, location: i32, v0: f32, v1: f32, v2: f32, loc := #caller_location)                       {        impl_ProgramUniform3f(program, location, v0, v1, v2);                         debug_helper(loc, 0, program, location, v0, v1, v2)                              }
+	ProgramUniform3fv         :: proc "c" (program: u32, location: i32, count: i32, value: [^]f32, loc := #caller_location)                       {        impl_ProgramUniform3fv(program, location, count, value);                      debug_helper(loc, 0, program, location, count, value)                            }
+	ProgramUniform3d          :: proc "c" (program: u32, location: i32, v0: f64, v1: f64, v2: f64, loc := #caller_location)                       {        impl_ProgramUniform3d(program, location, v0, v1, v2);                         debug_helper(loc, 0, program, location, v0, v1, v2)                              }
+	ProgramUniform3dv         :: proc "c" (program: u32, location: i32, count: i32, value: [^]f64, loc := #caller_location)                       {        impl_ProgramUniform3dv(program, location, count, value);                      debug_helper(loc, 0, program, location, count, value)                            }
+	ProgramUniform3ui         :: proc "c" (program: u32, location: i32, v0: u32, v1: u32, v2: u32, loc := #caller_location)                       {        impl_ProgramUniform3ui(program, location, v0, v1, v2);                        debug_helper(loc, 0, program, location, v0, v1, v2)                              }
+	ProgramUniform3uiv        :: proc "c" (program: u32, location: i32, count: i32, value: [^]u32, loc := #caller_location)                       {        impl_ProgramUniform3uiv(program, location, count, value);                     debug_helper(loc, 0, program, location, count, value)                            }
+	ProgramUniform4i          :: proc "c" (program: u32, location: i32, v0: i32, v1: i32, v2: i32, v3: i32, loc := #caller_location)              {        impl_ProgramUniform4i(program, location, v0, v1, v2, v3);                     debug_helper(loc, 0, program, location, v0, v1, v2, v3)                          }
+	ProgramUniform4iv         :: proc "c" (program: u32, location: i32, count: i32, value: [^]i32, loc := #caller_location)                       {        impl_ProgramUniform4iv(program, location, count, value);                      debug_helper(loc, 0, program, location, count, value)                            }
+	ProgramUniform4f          :: proc "c" (program: u32, location: i32, v0: f32, v1: f32, v2: f32, v3: f32, loc := #caller_location)              {        impl_ProgramUniform4f(program, location, v0, v1, v2, v3);                     debug_helper(loc, 0, program, location, v0, v1, v2, v3)                          }
+	ProgramUniform4fv         :: proc "c" (program: u32, location: i32, count: i32, value: [^]f32, loc := #caller_location)                       {        impl_ProgramUniform4fv(program, location, count, value);                      debug_helper(loc, 0, program, location, count, value)                            }
+	ProgramUniform4d          :: proc "c" (program: u32, location: i32, v0: f64, v1: f64, v2: f64, v3: f64, loc := #caller_location)              {        impl_ProgramUniform4d(program, location, v0, v1, v2, v3);                     debug_helper(loc, 0, program, location, v0, v1, v2, v3)                          }
+	ProgramUniform4dv         :: proc "c" (program: u32, location: i32, count: i32, value: [^]f64, loc := #caller_location)                       {        impl_ProgramUniform4dv(program, location, count, value);                      debug_helper(loc, 0, program, location, count, value)                            }
+	ProgramUniform4ui         :: proc "c" (program: u32, location: i32, v0: u32, v1: u32, v2: u32, v3: u32, loc := #caller_location)              {        impl_ProgramUniform4ui(program, location, v0, v1, v2, v3);                    debug_helper(loc, 0, program, location, v0, v1, v2, v3)                          }
+	ProgramUniform4uiv        :: proc "c" (program: u32, location: i32, count: i32, value: [^]u32, loc := #caller_location)                       {        impl_ProgramUniform4uiv(program, location, count, value);                     debug_helper(loc, 0, program, location, count, value)                            }
+	ProgramUniformMatrix2fv   :: proc "c" (program: u32, location: i32, count: i32, transpose: bool, value: [^]f32, loc := #caller_location)      {        impl_ProgramUniformMatrix2fv(program, location, count, transpose, value);     debug_helper(loc, 0, program, location, count, transpose, value)                 }
+	ProgramUniformMatrix3fv   :: proc "c" (program: u32, location: i32, count: i32, transpose: bool, value: [^]f32, loc := #caller_location)      {        impl_ProgramUniformMatrix3fv(program, location, count, transpose, value);     debug_helper(loc, 0, program, location, count, transpose, value)                 }
+	ProgramUniformMatrix4fv   :: proc "c" (program: u32, location: i32, count: i32, transpose: bool, value: [^]f32, loc := #caller_location)      {        impl_ProgramUniformMatrix4fv(program, location, count, transpose, value);     debug_helper(loc, 0, program, location, count, transpose, value)                 }
+	ProgramUniformMatrix2dv   :: proc "c" (program: u32, location: i32, count: i32, transpose: bool, value: [^]f64, loc := #caller_location)      {        impl_ProgramUniformMatrix2dv(program, location, count, transpose, value);     debug_helper(loc, 0, program, location, count, transpose, value)                 }
+	ProgramUniformMatrix3dv   :: proc "c" (program: u32, location: i32, count: i32, transpose: bool, value: [^]f64, loc := #caller_location)      {        impl_ProgramUniformMatrix3dv(program, location, count, transpose, value);     debug_helper(loc, 0, program, location, count, transpose, value)                 }
+	ProgramUniformMatrix4dv   :: proc "c" (program: u32, location: i32, count: i32, transpose: bool, value: [^]f64, loc := #caller_location)      {        impl_ProgramUniformMatrix4dv(program, location, count, transpose, value);     debug_helper(loc, 0, program, location, count, transpose, value)                 }
+	ProgramUniformMatrix2x3fv :: proc "c" (program: u32, location: i32, count: i32, transpose: bool, value: [^]f32, loc := #caller_location)      {        impl_ProgramUniformMatrix2x3fv(program, location, count, transpose, value);   debug_helper(loc, 0, program, location, count, transpose, value)                 }
+	ProgramUniformMatrix3x2fv :: proc "c" (program: u32, location: i32, count: i32, transpose: bool, value: [^]f32, loc := #caller_location)      {        impl_ProgramUniformMatrix3x2fv(program, location, count, transpose, value);   debug_helper(loc, 0, program, location, count, transpose, value)                 }
+	ProgramUniformMatrix2x4fv :: proc "c" (program: u32, location: i32, count: i32, transpose: bool, value: [^]f32, loc := #caller_location)      {        impl_ProgramUniformMatrix2x4fv(program, location, count, transpose, value);   debug_helper(loc, 0, program, location, count, transpose, value)                 }
+	ProgramUniformMatrix4x2fv :: proc "c" (program: u32, location: i32, count: i32, transpose: bool, value: [^]f32, loc := #caller_location)      {        impl_ProgramUniformMatrix4x2fv(program, location, count, transpose, value);   debug_helper(loc, 0, program, location, count, transpose, value)                 }
+	ProgramUniformMatrix3x4fv :: proc "c" (program: u32, location: i32, count: i32, transpose: bool, value: [^]f32, loc := #caller_location)      {        impl_ProgramUniformMatrix3x4fv(program, location, count, transpose, value);   debug_helper(loc, 0, program, location, count, transpose, value)                 }
+	ProgramUniformMatrix4x3fv :: proc "c" (program: u32, location: i32, count: i32, transpose: bool, value: [^]f32, loc := #caller_location)      {        impl_ProgramUniformMatrix4x3fv(program, location, count, transpose, value);   debug_helper(loc, 0, program, location, count, transpose, value)                 }
+	ProgramUniformMatrix2x3dv :: proc "c" (program: u32, location: i32, count: i32, transpose: bool, value: [^]f64, loc := #caller_location)      {        impl_ProgramUniformMatrix2x3dv(program, location, count, transpose, value);   debug_helper(loc, 0, program, location, count, transpose, value)                 }
+	ProgramUniformMatrix3x2dv :: proc "c" (program: u32, location: i32, count: i32, transpose: bool, value: [^]f64, loc := #caller_location)      {        impl_ProgramUniformMatrix3x2dv(program, location, count, transpose, value);   debug_helper(loc, 0, program, location, count, transpose, value)                 }
+	ProgramUniformMatrix2x4dv :: proc "c" (program: u32, location: i32, count: i32, transpose: bool, value: [^]f64, loc := #caller_location)      {        impl_ProgramUniformMatrix2x4dv(program, location, count, transpose, value);   debug_helper(loc, 0, program, location, count, transpose, value)                 }
+	ProgramUniformMatrix4x2dv :: proc "c" (program: u32, location: i32, count: i32, transpose: bool, value: [^]f64, loc := #caller_location)      {        impl_ProgramUniformMatrix4x2dv(program, location, count, transpose, value);   debug_helper(loc, 0, program, location, count, transpose, value)                 }
+	ProgramUniformMatrix3x4dv :: proc "c" (program: u32, location: i32, count: i32, transpose: bool, value: [^]f64, loc := #caller_location)      {        impl_ProgramUniformMatrix3x4dv(program, location, count, transpose, value);   debug_helper(loc, 0, program, location, count, transpose, value)                 }
+	ProgramUniformMatrix4x3dv :: proc "c" (program: u32, location: i32, count: i32, transpose: bool, value: [^]f64, loc := #caller_location)      {        impl_ProgramUniformMatrix4x3dv(program, location, count, transpose, value);   debug_helper(loc, 0, program, location, count, transpose, value)                 }
+	ValidateProgramPipeline   :: proc "c" (pipeline: u32, loc := #caller_location)                                                                {        impl_ValidateProgramPipeline(pipeline);                                       debug_helper(loc, 0, pipeline)                                                   }
+	GetProgramPipelineInfoLog :: proc "c" (pipeline: u32, bufSize: i32, length: ^i32, infoLog: [^]u8, loc := #caller_location)                    {        impl_GetProgramPipelineInfoLog(pipeline, bufSize, length, infoLog);           debug_helper(loc, 0, pipeline, bufSize, length, infoLog)                         }
+	VertexAttribL1d           :: proc "c" (index: u32, x: f64, loc := #caller_location)                                                           {        impl_VertexAttribL1d(index, x);                                               debug_helper(loc, 0, index, x)                                                   }
+	VertexAttribL2d           :: proc "c" (index: u32, x: f64, y: f64, loc := #caller_location)                                                   {        impl_VertexAttribL2d(index, x, y);                                            debug_helper(loc, 0, index, x, y)                                                }
+	VertexAttribL3d           :: proc "c" (index: u32, x: f64, y: f64, z: f64, loc := #caller_location)                                           {        impl_VertexAttribL3d(index, x, y, z);                                         debug_helper(loc, 0, index, x, y, z)                                             }
+	VertexAttribL4d           :: proc "c" (index: u32, x: f64, y: f64, z: f64, w: f64, loc := #caller_location)                                   {        impl_VertexAttribL4d(index, x, y, z, w);                                      debug_helper(loc, 0, index, x, y, z, w)                                          }
+	VertexAttribL1dv          :: proc "c" (index: u32, v: ^f64, loc := #caller_location)                                                          {        impl_VertexAttribL1dv(index, v);                                              debug_helper(loc, 0, index, v)                                                   }
+	VertexAttribL2dv          :: proc "c" (index: u32, v: ^[2]f64, loc := #caller_location)                                                          {        impl_VertexAttribL2dv(index, v);                                              debug_helper(loc, 0, index, v)                                                   }
+	VertexAttribL3dv          :: proc "c" (index: u32, v: ^[3]f64, loc := #caller_location)                                                          {        impl_VertexAttribL3dv(index, v);                                              debug_helper(loc, 0, index, v)                                                   }
+	VertexAttribL4dv          :: proc "c" (index: u32, v: ^[4]f64, loc := #caller_location)                                                          {        impl_VertexAttribL4dv(index, v);                                              debug_helper(loc, 0, index, v)                                                   }
+	VertexAttribLPointer      :: proc "c" (index: u32, size: i32, type: u32, stride: i32, pointer: uintptr, loc := #caller_location)               {        impl_VertexAttribLPointer(index, size, type, stride, pointer);               debug_helper(loc, 0, index, size, type, stride, pointer)                        }
+	GetVertexAttribLdv        :: proc "c" (index: u32, pname: u32, params: [^]f64, loc := #caller_location)                                       {        impl_GetVertexAttribLdv(index, pname, params);                                debug_helper(loc, 0, index, pname, params)                                       }
+	ViewportArrayv            :: proc "c" (first: u32, count: i32, v: [^]f32, loc := #caller_location)                                            {        impl_ViewportArrayv(first, count, v);                                         debug_helper(loc, 0, first, count, v)                                            }
+	ViewportIndexedf          :: proc "c" (index: u32, x: f32, y: f32, w: f32, h: f32, loc := #caller_location)                                   {        impl_ViewportIndexedf(index, x, y, w, h);                                     debug_helper(loc, 0, index, x, y, w, h)                                          }
+	ViewportIndexedfv         :: proc "c" (index: u32, v: ^[4]f32, loc := #caller_location)                                                          {        impl_ViewportIndexedfv(index, v);                                             debug_helper(loc, 0, index, v)                                                   }
+	ScissorArrayv             :: proc "c" (first: u32, count: i32, v: [^]i32, loc := #caller_location)                                            {        impl_ScissorArrayv(first, count, v);                                          debug_helper(loc, 0, first, count, v)                                            }
+	ScissorIndexed            :: proc "c" (index: u32, left: i32, bottom: i32, width: i32, height: i32, loc := #caller_location)                  {        impl_ScissorIndexed(index, left, bottom, width, height);                      debug_helper(loc, 0, index, left, bottom, width, height)                         }
+	ScissorIndexedv           :: proc "c" (index: u32, v: ^[4]i32, loc := #caller_location)                                                          {        impl_ScissorIndexedv(index, v);                                               debug_helper(loc, 0, index, v)                                                   }
+	DepthRangeArrayv          :: proc "c" (first: u32, count: i32, v: [^]f64, loc := #caller_location)                                            {        impl_DepthRangeArrayv(first, count, v);                                       debug_helper(loc, 0, first, count, v)                                            }
+	DepthRangeIndexed         :: proc "c" (index: u32, n: f64, f: f64, loc := #caller_location)                                                   {        impl_DepthRangeIndexed(index, n, f);                                          debug_helper(loc, 0, index, n, f)                                                }
+	GetFloati_v               :: proc "c" (target: u32, index: u32, data: ^f32, loc := #caller_location)                                          {        impl_GetFloati_v(target, index, data);                                        debug_helper(loc, 0, target, index, data)                                        }
+	GetDoublei_v              :: proc "c" (target: u32, index: u32, data: ^f64, loc := #caller_location)                                          {        impl_GetDoublei_v(target, index, data);                                       debug_helper(loc, 0, target, index, data)                                        }
 
 	// VERSION_4_2
-	DrawArraysInstancedBaseInstance             :: #force_inline proc "c" (mode: u32, first: i32, count: i32, instancecount: i32, baseinstance: u32, loc := #caller_location)                                  { impl_DrawArraysInstancedBaseInstance(mode, first, count, instancecount, baseinstance);                                  debug_helper(loc, 0, mode, first, count, instancecount, baseinstance)                      }
-	DrawElementsInstancedBaseInstance           :: #force_inline proc "c" (mode: u32, count: i32, type: u32, indices: rawptr, instancecount: i32, baseinstance: u32, loc := #caller_location)                  { impl_DrawElementsInstancedBaseInstance(mode, count, type, indices, instancecount, baseinstance);                       debug_helper(loc, 0, mode, count, type, indices, instancecount, baseinstance)             }
-	DrawElementsInstancedBaseVertexBaseInstance :: #force_inline proc "c" (mode: u32, count: i32, type: u32, indices: rawptr, instancecount: i32, basevertex: i32, baseinstance: u32, loc := #caller_location) { impl_DrawElementsInstancedBaseVertexBaseInstance(mode, count, type, indices, instancecount, basevertex, baseinstance); debug_helper(loc, 0, mode, count, type, indices, instancecount, basevertex, baseinstance) }
-	GetInternalformativ                         :: #force_inline proc "c" (target: u32, internalformat: u32, pname: u32, bufSize: i32, params: [^]i32, loc := #caller_location)                                { impl_GetInternalformativ(target, internalformat, pname, bufSize, params);                                               debug_helper(loc, 0, target, internalformat, pname, bufSize, params)                       }
-	GetActiveAtomicCounterBufferiv              :: #force_inline proc "c" (program: u32, bufferIndex: u32, pname: u32, params: [^]i32, loc := #caller_location)                                                { impl_GetActiveAtomicCounterBufferiv(program, bufferIndex, pname, params);                                               debug_helper(loc, 0, program, bufferIndex, pname, params)                                  }
-	BindImageTexture                            :: #force_inline proc "c" (unit: u32, texture: u32, level: i32, layered: bool, layer: i32, access: u32, format: u32, loc := #caller_location)                  { impl_BindImageTexture(unit, texture, level, layered, layer, access, format);                                            debug_helper(loc, 0, unit, texture, level, layered, layer, access, format)                 }
-	MemoryBarrier                               :: #force_inline proc "c" (barriers: u32, loc := #caller_location)                                                                                             { impl_MemoryBarrier(barriers);                                                                                           debug_helper(loc, 0, barriers)                                                             }
-	TexStorage1D                                :: #force_inline proc "c" (target: u32, levels: i32, internalformat: u32, width: i32, loc := #caller_location)                                                 { impl_TexStorage1D(target, levels, internalformat, width);                                                               debug_helper(loc, 0, target, levels, internalformat, width)                                }
-	TexStorage2D                                :: #force_inline proc "c" (target: u32, levels: i32, internalformat: u32, width: i32, height: i32, loc := #caller_location)                                    { impl_TexStorage2D(target, levels, internalformat, width, height);                                                       debug_helper(loc, 0, target, levels, internalformat, width, height)                        }
-	TexStorage3D                                :: #force_inline proc "c" (target: u32, levels: i32, internalformat: u32, width: i32, height: i32, depth: i32, loc := #caller_location)                        { impl_TexStorage3D(target, levels, internalformat, width, height, depth);                                                debug_helper(loc, 0, target, levels, internalformat, width, height, depth)                 }
-	DrawTransformFeedbackInstanced              :: #force_inline proc "c" (mode: u32, id: u32, instancecount: i32, loc := #caller_location)                                                                    { impl_DrawTransformFeedbackInstanced(mode, id, instancecount);                                                           debug_helper(loc, 0, mode, id, instancecount)                                              }
-	DrawTransformFeedbackStreamInstanced        :: #force_inline proc "c" (mode: u32, id: u32, stream: u32, instancecount: i32, loc := #caller_location)                                                       { impl_DrawTransformFeedbackStreamInstanced(mode, id, stream, instancecount);                                             debug_helper(loc, 0, mode, id, stream, instancecount)                                      }
+	DrawArraysInstancedBaseInstance             :: proc "c" (mode: u32, first: i32, count: i32, instancecount: i32, baseinstance: u32, loc := #caller_location)                                  { impl_DrawArraysInstancedBaseInstance(mode, first, count, instancecount, baseinstance);                                  debug_helper(loc, 0, mode, first, count, instancecount, baseinstance)                      }
+	DrawElementsInstancedBaseInstance           :: proc "c" (mode: u32, count: i32, type: u32, indices: rawptr, instancecount: i32, baseinstance: u32, loc := #caller_location)                  { impl_DrawElementsInstancedBaseInstance(mode, count, type, indices, instancecount, baseinstance);                       debug_helper(loc, 0, mode, count, type, indices, instancecount, baseinstance)             }
+	DrawElementsInstancedBaseVertexBaseInstance :: proc "c" (mode: u32, count: i32, type: u32, indices: rawptr, instancecount: i32, basevertex: i32, baseinstance: u32, loc := #caller_location) { impl_DrawElementsInstancedBaseVertexBaseInstance(mode, count, type, indices, instancecount, basevertex, baseinstance); debug_helper(loc, 0, mode, count, type, indices, instancecount, basevertex, baseinstance) }
+	GetInternalformativ                         :: proc "c" (target: u32, internalformat: u32, pname: u32, bufSize: i32, params: [^]i32, loc := #caller_location)                                { impl_GetInternalformativ(target, internalformat, pname, bufSize, params);                                               debug_helper(loc, 0, target, internalformat, pname, bufSize, params)                       }
+	GetActiveAtomicCounterBufferiv              :: proc "c" (program: u32, bufferIndex: u32, pname: u32, params: [^]i32, loc := #caller_location)                                                { impl_GetActiveAtomicCounterBufferiv(program, bufferIndex, pname, params);                                               debug_helper(loc, 0, program, bufferIndex, pname, params)                                  }
+	BindImageTexture                            :: proc "c" (unit: u32, texture: u32, level: i32, layered: bool, layer: i32, access: u32, format: u32, loc := #caller_location)                  { impl_BindImageTexture(unit, texture, level, layered, layer, access, format);                                            debug_helper(loc, 0, unit, texture, level, layered, layer, access, format)                 }
+	MemoryBarrier                               :: proc "c" (barriers: u32, loc := #caller_location)                                                                                             { impl_MemoryBarrier(barriers);                                                                                           debug_helper(loc, 0, barriers)                                                             }
+	TexStorage1D                                :: proc "c" (target: u32, levels: i32, internalformat: u32, width: i32, loc := #caller_location)                                                 { impl_TexStorage1D(target, levels, internalformat, width);                                                               debug_helper(loc, 0, target, levels, internalformat, width)                                }
+	TexStorage2D                                :: proc "c" (target: u32, levels: i32, internalformat: u32, width: i32, height: i32, loc := #caller_location)                                    { impl_TexStorage2D(target, levels, internalformat, width, height);                                                       debug_helper(loc, 0, target, levels, internalformat, width, height)                        }
+	TexStorage3D                                :: proc "c" (target: u32, levels: i32, internalformat: u32, width: i32, height: i32, depth: i32, loc := #caller_location)                        { impl_TexStorage3D(target, levels, internalformat, width, height, depth);                                                debug_helper(loc, 0, target, levels, internalformat, width, height, depth)                 }
+	DrawTransformFeedbackInstanced              :: proc "c" (mode: u32, id: u32, instancecount: i32, loc := #caller_location)                                                                    { impl_DrawTransformFeedbackInstanced(mode, id, instancecount);                                                           debug_helper(loc, 0, mode, id, instancecount)                                              }
+	DrawTransformFeedbackStreamInstanced        :: proc "c" (mode: u32, id: u32, stream: u32, instancecount: i32, loc := #caller_location)                                                       { impl_DrawTransformFeedbackStreamInstanced(mode, id, stream, instancecount);                                             debug_helper(loc, 0, mode, id, stream, instancecount)                                      }
 
 	// VERSION_4_3
-	ClearBufferData                 :: #force_inline proc "c" (target: u32, internalformat: u32, format: u32, type: u32, data: rawptr, loc := #caller_location)                                                                                                                                   {        impl_ClearBufferData(target, internalformat, format, type, data);                                                                                    debug_helper(loc, 0, target, internalformat, format, type, data)                                                                                               }
-	ClearBufferSubData              :: #force_inline proc "c" (target: u32, internalformat: u32, offset: int, size: int, format: u32, type: u32, data: rawptr, loc := #caller_location)                                                                                                           {        impl_ClearBufferSubData(target, internalformat, offset, size, format, type, data);                                                                   debug_helper(loc, 0, target, internalformat, offset, size, format, type, data)                                                                                 }
-	DispatchCompute                 :: #force_inline proc "c" (num_groups_x: u32, num_groups_y: u32, num_groups_z: u32, loc := #caller_location)                                                                                                                                                  {        impl_DispatchCompute(num_groups_x, num_groups_y, num_groups_z);                                                                                       debug_helper(loc, 0, num_groups_x, num_groups_y, num_groups_z)                                                                                                  }
-	DispatchComputeIndirect         :: #force_inline proc "c" (indirect: ^DispatchIndirectCommand, loc := #caller_location)                                                                                                                                                                       {        impl_DispatchComputeIndirect(indirect);                                                                                                               debug_helper(loc, 0, indirect)                                                                                                                                  }
-	CopyImageSubData                :: #force_inline proc "c" (srcName: u32, srcTarget: u32, srcLevel: i32, srcX: i32, srcY: i32, srcZ: i32, dstName: u32, dstTarget: u32, dstLevel: i32, dstX: i32, dstY: i32, dstZ: i32, srcWidth: i32, srcHeight: i32, srcDepth: i32, loc := #caller_location) {        impl_CopyImageSubData(srcName, srcTarget, srcLevel, srcX, srcY, srcZ, dstName, dstTarget, dstLevel, dstX, dstY, dstZ, srcWidth, srcHeight, srcDepth); debug_helper(loc, 0, srcName, srcTarget, srcLevel, srcX, srcY, srcZ, dstName, dstTarget, dstLevel, dstX, dstY, dstZ, srcWidth, srcHeight, srcDepth)             }
-	FramebufferParameteri           :: #force_inline proc "c" (target: u32, pname: u32, param: i32, loc := #caller_location)                                                                                                                                                                      {        impl_FramebufferParameteri(target, pname, param);                                                                                                     debug_helper(loc, 0, target, pname, param)                                                                                                                      }
-	GetFramebufferParameteriv       :: #force_inline proc "c" (target: u32, pname: u32, params: [^]i32, loc := #caller_location)                                                                                                                                                                  {        impl_GetFramebufferParameteriv(target, pname, params);                                                                                                debug_helper(loc, 0, target, pname, params)                                                                                                                     }
-	GetInternalformati64v           :: #force_inline proc "c" (target: u32, internalformat: u32, pname: u32, bufSize: i32, params: [^]i64, loc := #caller_location)                                                                                                                               {        impl_GetInternalformati64v(target, internalformat, pname, bufSize, params);                                                                           debug_helper(loc, 0, target, internalformat, pname, bufSize, params)                                                                                            }
-	InvalidateTexSubImage           :: #force_inline proc "c" (texture: u32, level: i32, xoffset: i32, yoffset: i32, zoffset: i32, width: i32, height: i32, depth: i32, loc := #caller_location)                                                                                                  {        impl_InvalidateTexSubImage(texture, level, xoffset, yoffset, zoffset, width, height, depth);                                                          debug_helper(loc, 0, texture, level, xoffset, yoffset, zoffset, width, height, depth)                                                                           }
-	InvalidateTexImage              :: #force_inline proc "c" (texture: u32, level: i32, loc := #caller_location)                                                                                                                                                                                 {        impl_InvalidateTexImage(texture, level);                                                                                                              debug_helper(loc, 0, texture, level)                                                                                                                            }
-	InvalidateBufferSubData         :: #force_inline proc "c" (buffer: u32, offset: int, length: int, loc := #caller_location)                                                                                                                                                                    {        impl_InvalidateBufferSubData(buffer, offset, length);                                                                                                 debug_helper(loc, 0, buffer, offset, length)                                                                                                                    }
-	InvalidateBufferData            :: #force_inline proc "c" (buffer: u32, loc := #caller_location)                                                                                                                                                                                              {        impl_InvalidateBufferData(buffer);                                                                                                                    debug_helper(loc, 0, buffer)                                                                                                                                    }
-	InvalidateFramebuffer           :: #force_inline proc "c" (target: u32, numAttachments: i32, attachments: [^]u32, loc := #caller_location)                                                                                                                                                    {        impl_InvalidateFramebuffer(target, numAttachments, attachments);                                                                                      debug_helper(loc, 0, target, numAttachments, attachments)                                                                                                       }
-	InvalidateSubFramebuffer        :: #force_inline proc "c" (target: u32, numAttachments: i32, attachments: [^]u32, x: i32, y: i32, width: i32, height: i32, loc := #caller_location)                                                                                                           {        impl_InvalidateSubFramebuffer(target, numAttachments, attachments, x, y, width, height);                                                              debug_helper(loc, 0, target, numAttachments, attachments, x, y, width, height)                                                                                  }
-	MultiDrawArraysIndirect         :: #force_inline proc "c" (mode: u32, indirect: [^]DrawArraysIndirectCommand, drawcount: i32, stride: i32, loc := #caller_location)                                                                                                                           {        impl_MultiDrawArraysIndirect(mode, indirect, drawcount, stride);                                                                                      debug_helper(loc, 0, mode, indirect, drawcount, stride)                                                                                                         }
-	MultiDrawElementsIndirect       :: #force_inline proc "c" (mode: u32, type: u32, indirect: [^]DrawElementsIndirectCommand, drawcount: i32, stride: i32, loc := #caller_location)                                                                                                              {        impl_MultiDrawElementsIndirect(mode, type, indirect, drawcount, stride);                                                                             debug_helper(loc, 0, mode, type, indirect, drawcount, stride)                                                                                                  }
-	GetProgramInterfaceiv           :: #force_inline proc "c" (program: u32, programInterface: u32, pname: u32, params: [^]i32, loc := #caller_location)                                                                                                                                          {        impl_GetProgramInterfaceiv(program, programInterface, pname, params);                                                                                 debug_helper(loc, 0, program, programInterface, pname, params)                                                                                                  }
-	GetProgramResourceIndex         :: #force_inline proc "c" (program: u32, programInterface: u32, name: cstring, loc := #caller_location) -> u32                                                                                                                                                { ret := impl_GetProgramResourceIndex(program, programInterface, name);                                                                                        debug_helper(loc, 1, ret, program, programInterface, name);                                                                                          return ret }
-	GetProgramResourceName          :: #force_inline proc "c" (program: u32, programInterface: u32, index: u32, bufSize: i32, length: ^i32, name: [^]u8, loc := #caller_location)                                                                                                                 {        impl_GetProgramResourceName(program, programInterface, index, bufSize, length, name);                                                                 debug_helper(loc, 0, program, programInterface, index, bufSize, length, name)                                                                                   }
-	GetProgramResourceiv            :: #force_inline proc "c" (program: u32, programInterface: u32, index: u32, propCount: i32, props: [^]u32, bufSize: i32, length: ^i32, params: [^]i32, loc := #caller_location)                                                                               {        impl_GetProgramResourceiv(program, programInterface, index, propCount, props, bufSize, length, params);                                               debug_helper(loc, 0, program, programInterface, index, propCount, props, bufSize, length, params)                                                               }
-	GetProgramResourceLocation      :: #force_inline proc "c" (program: u32, programInterface: u32, name: cstring, loc := #caller_location) -> i32                                                                                                                                                { ret := impl_GetProgramResourceLocation(program, programInterface, name);                                                                                     debug_helper(loc, 1, ret, program, programInterface, name);                                                                                          return ret }
-	GetProgramResourceLocationIndex :: #force_inline proc "c" (program: u32, programInterface: u32, name: cstring, loc := #caller_location) -> i32                                                                                                                                                { ret := impl_GetProgramResourceLocationIndex(program, programInterface, name);                                                                                debug_helper(loc, 1, ret, program, programInterface, name);                                                                                          return ret }
-	ShaderStorageBlockBinding       :: #force_inline proc "c" (program: u32, storageBlockIndex: u32, storageBlockBinding: u32, loc := #caller_location)                                                                                                                                           {        impl_ShaderStorageBlockBinding(program, storageBlockIndex, storageBlockBinding);                                                                      debug_helper(loc, 0, program, storageBlockIndex, storageBlockBinding)                                                                                           }
-	TexBufferRange                  :: #force_inline proc "c" (target: u32, internalformat: u32, buffer: u32, offset: int, size: int, loc := #caller_location)                                                                                                                                    {        impl_TexBufferRange(target, internalformat, buffer, offset, size);                                                                                    debug_helper(loc, 0, target, internalformat, buffer, offset, size)                                                                                              }
-	TexStorage2DMultisample         :: #force_inline proc "c" (target: u32, samples: i32, internalformat: u32, width: i32, height: i32, fixedsamplelocations: bool, loc := #caller_location)                                                                                                        {        impl_TexStorage2DMultisample(target, samples, internalformat, width, height, fixedsamplelocations);                                                   debug_helper(loc, 0, target, samples, internalformat, width, height, fixedsamplelocations)                                                                      }
-	TexStorage3DMultisample         :: #force_inline proc "c" (target: u32, samples: i32, internalformat: u32, width: i32, height: i32, depth: i32, fixedsamplelocations: bool, loc := #caller_location)                                                                                            {        impl_TexStorage3DMultisample(target, samples, internalformat, width, height, depth, fixedsamplelocations);                                            debug_helper(loc, 0, target, samples, internalformat, width, height, depth, fixedsamplelocations)                                                               }
-	TextureView                     :: #force_inline proc "c" (texture: u32, target: u32, origtexture: u32, internalformat: u32, minlevel: u32, numlevels: u32, minlayer: u32, numlayers: u32, loc := #caller_location)                                                                           {        impl_TextureView(texture, target, origtexture, internalformat, minlevel, numlevels, minlayer, numlayers);                                             debug_helper(loc, 0, texture, target, origtexture, internalformat, minlevel, numlevels, minlayer, numlayers)                                                    }
-	BindVertexBuffer                :: #force_inline proc "c" (bindingindex: u32, buffer: u32, offset: int, stride: i32, loc := #caller_location)                                                                                                                                                 {        impl_BindVertexBuffer(bindingindex, buffer, offset, stride);                                                                                          debug_helper(loc, 0, bindingindex, buffer, offset, stride)                                                                                                      }
-	VertexAttribFormat              :: #force_inline proc "c" (attribindex: u32, size: i32, type: u32, normalized: bool, relativeoffset: u32, loc := #caller_location)                                                                                                                            {        impl_VertexAttribFormat(attribindex, size, type, normalized, relativeoffset);                                                                        debug_helper(loc, 0, attribindex, size, type, normalized, relativeoffset)                                                                                      }
-	VertexAttribIFormat             :: #force_inline proc "c" (attribindex: u32, size: i32, type: u32, relativeoffset: u32, loc := #caller_location)                                                                                                                                              {        impl_VertexAttribIFormat(attribindex, size, type, relativeoffset);                                                                                   debug_helper(loc, 0, attribindex, size, type, relativeoffset)                                                                                                  }
-	VertexAttribLFormat             :: #force_inline proc "c" (attribindex: u32, size: i32, type: u32, relativeoffset: u32, loc := #caller_location)                                                                                                                                              {        impl_VertexAttribLFormat(attribindex, size, type, relativeoffset);                                                                                   debug_helper(loc, 0, attribindex, size, type, relativeoffset)                                                                                                  }
-	VertexAttribBinding             :: #force_inline proc "c" (attribindex: u32, bindingindex: u32, loc := #caller_location)                                                                                                                                                                      {        impl_VertexAttribBinding(attribindex, bindingindex);                                                                                                  debug_helper(loc, 0, attribindex, bindingindex)                                                                                                                 }
-	VertexBindingDivisor            :: #force_inline proc "c" (bindingindex: u32, divisor: u32, loc := #caller_location)                                                                                                                                                                          {        impl_VertexBindingDivisor(bindingindex, divisor);                                                                                                     debug_helper(loc, 0, bindingindex, divisor)                                                                                                                     }
-	DebugMessageControl             :: #force_inline proc "c" (source: u32, type: u32, severity: u32, count: i32, ids: [^]u32, enabled: bool, loc := #caller_location)                                                                                                                              {        impl_DebugMessageControl(source, type, severity, count, ids, enabled);                                                                               debug_helper(loc, 0, source, type, severity, count, ids, enabled)                                                                                              }
-	DebugMessageInsert              :: #force_inline proc "c" (source: u32, type: u32, id: u32, severity: u32, length: i32, buf: ^u8, loc := #caller_location)                                                                                                                                    {        impl_DebugMessageInsert(source, type, id, severity, length, buf);                                                                                    debug_helper(loc, 0, source, type, id, severity, length, buf)                                                                                                  }
-	DebugMessageCallback            :: #force_inline proc "c" (callback: debug_proc_t, userParam: rawptr, loc := #caller_location)                                                                                                                                                                {        impl_DebugMessageCallback(callback, userParam);                                                                                                       debug_helper(loc, 0, callback, userParam)                                                                                                                       }
-	GetDebugMessageLog              :: #force_inline proc "c" (count: u32, bufSize: i32, sources: [^]u32, types: [^]u32, ids: [^]u32, severities: [^]u32, lengths: [^]i32, messageLog: [^]u8, loc := #caller_location) -> u32                                                                     { ret := impl_GetDebugMessageLog(count, bufSize, sources, types, ids, severities, lengths, messageLog);                                                        debug_helper(loc, 1, ret, count, bufSize, sources, types, ids, severities, lengths, messageLog);                                                     return ret }
-	PushDebugGroup                  :: #force_inline proc "c" (source: u32, id: u32, length: i32, message: cstring, loc := #caller_location)                                                                                                                                                      {        impl_PushDebugGroup(source, id, length, message);                                                                                                     debug_helper(loc, 0, source, id, length, message)                                                                                                               }
-	PopDebugGroup                   :: #force_inline proc "c" (loc := #caller_location)                                                                                                                                                                                                           {        impl_PopDebugGroup();                                                                                                                                 debug_helper(loc, 0)                                                                                                                                            }
-	ObjectLabel                     :: #force_inline proc "c" (identifier: u32, name: u32, length: i32, label: [^]u8, loc := #caller_location)                                                                                                                                                    {        impl_ObjectLabel(identifier, name, length, label);                                                                                                    debug_helper(loc, 0, identifier, name, length, label)                                                                                                           }
-	GetObjectLabel                  :: #force_inline proc "c" (identifier: u32, name: u32, bufSize: i32, length: ^i32, label: [^]u8, loc := #caller_location)                                                                                                                                     {        impl_GetObjectLabel(identifier, name, bufSize, length, label);                                                                                        debug_helper(loc, 0, identifier, name, bufSize, length, label)                                                                                                  }
-	ObjectPtrLabel                  :: #force_inline proc "c" (ptr: rawptr, length: i32, label: [^]u8, loc := #caller_location)                                                                                                                                                                   {        impl_ObjectPtrLabel(ptr, length, label);                                                                                                              debug_helper(loc, 0, ptr, length, label)                                                                                                                        }
-	GetObjectPtrLabel               :: #force_inline proc "c" (ptr: rawptr, bufSize: i32, length: ^i32, label: [^]u8, loc := #caller_location)                                                                                                                                                    {        impl_GetObjectPtrLabel(ptr, bufSize, length, label);                                                                                                  debug_helper(loc, 0, ptr, bufSize, length, label)                                                                                                               }
+	ClearBufferData                 :: proc "c" (target: u32, internalformat: u32, format: u32, type: u32, data: rawptr, loc := #caller_location)                                                                                                                                   {        impl_ClearBufferData(target, internalformat, format, type, data);                                                                                    debug_helper(loc, 0, target, internalformat, format, type, data)                                                                                               }
+	ClearBufferSubData              :: proc "c" (target: u32, internalformat: u32, offset: int, size: int, format: u32, type: u32, data: rawptr, loc := #caller_location)                                                                                                           {        impl_ClearBufferSubData(target, internalformat, offset, size, format, type, data);                                                                   debug_helper(loc, 0, target, internalformat, offset, size, format, type, data)                                                                                 }
+	DispatchCompute                 :: proc "c" (num_groups_x: u32, num_groups_y: u32, num_groups_z: u32, loc := #caller_location)                                                                                                                                                  {        impl_DispatchCompute(num_groups_x, num_groups_y, num_groups_z);                                                                                       debug_helper(loc, 0, num_groups_x, num_groups_y, num_groups_z)                                                                                                  }
+	DispatchComputeIndirect         :: proc "c" (indirect: ^DispatchIndirectCommand, loc := #caller_location)                                                                                                                                                                       {        impl_DispatchComputeIndirect(indirect);                                                                                                               debug_helper(loc, 0, indirect)                                                                                                                                  }
+	CopyImageSubData                :: proc "c" (srcName: u32, srcTarget: u32, srcLevel: i32, srcX: i32, srcY: i32, srcZ: i32, dstName: u32, dstTarget: u32, dstLevel: i32, dstX: i32, dstY: i32, dstZ: i32, srcWidth: i32, srcHeight: i32, srcDepth: i32, loc := #caller_location) {        impl_CopyImageSubData(srcName, srcTarget, srcLevel, srcX, srcY, srcZ, dstName, dstTarget, dstLevel, dstX, dstY, dstZ, srcWidth, srcHeight, srcDepth); debug_helper(loc, 0, srcName, srcTarget, srcLevel, srcX, srcY, srcZ, dstName, dstTarget, dstLevel, dstX, dstY, dstZ, srcWidth, srcHeight, srcDepth)             }
+	FramebufferParameteri           :: proc "c" (target: u32, pname: u32, param: i32, loc := #caller_location)                                                                                                                                                                      {        impl_FramebufferParameteri(target, pname, param);                                                                                                     debug_helper(loc, 0, target, pname, param)                                                                                                                      }
+	GetFramebufferParameteriv       :: proc "c" (target: u32, pname: u32, params: [^]i32, loc := #caller_location)                                                                                                                                                                  {        impl_GetFramebufferParameteriv(target, pname, params);                                                                                                debug_helper(loc, 0, target, pname, params)                                                                                                                     }
+	GetInternalformati64v           :: proc "c" (target: u32, internalformat: u32, pname: u32, bufSize: i32, params: [^]i64, loc := #caller_location)                                                                                                                               {        impl_GetInternalformati64v(target, internalformat, pname, bufSize, params);                                                                           debug_helper(loc, 0, target, internalformat, pname, bufSize, params)                                                                                            }
+	InvalidateTexSubImage           :: proc "c" (texture: u32, level: i32, xoffset: i32, yoffset: i32, zoffset: i32, width: i32, height: i32, depth: i32, loc := #caller_location)                                                                                                  {        impl_InvalidateTexSubImage(texture, level, xoffset, yoffset, zoffset, width, height, depth);                                                          debug_helper(loc, 0, texture, level, xoffset, yoffset, zoffset, width, height, depth)                                                                           }
+	InvalidateTexImage              :: proc "c" (texture: u32, level: i32, loc := #caller_location)                                                                                                                                                                                 {        impl_InvalidateTexImage(texture, level);                                                                                                              debug_helper(loc, 0, texture, level)                                                                                                                            }
+	InvalidateBufferSubData         :: proc "c" (buffer: u32, offset: int, length: int, loc := #caller_location)                                                                                                                                                                    {        impl_InvalidateBufferSubData(buffer, offset, length);                                                                                                 debug_helper(loc, 0, buffer, offset, length)                                                                                                                    }
+	InvalidateBufferData            :: proc "c" (buffer: u32, loc := #caller_location)                                                                                                                                                                                              {        impl_InvalidateBufferData(buffer);                                                                                                                    debug_helper(loc, 0, buffer)                                                                                                                                    }
+	InvalidateFramebuffer           :: proc "c" (target: u32, numAttachments: i32, attachments: [^]u32, loc := #caller_location)                                                                                                                                                    {        impl_InvalidateFramebuffer(target, numAttachments, attachments);                                                                                      debug_helper(loc, 0, target, numAttachments, attachments)                                                                                                       }
+	InvalidateSubFramebuffer        :: proc "c" (target: u32, numAttachments: i32, attachments: [^]u32, x: i32, y: i32, width: i32, height: i32, loc := #caller_location)                                                                                                           {        impl_InvalidateSubFramebuffer(target, numAttachments, attachments, x, y, width, height);                                                              debug_helper(loc, 0, target, numAttachments, attachments, x, y, width, height)                                                                                  }
+	MultiDrawArraysIndirect         :: proc "c" (mode: u32, indirect: [^]DrawArraysIndirectCommand, drawcount: i32, stride: i32, loc := #caller_location)                                                                                                                           {        impl_MultiDrawArraysIndirect(mode, indirect, drawcount, stride);                                                                                      debug_helper(loc, 0, mode, indirect, drawcount, stride)                                                                                                         }
+	MultiDrawElementsIndirect       :: proc "c" (mode: u32, type: u32, indirect: [^]DrawElementsIndirectCommand, drawcount: i32, stride: i32, loc := #caller_location)                                                                                                              {        impl_MultiDrawElementsIndirect(mode, type, indirect, drawcount, stride);                                                                             debug_helper(loc, 0, mode, type, indirect, drawcount, stride)                                                                                                  }
+	GetProgramInterfaceiv           :: proc "c" (program: u32, programInterface: u32, pname: u32, params: [^]i32, loc := #caller_location)                                                                                                                                          {        impl_GetProgramInterfaceiv(program, programInterface, pname, params);                                                                                 debug_helper(loc, 0, program, programInterface, pname, params)                                                                                                  }
+	GetProgramResourceIndex         :: proc "c" (program: u32, programInterface: u32, name: cstring, loc := #caller_location) -> u32                                                                                                                                                { ret := impl_GetProgramResourceIndex(program, programInterface, name);                                                                                        debug_helper(loc, 1, ret, program, programInterface, name);                                                                                          return ret }
+	GetProgramResourceName          :: proc "c" (program: u32, programInterface: u32, index: u32, bufSize: i32, length: ^i32, name: [^]u8, loc := #caller_location)                                                                                                                 {        impl_GetProgramResourceName(program, programInterface, index, bufSize, length, name);                                                                 debug_helper(loc, 0, program, programInterface, index, bufSize, length, name)                                                                                   }
+	GetProgramResourceiv            :: proc "c" (program: u32, programInterface: u32, index: u32, propCount: i32, props: [^]u32, bufSize: i32, length: ^i32, params: [^]i32, loc := #caller_location)                                                                               {        impl_GetProgramResourceiv(program, programInterface, index, propCount, props, bufSize, length, params);                                               debug_helper(loc, 0, program, programInterface, index, propCount, props, bufSize, length, params)                                                               }
+	GetProgramResourceLocation      :: proc "c" (program: u32, programInterface: u32, name: cstring, loc := #caller_location) -> i32                                                                                                                                                { ret := impl_GetProgramResourceLocation(program, programInterface, name);                                                                                     debug_helper(loc, 1, ret, program, programInterface, name);                                                                                          return ret }
+	GetProgramResourceLocationIndex :: proc "c" (program: u32, programInterface: u32, name: cstring, loc := #caller_location) -> i32                                                                                                                                                { ret := impl_GetProgramResourceLocationIndex(program, programInterface, name);                                                                                debug_helper(loc, 1, ret, program, programInterface, name);                                                                                          return ret }
+	ShaderStorageBlockBinding       :: proc "c" (program: u32, storageBlockIndex: u32, storageBlockBinding: u32, loc := #caller_location)                                                                                                                                           {        impl_ShaderStorageBlockBinding(program, storageBlockIndex, storageBlockBinding);                                                                      debug_helper(loc, 0, program, storageBlockIndex, storageBlockBinding)                                                                                           }
+	TexBufferRange                  :: proc "c" (target: u32, internalformat: u32, buffer: u32, offset: int, size: int, loc := #caller_location)                                                                                                                                    {        impl_TexBufferRange(target, internalformat, buffer, offset, size);                                                                                    debug_helper(loc, 0, target, internalformat, buffer, offset, size)                                                                                              }
+	TexStorage2DMultisample         :: proc "c" (target: u32, samples: i32, internalformat: u32, width: i32, height: i32, fixedsamplelocations: bool, loc := #caller_location)                                                                                                        {        impl_TexStorage2DMultisample(target, samples, internalformat, width, height, fixedsamplelocations);                                                   debug_helper(loc, 0, target, samples, internalformat, width, height, fixedsamplelocations)                                                                      }
+	TexStorage3DMultisample         :: proc "c" (target: u32, samples: i32, internalformat: u32, width: i32, height: i32, depth: i32, fixedsamplelocations: bool, loc := #caller_location)                                                                                            {        impl_TexStorage3DMultisample(target, samples, internalformat, width, height, depth, fixedsamplelocations);                                            debug_helper(loc, 0, target, samples, internalformat, width, height, depth, fixedsamplelocations)                                                               }
+	TextureView                     :: proc "c" (texture: u32, target: u32, origtexture: u32, internalformat: u32, minlevel: u32, numlevels: u32, minlayer: u32, numlayers: u32, loc := #caller_location)                                                                           {        impl_TextureView(texture, target, origtexture, internalformat, minlevel, numlevels, minlayer, numlayers);                                             debug_helper(loc, 0, texture, target, origtexture, internalformat, minlevel, numlevels, minlayer, numlayers)                                                    }
+	BindVertexBuffer                :: proc "c" (bindingindex: u32, buffer: u32, offset: int, stride: i32, loc := #caller_location)                                                                                                                                                 {        impl_BindVertexBuffer(bindingindex, buffer, offset, stride);                                                                                          debug_helper(loc, 0, bindingindex, buffer, offset, stride)                                                                                                      }
+	VertexAttribFormat              :: proc "c" (attribindex: u32, size: i32, type: u32, normalized: bool, relativeoffset: u32, loc := #caller_location)                                                                                                                            {        impl_VertexAttribFormat(attribindex, size, type, normalized, relativeoffset);                                                                        debug_helper(loc, 0, attribindex, size, type, normalized, relativeoffset)                                                                                      }
+	VertexAttribIFormat             :: proc "c" (attribindex: u32, size: i32, type: u32, relativeoffset: u32, loc := #caller_location)                                                                                                                                              {        impl_VertexAttribIFormat(attribindex, size, type, relativeoffset);                                                                                   debug_helper(loc, 0, attribindex, size, type, relativeoffset)                                                                                                  }
+	VertexAttribLFormat             :: proc "c" (attribindex: u32, size: i32, type: u32, relativeoffset: u32, loc := #caller_location)                                                                                                                                              {        impl_VertexAttribLFormat(attribindex, size, type, relativeoffset);                                                                                   debug_helper(loc, 0, attribindex, size, type, relativeoffset)                                                                                                  }
+	VertexAttribBinding             :: proc "c" (attribindex: u32, bindingindex: u32, loc := #caller_location)                                                                                                                                                                      {        impl_VertexAttribBinding(attribindex, bindingindex);                                                                                                  debug_helper(loc, 0, attribindex, bindingindex)                                                                                                                 }
+	VertexBindingDivisor            :: proc "c" (bindingindex: u32, divisor: u32, loc := #caller_location)                                                                                                                                                                          {        impl_VertexBindingDivisor(bindingindex, divisor);                                                                                                     debug_helper(loc, 0, bindingindex, divisor)                                                                                                                     }
+	DebugMessageControl             :: proc "c" (source: u32, type: u32, severity: u32, count: i32, ids: [^]u32, enabled: bool, loc := #caller_location)                                                                                                                              {        impl_DebugMessageControl(source, type, severity, count, ids, enabled);                                                                               debug_helper(loc, 0, source, type, severity, count, ids, enabled)                                                                                              }
+	DebugMessageInsert              :: proc "c" (source: u32, type: u32, id: u32, severity: u32, length: i32, buf: ^u8, loc := #caller_location)                                                                                                                                    {        impl_DebugMessageInsert(source, type, id, severity, length, buf);                                                                                    debug_helper(loc, 0, source, type, id, severity, length, buf)                                                                                                  }
+	DebugMessageCallback            :: proc "c" (callback: debug_proc_t, userParam: rawptr, loc := #caller_location)                                                                                                                                                                {        impl_DebugMessageCallback(callback, userParam);                                                                                                       debug_helper(loc, 0, callback, userParam)                                                                                                                       }
+	GetDebugMessageLog              :: proc "c" (count: u32, bufSize: i32, sources: [^]u32, types: [^]u32, ids: [^]u32, severities: [^]u32, lengths: [^]i32, messageLog: [^]u8, loc := #caller_location) -> u32                                                                     { ret := impl_GetDebugMessageLog(count, bufSize, sources, types, ids, severities, lengths, messageLog);                                                        debug_helper(loc, 1, ret, count, bufSize, sources, types, ids, severities, lengths, messageLog);                                                     return ret }
+	PushDebugGroup                  :: proc "c" (source: u32, id: u32, length: i32, message: cstring, loc := #caller_location)                                                                                                                                                      {        impl_PushDebugGroup(source, id, length, message);                                                                                                     debug_helper(loc, 0, source, id, length, message)                                                                                                               }
+	PopDebugGroup                   :: proc "c" (loc := #caller_location)                                                                                                                                                                                                           {        impl_PopDebugGroup();                                                                                                                                 debug_helper(loc, 0)                                                                                                                                            }
+	ObjectLabel                     :: proc "c" (identifier: u32, name: u32, length: i32, label: [^]u8, loc := #caller_location)                                                                                                                                                    {        impl_ObjectLabel(identifier, name, length, label);                                                                                                    debug_helper(loc, 0, identifier, name, length, label)                                                                                                           }
+	GetObjectLabel                  :: proc "c" (identifier: u32, name: u32, bufSize: i32, length: ^i32, label: [^]u8, loc := #caller_location)                                                                                                                                     {        impl_GetObjectLabel(identifier, name, bufSize, length, label);                                                                                        debug_helper(loc, 0, identifier, name, bufSize, length, label)                                                                                                  }
+	ObjectPtrLabel                  :: proc "c" (ptr: rawptr, length: i32, label: [^]u8, loc := #caller_location)                                                                                                                                                                   {        impl_ObjectPtrLabel(ptr, length, label);                                                                                                              debug_helper(loc, 0, ptr, length, label)                                                                                                                        }
+	GetObjectPtrLabel               :: proc "c" (ptr: rawptr, bufSize: i32, length: ^i32, label: [^]u8, loc := #caller_location)                                                                                                                                                    {        impl_GetObjectPtrLabel(ptr, bufSize, length, label);                                                                                                  debug_helper(loc, 0, ptr, bufSize, length, label)                                                                                                               }
 
 	// VERSION_4_4
-	BufferStorage     :: #force_inline proc "c" (target: u32, size: int, data: rawptr, flags: u32, loc := #caller_location)                                                                                              { impl_BufferStorage(target, size, data, flags);                                                               debug_helper(loc, 0, target, size, data, flags)                                                            }
-	ClearTexImage     :: #force_inline proc "c" (texture: u32, level: i32, format: u32, type: u32, data: rawptr, loc := #caller_location)                                                                                { impl_ClearTexImage(texture, level, format, type, data);                                                     debug_helper(loc, 0, texture, level, format, type, data)                                                  }
-	ClearTexSubImage  :: #force_inline proc "c" (texture: u32, level: i32, xoffset: i32, yoffset: i32, zoffset: i32, width: i32, height: i32, depth: i32, format: u32, type: u32, data: rawptr, loc := #caller_location) { impl_ClearTexSubImage(texture, level, xoffset, yoffset, zoffset, width, height, depth, format, type, data); debug_helper(loc, 0, texture, level, xoffset, yoffset, zoffset, width, height, depth, format, type, data) }
-	BindBuffersBase   :: #force_inline proc "c" (target: u32, first: u32, count: i32, buffers: [^]u32, loc := #caller_location)                                                                                          { impl_BindBuffersBase(target, first, count, buffers);                                                         debug_helper(loc, 0, target, first, count, buffers)                                                        }
-	BindBuffersRange  :: #force_inline proc "c" (target: u32, first: u32, count: i32, buffers: [^]u32, offsets: [^]uintptr, sizes: [^]int, loc := #caller_location)                                                      { impl_BindBuffersRange(target, first, count, buffers, offsets, sizes);                                        debug_helper(loc, 0, target, first, count, buffers, offsets, sizes)                                        }
-	BindTextures      :: #force_inline proc "c" (first: u32, count: i32, textures: [^]u32, loc := #caller_location)                                                                                                      { impl_BindTextures(first, count, textures);                                                                   debug_helper(loc, 0, first, count, textures)                                                               }
-	BindSamplers      :: #force_inline proc "c" (first: u32, count: i32, samplers: [^]u32, loc := #caller_location)                                                                                                      { impl_BindSamplers(first, count, samplers);                                                                   debug_helper(loc, 0, first, count, samplers)                                                               }
-	BindImageTextures :: #force_inline proc "c" (first: u32, count: i32, textures: [^]u32, loc := #caller_location)                                                                                                      { impl_BindImageTextures(first, count, textures);                                                              debug_helper(loc, 0, first, count, textures)                                                               }
-	BindVertexBuffers :: #force_inline proc "c" (first: u32, count: i32, buffers: [^]u32, offsets: [^]uintptr, strides: [^]i32, loc := #caller_location)                                                                 { impl_BindVertexBuffers(first, count, buffers, offsets, strides);                                             debug_helper(loc, 0, first, count, buffers, offsets, strides)                                              }
+	BufferStorage     :: proc "c" (target: u32, size: int, data: rawptr, flags: u32, loc := #caller_location)                                                                                              { impl_BufferStorage(target, size, data, flags);                                                               debug_helper(loc, 0, target, size, data, flags)                                                            }
+	ClearTexImage     :: proc "c" (texture: u32, level: i32, format: u32, type: u32, data: rawptr, loc := #caller_location)                                                                                { impl_ClearTexImage(texture, level, format, type, data);                                                     debug_helper(loc, 0, texture, level, format, type, data)                                                  }
+	ClearTexSubImage  :: proc "c" (texture: u32, level: i32, xoffset: i32, yoffset: i32, zoffset: i32, width: i32, height: i32, depth: i32, format: u32, type: u32, data: rawptr, loc := #caller_location) { impl_ClearTexSubImage(texture, level, xoffset, yoffset, zoffset, width, height, depth, format, type, data); debug_helper(loc, 0, texture, level, xoffset, yoffset, zoffset, width, height, depth, format, type, data) }
+	BindBuffersBase   :: proc "c" (target: u32, first: u32, count: i32, buffers: [^]u32, loc := #caller_location)                                                                                          { impl_BindBuffersBase(target, first, count, buffers);                                                         debug_helper(loc, 0, target, first, count, buffers)                                                        }
+	BindBuffersRange  :: proc "c" (target: u32, first: u32, count: i32, buffers: [^]u32, offsets: [^]uintptr, sizes: [^]int, loc := #caller_location)                                                      { impl_BindBuffersRange(target, first, count, buffers, offsets, sizes);                                        debug_helper(loc, 0, target, first, count, buffers, offsets, sizes)                                        }
+	BindTextures      :: proc "c" (first: u32, count: i32, textures: [^]u32, loc := #caller_location)                                                                                                      { impl_BindTextures(first, count, textures);                                                                   debug_helper(loc, 0, first, count, textures)                                                               }
+	BindSamplers      :: proc "c" (first: u32, count: i32, samplers: [^]u32, loc := #caller_location)                                                                                                      { impl_BindSamplers(first, count, samplers);                                                                   debug_helper(loc, 0, first, count, samplers)                                                               }
+	BindImageTextures :: proc "c" (first: u32, count: i32, textures: [^]u32, loc := #caller_location)                                                                                                      { impl_BindImageTextures(first, count, textures);                                                              debug_helper(loc, 0, first, count, textures)                                                               }
+	BindVertexBuffers :: proc "c" (first: u32, count: i32, buffers: [^]u32, offsets: [^]uintptr, strides: [^]i32, loc := #caller_location)                                                                 { impl_BindVertexBuffers(first, count, buffers, offsets, strides);                                             debug_helper(loc, 0, first, count, buffers, offsets, strides)                                              }
 
 	// VERSION_4_5
-	ClipControl                              :: #force_inline proc "c" (origin: u32, depth: u32, loc := #caller_location)                                                                                                                                            {        impl_ClipControl(origin, depth);                                                                                                   debug_helper(loc, 0, origin, depth)                                                                                                      }
-	CreateTransformFeedbacks                 :: #force_inline proc "c" (n: i32, ids: [^]u32, loc := #caller_location)                                                                                                                                                {        impl_CreateTransformFeedbacks(n, ids);                                                                                             debug_helper(loc, 0, n, ids)                                                                                                             }
-	TransformFeedbackBufferBase              :: #force_inline proc "c" (xfb: u32, index: u32, buffer: u32, loc := #caller_location)                                                                                                                                  {        impl_TransformFeedbackBufferBase(xfb, index, buffer);                                                                              debug_helper(loc, 0, xfb, index, buffer)                                                                                                 }
-	TransformFeedbackBufferRange             :: #force_inline proc "c" (xfb: u32, index: u32, buffer: u32, offset: int, size: int, loc := #caller_location)                                                                                                          {        impl_TransformFeedbackBufferRange(xfb, index, buffer, offset, size);                                                               debug_helper(loc, 0, xfb, index, buffer, offset, size)                                                                                   }
-	GetTransformFeedbackiv                   :: #force_inline proc "c" (xfb: u32, pname: u32, param: ^i32, loc := #caller_location)                                                                                                                                  {        impl_GetTransformFeedbackiv(xfb, pname, param);                                                                                    debug_helper(loc, 0, xfb, pname, param)                                                                                                  }
-	GetTransformFeedbacki_v                  :: #force_inline proc "c" (xfb: u32, pname: u32, index: u32, param: ^i32, loc := #caller_location)                                                                                                                      {        impl_GetTransformFeedbacki_v(xfb, pname, index, param);                                                                            debug_helper(loc, 0, xfb, pname, index, param)                                                                                           }
-	GetTransformFeedbacki64_v                :: #force_inline proc "c" (xfb: u32, pname: u32, index: u32, param: ^i64, loc := #caller_location)                                                                                                                      {        impl_GetTransformFeedbacki64_v(xfb, pname, index, param);                                                                          debug_helper(loc, 0, xfb, pname, index, param)                                                                                           }
-	CreateBuffers                            :: #force_inline proc "c" (n: i32, buffers: [^]u32, loc := #caller_location)                                                                                                                                            {        impl_CreateBuffers(n, buffers);                                                                                                    debug_helper(loc, 0, n, buffers)                                                                                                         }
-	NamedBufferStorage                       :: #force_inline proc "c" (buffer: u32, size: int, data: rawptr, flags: u32, loc := #caller_location)                                                                                                                   {        impl_NamedBufferStorage(buffer, size, data, flags);                                                                                debug_helper(loc, 0, buffer, size, data, flags)                                                                                          }
-	NamedBufferData                          :: #force_inline proc "c" (buffer: u32, size: int, data: rawptr, usage: u32, loc := #caller_location)                                                                                                                   {        impl_NamedBufferData(buffer, size, data, usage);                                                                                   debug_helper(loc, 0, buffer, size, data, usage)                                                                                          }
-	NamedBufferSubData                       :: #force_inline proc "c" (buffer: u32, offset: int, size: int, data: rawptr, loc := #caller_location)                                                                                                                  {        impl_NamedBufferSubData(buffer, offset, size, data);                                                                               debug_helper(loc, 0, buffer, offset, size, data)                                                                                         }
-	CopyNamedBufferSubData                   :: #force_inline proc "c" (readBuffer: u32, writeBuffer: u32, readOffset: int, writeOffset: int, size: int, loc := #caller_location)                                                                                    {        impl_CopyNamedBufferSubData(readBuffer, writeBuffer, readOffset, writeOffset, size);                                               debug_helper(loc, 0, readBuffer, writeBuffer, readOffset, writeOffset, size)                                                             }
-	ClearNamedBufferData                     :: #force_inline proc "c" (buffer: u32, internalformat: u32, format: u32, type: u32, data: rawptr, loc := #caller_location)                                                                                             {        impl_ClearNamedBufferData(buffer, internalformat, format, type, data);                                                            debug_helper(loc, 0, buffer, internalformat, format, type, data)                                                                        }
-	ClearNamedBufferSubData                  :: #force_inline proc "c" (buffer: u32, internalformat: u32, offset: int, size: int, format: u32, type: u32, data: rawptr, loc := #caller_location)                                                                     {        impl_ClearNamedBufferSubData(buffer, internalformat, offset, size, format, type, data);                                           debug_helper(loc, 0, buffer, internalformat, offset, size, format, type, data)                                                          }
-	MapNamedBuffer                           :: #force_inline proc "c" (buffer: u32, access: u32, loc := #caller_location) -> rawptr                                                                                                                                 { ret := impl_MapNamedBuffer(buffer, access);                                                                                               debug_helper(loc, 1, ret, buffer, access);                                                                                    return ret }
-	MapNamedBufferRange                      :: #force_inline proc "c" (buffer: u32, offset: int, length: int, access: u32, loc := #caller_location) -> rawptr                                                                                                       { ret := impl_MapNamedBufferRange(buffer, offset, length, access);                                                                          debug_helper(loc, 1, ret, buffer, offset, length, access);                                                                    return ret }
-	UnmapNamedBuffer                         :: #force_inline proc "c" (buffer: u32, loc := #caller_location) -> bool                                                                                                                                                { ret := impl_UnmapNamedBuffer(buffer);                                                                                                     debug_helper(loc, 1, ret, buffer);                                                                                            return ret }
-	FlushMappedNamedBufferRange              :: #force_inline proc "c" (buffer: u32, offset: int, length: int, loc := #caller_location)                                                                                                                              {        impl_FlushMappedNamedBufferRange(buffer, offset, length);                                                                          debug_helper(loc, 0, buffer, offset, length)                                                                                             }
-	GetNamedBufferParameteriv                :: #force_inline proc "c" (buffer: u32, pname: u32, params: [^]i32, loc := #caller_location)                                                                                                                            {        impl_GetNamedBufferParameteriv(buffer, pname, params);                                                                             debug_helper(loc, 0, buffer, pname, params)                                                                                              }
-	GetNamedBufferParameteri64v              :: #force_inline proc "c" (buffer: u32, pname: u32, params: [^]i64, loc := #caller_location)                                                                                                                            {        impl_GetNamedBufferParameteri64v(buffer, pname, params);                                                                           debug_helper(loc, 0, buffer, pname, params)                                                                                              }
-	GetNamedBufferPointerv                   :: #force_inline proc "c" (buffer: u32, pname: u32, params: [^]rawptr, loc := #caller_location)                                                                                                                         {        impl_GetNamedBufferPointerv(buffer, pname, params);                                                                                debug_helper(loc, 0, buffer, pname, params)                                                                                              }
-	GetNamedBufferSubData                    :: #force_inline proc "c" (buffer: u32, offset: int, size: int, data: rawptr, loc := #caller_location)                                                                                                                  {        impl_GetNamedBufferSubData(buffer, offset, size, data);                                                                            debug_helper(loc, 0, buffer, offset, size, data)                                                                                         }
-	CreateFramebuffers                       :: #force_inline proc "c" (n: i32, framebuffers: [^]u32, loc := #caller_location)                                                                                                                                       {        impl_CreateFramebuffers(n, framebuffers);                                                                                          debug_helper(loc, 0, n, framebuffers)                                                                                                    }
-	NamedFramebufferRenderbuffer             :: #force_inline proc "c" (framebuffer: u32, attachment: u32, renderbuffertarget: u32, renderbuffer: u32, loc := #caller_location)                                                                                      {        impl_NamedFramebufferRenderbuffer(framebuffer, attachment, renderbuffertarget, renderbuffer);                                      debug_helper(loc, 0, framebuffer, attachment, renderbuffertarget, renderbuffer)                                                          }
-	NamedFramebufferParameteri               :: #force_inline proc "c" (framebuffer: u32, pname: u32, param: i32, loc := #caller_location)                                                                                                                           {        impl_NamedFramebufferParameteri(framebuffer, pname, param);                                                                        debug_helper(loc, 0, framebuffer, pname, param)                                                                                          }
-	NamedFramebufferTexture                  :: #force_inline proc "c" (framebuffer: u32, attachment: u32, texture: u32, level: i32, loc := #caller_location)                                                                                                        {        impl_NamedFramebufferTexture(framebuffer, attachment, texture, level);                                                             debug_helper(loc, 0, framebuffer, attachment, texture, level)                                                                            }
-	NamedFramebufferTextureLayer             :: #force_inline proc "c" (framebuffer: u32, attachment: u32, texture: u32, level: i32, layer: i32, loc := #caller_location)                                                                                            {        impl_NamedFramebufferTextureLayer(framebuffer, attachment, texture, level, layer);                                                 debug_helper(loc, 0, framebuffer, attachment, texture, level, layer)                                                                     }
-	NamedFramebufferDrawBuffer               :: #force_inline proc "c" (framebuffer: u32, buf: u32, loc := #caller_location)                                                                                                                                         {        impl_NamedFramebufferDrawBuffer(framebuffer, buf);                                                                                 debug_helper(loc, 0, framebuffer, buf)                                                                                                   }
-	NamedFramebufferDrawBuffers              :: #force_inline proc "c" (framebuffer: u32, n: i32, bufs: [^]u32, loc := #caller_location)                                                                                                                             {        impl_NamedFramebufferDrawBuffers(framebuffer, n, bufs);                                                                            debug_helper(loc, 0, framebuffer, n, bufs)                                                                                               }
-	NamedFramebufferReadBuffer               :: #force_inline proc "c" (framebuffer: u32, src: u32, loc := #caller_location)                                                                                                                                         {        impl_NamedFramebufferReadBuffer(framebuffer, src);                                                                                 debug_helper(loc, 0, framebuffer, src)                                                                                                   }
-	InvalidateNamedFramebufferData           :: #force_inline proc "c" (framebuffer: u32, numAttachments: i32, attachments: [^]u32, loc := #caller_location)                                                                                                           {        impl_InvalidateNamedFramebufferData(framebuffer, numAttachments, attachments);                                                     debug_helper(loc, 0, framebuffer, numAttachments, attachments)                                                                           }
-	InvalidateNamedFramebufferSubData        :: #force_inline proc "c" (framebuffer: u32, numAttachments: i32, attachments: [^]u32, x: i32, y: i32, width: i32, height: i32, loc := #caller_location)                                                                  {        impl_InvalidateNamedFramebufferSubData(framebuffer, numAttachments, attachments, x, y, width, height);                             debug_helper(loc, 0, framebuffer, numAttachments, attachments, x, y, width, height)                                                      }
-	ClearNamedFramebufferiv                  :: #force_inline proc "c" (framebuffer: u32, buffer: u32, drawbuffer: i32, value: ^i32, loc := #caller_location)                                                                                                        {        impl_ClearNamedFramebufferiv(framebuffer, buffer, drawbuffer, value);                                                              debug_helper(loc, 0, framebuffer, buffer, drawbuffer, value)                                                                             }
-	ClearNamedFramebufferuiv                 :: #force_inline proc "c" (framebuffer: u32, buffer: u32, drawbuffer: i32, value: ^u32, loc := #caller_location)                                                                                                        {        impl_ClearNamedFramebufferuiv(framebuffer, buffer, drawbuffer, value);                                                             debug_helper(loc, 0, framebuffer, buffer, drawbuffer, value)                                                                             }
-	ClearNamedFramebufferfv                  :: #force_inline proc "c" (framebuffer: u32, buffer: u32, drawbuffer: i32, value: ^f32, loc := #caller_location)                                                                                                        {        impl_ClearNamedFramebufferfv(framebuffer, buffer, drawbuffer, value);                                                              debug_helper(loc, 0, framebuffer, buffer, drawbuffer, value)                                                                             }
-	ClearNamedFramebufferfi                  :: #force_inline proc "c" (framebuffer: u32, buffer: u32, drawbuffer: i32, depth: f32, stencil: i32, loc := #caller_location)                                                                                           {        impl_ClearNamedFramebufferfi(framebuffer, buffer, drawbuffer, depth, stencil);                                                     debug_helper(loc, 0, framebuffer, buffer, drawbuffer, depth, stencil)                                                                    }
-	BlitNamedFramebuffer                     :: #force_inline proc "c" (readFramebuffer: u32, drawFramebuffer: u32, srcX0: i32, srcY0: i32, srcX1: i32, srcY1: i32, dstX0: i32, dstY0: i32, dstX1: i32, dstY1: i32, mask: u32, filter: u32, loc := #caller_location) {        impl_BlitNamedFramebuffer(readFramebuffer, drawFramebuffer, srcX0, srcY0, srcX1, srcY1, dstX0, dstY0, dstX1, dstY1, mask, filter); debug_helper(loc, 0, readFramebuffer, drawFramebuffer, srcX0, srcY0, srcX1, srcY1, dstX0, dstY0, dstX1, dstY1, mask, filter)             }
-	CheckNamedFramebufferStatus              :: #force_inline proc "c" (framebuffer: u32, target: u32, loc := #caller_location) -> u32                                                                                                                               { ret := impl_CheckNamedFramebufferStatus(framebuffer, target);                                                                             debug_helper(loc, 1, ret, framebuffer, target); return ret                                                                               }
-	GetNamedFramebufferParameteriv           :: #force_inline proc "c" (framebuffer: u32, pname: u32, param: ^i32, loc := #caller_location)                                                                                                                          {        impl_GetNamedFramebufferParameteriv(framebuffer, pname, param);                                                                    debug_helper(loc, 0, framebuffer, pname, param)                                                                                          }
-	GetNamedFramebufferAttachmentParameteriv :: #force_inline proc "c" (framebuffer: u32, attachment: u32, pname: u32, params: [^]i32, loc := #caller_location)                                                                                                      {        impl_GetNamedFramebufferAttachmentParameteriv(framebuffer, attachment, pname, params);                                             debug_helper(loc, 0, framebuffer, attachment, pname, params)                                                                             }
-	CreateRenderbuffers                      :: #force_inline proc "c" (n: i32, renderbuffers: [^]u32, loc := #caller_location)                                                                                                                                      {        impl_CreateRenderbuffers(n, renderbuffers);                                                                                        debug_helper(loc, 0, n, renderbuffers)                                                                                                   }
-	NamedRenderbufferStorage                 :: #force_inline proc "c" (renderbuffer: u32, internalformat: u32, width: i32, height: i32, loc := #caller_location)                                                                                                    {        impl_NamedRenderbufferStorage(renderbuffer, internalformat, width, height);                                                        debug_helper(loc, 0, renderbuffer, internalformat, width, height)                                                                        }
-	NamedRenderbufferStorageMultisample      :: #force_inline proc "c" (renderbuffer: u32, samples: i32, internalformat: u32, width: i32, height: i32, loc := #caller_location)                                                                                      {        impl_NamedRenderbufferStorageMultisample(renderbuffer, samples, internalformat, width, height);                                    debug_helper(loc, 0, renderbuffer, samples, internalformat, width, height)                                                               }
-	GetNamedRenderbufferParameteriv          :: #force_inline proc "c" (renderbuffer: u32, pname: u32, params: [^]i32, loc := #caller_location)                                                                                                                      {        impl_GetNamedRenderbufferParameteriv(renderbuffer, pname, params);                                                                 debug_helper(loc, 0, renderbuffer, pname, params)                                                                                        }
-	CreateTextures                           :: #force_inline proc "c" (target: u32, n: i32, textures: [^]u32, loc := #caller_location)                                                                                                                              {        impl_CreateTextures(target, n, textures);                                                                                          debug_helper(loc, 0, target, n, textures)                                                                                                }
-	TextureBuffer                            :: #force_inline proc "c" (texture: u32, internalformat: u32, buffer: u32, loc := #caller_location)                                                                                                                     {        impl_TextureBuffer(texture, internalformat, buffer);                                                                               debug_helper(loc, 0, texture, internalformat, buffer)                                                                                    }
-	TextureBufferRange                       :: #force_inline proc "c" (texture: u32, internalformat: u32, buffer: u32, offset: int, size: int, loc := #caller_location)                                                                                             {        impl_TextureBufferRange(texture, internalformat, buffer, offset, size);                                                            debug_helper(loc, 0, texture, internalformat, buffer, offset, size)                                                                      }
-	TextureStorage1D                         :: #force_inline proc "c" (texture: u32, levels: i32, internalformat: u32, width: i32, loc := #caller_location)                                                                                                         {        impl_TextureStorage1D(texture, levels, internalformat, width);                                                                     debug_helper(loc, 0, texture, levels, internalformat, width)                                                                             }
-	TextureStorage2D                         :: #force_inline proc "c" (texture: u32, levels: i32, internalformat: u32, width: i32, height: i32, loc := #caller_location)                                                                                            {        impl_TextureStorage2D(texture, levels, internalformat, width, height);                                                             debug_helper(loc, 0, texture, levels, internalformat, width, height)                                                                     }
-	TextureStorage3D                         :: #force_inline proc "c" (texture: u32, levels: i32, internalformat: u32, width: i32, height: i32, depth: i32, loc := #caller_location)                                                                                {        impl_TextureStorage3D(texture, levels, internalformat, width, height, depth);                                                      debug_helper(loc, 0, texture, levels, internalformat, width, height, depth)                                                              }
-	TextureStorage2DMultisample              :: #force_inline proc "c" (texture: u32, samples: i32, internalformat: u32, width: i32, height: i32, fixedsamplelocations: bool, loc := #caller_location)                                                                 {        impl_TextureStorage2DMultisample(texture, samples, internalformat, width, height, fixedsamplelocations);                           debug_helper(loc, 0, texture, samples, internalformat, width, height, fixedsamplelocations)                                              }
-	TextureStorage3DMultisample              :: #force_inline proc "c" (texture: u32, samples: i32, internalformat: u32, width: i32, height: i32, depth: i32, fixedsamplelocations: bool, loc := #caller_location)                                                     {        impl_TextureStorage3DMultisample(texture, samples, internalformat, width, height, depth, fixedsamplelocations);                    debug_helper(loc, 0, texture, samples, internalformat, width, height, depth, fixedsamplelocations)                                       }
-	TextureSubImage1D                        :: #force_inline proc "c" (texture: u32, level: i32, xoffset: i32, width: i32, format: u32, type: u32, pixels: rawptr, loc := #caller_location)                                                                         {        impl_TextureSubImage1D(texture, level, xoffset, width, format, type, pixels);                                                     debug_helper(loc, 0, texture, level, xoffset, width, format, type, pixels)                                                              }
-	TextureSubImage2D                        :: #force_inline proc "c" (texture: u32, level: i32, xoffset: i32, yoffset: i32, width: i32, height: i32, format: u32, type: u32, pixels: rawptr, loc := #caller_location)                                              {        impl_TextureSubImage2D(texture, level, xoffset, yoffset, width, height, format, type, pixels);                                    debug_helper(loc, 0, texture, level, xoffset, yoffset, width, height, format, type, pixels)                                             }
-	TextureSubImage3D                        :: #force_inline proc "c" (texture: u32, level: i32, xoffset: i32, yoffset: i32, zoffset: i32, width: i32, height: i32, depth: i32, format: u32, type: u32, pixels: rawptr, loc := #caller_location)                    {        impl_TextureSubImage3D(texture, level, xoffset, yoffset, zoffset, width, height, depth, format, type, pixels);                    debug_helper(loc, 0, texture, level, xoffset, yoffset, zoffset, width, height, depth, format, type, pixels)                             }
-	CompressedTextureSubImage1D              :: #force_inline proc "c" (texture: u32, level: i32, xoffset: i32, width: i32, format: u32, imageSize: i32, data: rawptr, loc := #caller_location)                                                                      {        impl_CompressedTextureSubImage1D(texture, level, xoffset, width, format, imageSize, data);                                         debug_helper(loc, 0, texture, level, xoffset, width, format, imageSize, data)                                                            }
-	CompressedTextureSubImage2D              :: #force_inline proc "c" (texture: u32, level: i32, xoffset: i32, yoffset: i32, width: i32, height: i32, format: u32, imageSize: i32, data: rawptr, loc := #caller_location)                                           {        impl_CompressedTextureSubImage2D(texture, level, xoffset, yoffset, width, height, format, imageSize, data);                        debug_helper(loc, 0, texture, level, xoffset, yoffset, width, height, format, imageSize, data)                                           }
-	CompressedTextureSubImage3D              :: #force_inline proc "c" (texture: u32, level: i32, xoffset: i32, yoffset: i32, zoffset: i32, width: i32, height: i32, depth: i32, format: u32, imageSize: i32, data: rawptr, loc := #caller_location)                 {        impl_CompressedTextureSubImage3D(texture, level, xoffset, yoffset, zoffset, width, height, depth, format, imageSize, data);        debug_helper(loc, 0, texture, level, xoffset, yoffset, zoffset, width, height, depth, format, imageSize, data)                           }
-	CopyTextureSubImage1D                    :: #force_inline proc "c" (texture: u32, level: i32, xoffset: i32, x: i32, y: i32, width: i32, loc := #caller_location)                                                                                                 {        impl_CopyTextureSubImage1D(texture, level, xoffset, x, y, width);                                                                  debug_helper(loc, 0, texture, level, xoffset, x, y, width)                                                                               }
-	CopyTextureSubImage2D                    :: #force_inline proc "c" (texture: u32, level: i32, xoffset: i32, yoffset: i32, x: i32, y: i32, width: i32, height: i32, loc := #caller_location)                                                                      {        impl_CopyTextureSubImage2D(texture, level, xoffset, yoffset, x, y, width, height);                                                 debug_helper(loc, 0, texture, level, xoffset, yoffset, x, y, width, height)                                                              }
-	CopyTextureSubImage3D                    :: #force_inline proc "c" (texture: u32, level: i32, xoffset: i32, yoffset: i32, zoffset: i32, x: i32, y: i32, width: i32, height: i32, loc := #caller_location)                                                        {        impl_CopyTextureSubImage3D(texture, level, xoffset, yoffset, zoffset, x, y, width, height);                                        debug_helper(loc, 0, texture, level, xoffset, yoffset, zoffset, x, y, width, height)                                                     }
-	TextureParameterf                        :: #force_inline proc "c" (texture: u32, pname: u32, param: f32, loc := #caller_location)                                                                                                                               {        impl_TextureParameterf(texture, pname, param);                                                                                     debug_helper(loc, 0, texture, pname, param)                                                                                              }
-	TextureParameterfv                       :: #force_inline proc "c" (texture: u32, pname: u32, param: ^f32, loc := #caller_location)                                                                                                                              {        impl_TextureParameterfv(texture, pname, param);                                                                                    debug_helper(loc, 0, texture, pname, param)                                                                                              }
-	TextureParameteri                        :: #force_inline proc "c" (texture: u32, pname: u32, param: i32, loc := #caller_location)                                                                                                                               {        impl_TextureParameteri(texture, pname, param);                                                                                     debug_helper(loc, 0, texture, pname, param)                                                                                              }
-	TextureParameterIiv                      :: #force_inline proc "c" (texture: u32, pname: u32, params: [^]i32, loc := #caller_location)                                                                                                                           {        impl_TextureParameterIiv(texture, pname, params);                                                                                  debug_helper(loc, 0, texture, pname, params)                                                                                             }
-	TextureParameterIuiv                     :: #force_inline proc "c" (texture: u32, pname: u32, params: [^]u32, loc := #caller_location)                                                                                                                           {        impl_TextureParameterIuiv(texture, pname, params);                                                                                 debug_helper(loc, 0, texture, pname, params)                                                                                             }
-	TextureParameteriv                       :: #force_inline proc "c" (texture: u32, pname: u32, param: ^i32, loc := #caller_location)                                                                                                                              {        impl_TextureParameteriv(texture, pname, param);                                                                                    debug_helper(loc, 0, texture, pname, param)                                                                                              }
-	GenerateTextureMipmap                    :: #force_inline proc "c" (texture: u32, loc := #caller_location)                                                                                                                                                       {        impl_GenerateTextureMipmap(texture);                                                                                               debug_helper(loc, 0, texture)                                                                                                            }
-	BindTextureUnit                          :: #force_inline proc "c" (unit: u32, texture: u32, loc := #caller_location)                                                                                                                                            {        impl_BindTextureUnit(unit, texture);                                                                                               debug_helper(loc, 0, unit, texture)                                                                                                      }
-	GetTextureImage                          :: #force_inline proc "c" (texture: u32, level: i32, format: u32, type: u32, bufSize: i32, pixels: rawptr, loc := #caller_location)                                                                                     {        impl_GetTextureImage(texture, level, format, type, bufSize, pixels);                                                              debug_helper(loc, 0, texture, level, format, type, bufSize, pixels)                                                                     }
-	GetCompressedTextureImage                :: #force_inline proc "c" (texture: u32, level: i32, bufSize: i32, pixels: rawptr, loc := #caller_location)                                                                                                             {        impl_GetCompressedTextureImage(texture, level, bufSize, pixels);                                                                   debug_helper(loc, 0, texture, level, bufSize, pixels)                                                                                    }
-	GetTextureLevelParameterfv               :: #force_inline proc "c" (texture: u32, level: i32, pname: u32, params: [^]f32, loc := #caller_location)                                                                                                               {        impl_GetTextureLevelParameterfv(texture, level, pname, params);                                                                    debug_helper(loc, 0, texture, level, pname, params)                                                                                      }
-	GetTextureLevelParameteriv               :: #force_inline proc "c" (texture: u32, level: i32, pname: u32, params: [^]i32, loc := #caller_location)                                                                                                               {        impl_GetTextureLevelParameteriv(texture, level, pname, params);                                                                    debug_helper(loc, 0, texture, level, pname, params)                                                                                      }
-	GetTextureParameterfv                    :: #force_inline proc "c" (texture: u32, pname: u32, params: [^]f32, loc := #caller_location)                                                                                                                           {        impl_GetTextureParameterfv(texture, pname, params);                                                                                debug_helper(loc, 0, texture, pname, params)                                                                                             }
-	GetTextureParameterIiv                   :: #force_inline proc "c" (texture: u32, pname: u32, params: [^]i32, loc := #caller_location)                                                                                                                           {        impl_GetTextureParameterIiv(texture, pname, params);                                                                               debug_helper(loc, 0, texture, pname, params)                                                                                             }
-	GetTextureParameterIuiv                  :: #force_inline proc "c" (texture: u32, pname: u32, params: [^]u32, loc := #caller_location)                                                                                                                           {        impl_GetTextureParameterIuiv(texture, pname, params);                                                                              debug_helper(loc, 0, texture, pname, params)                                                                                             }
-	GetTextureParameteriv                    :: #force_inline proc "c" (texture: u32, pname: u32, params: [^]i32, loc := #caller_location)                                                                                                                           {        impl_GetTextureParameteriv(texture, pname, params);                                                                                debug_helper(loc, 0, texture, pname, params)                                                                                             }
-	CreateVertexArrays                       :: #force_inline proc "c" (n: i32, arrays: [^]u32, loc := #caller_location)                                                                                                                                             {        impl_CreateVertexArrays(n, arrays);                                                                                                debug_helper(loc, 0, n, arrays)                                                                                                          }
-	DisableVertexArrayAttrib                 :: #force_inline proc "c" (vaobj: u32, index: u32, loc := #caller_location)                                                                                                                                             {        impl_DisableVertexArrayAttrib(vaobj, index);                                                                                       debug_helper(loc, 0, vaobj, index)                                                                                                       }
-	EnableVertexArrayAttrib                  :: #force_inline proc "c" (vaobj: u32, index: u32, loc := #caller_location)                                                                                                                                             {        impl_EnableVertexArrayAttrib(vaobj, index);                                                                                        debug_helper(loc, 0, vaobj, index)                                                                                                       }
-	VertexArrayElementBuffer                 :: #force_inline proc "c" (vaobj: u32, buffer: u32, loc := #caller_location)                                                                                                                                            {        impl_VertexArrayElementBuffer(vaobj, buffer);                                                                                      debug_helper(loc, 0, vaobj, buffer)                                                                                                      }
-	VertexArrayVertexBuffer                  :: #force_inline proc "c" (vaobj: u32, bindingindex: u32, buffer: u32, offset: int, stride: i32, loc := #caller_location)                                                                                               {        impl_VertexArrayVertexBuffer(vaobj, bindingindex, buffer, offset, stride);                                                         debug_helper(loc, 0, vaobj, bindingindex, buffer, offset, stride)                                                                        }
-	VertexArrayVertexBuffers                 :: #force_inline proc "c" (vaobj: u32, first: u32, count: i32, buffers: [^]u32, offsets: [^]uintptr, strides: [^]i32, loc := #caller_location)                                                                          {        impl_VertexArrayVertexBuffers(vaobj, first, count, buffers, offsets, strides);                                                     debug_helper(loc, 0, vaobj, first, count, buffers, offsets, strides)                                                                     }
-	VertexArrayAttribBinding                 :: #force_inline proc "c" (vaobj: u32, attribindex: u32, bindingindex: u32, loc := #caller_location)                                                                                                                    {        impl_VertexArrayAttribBinding(vaobj, attribindex, bindingindex);                                                                   debug_helper(loc, 0, vaobj, attribindex, bindingindex)                                                                                   }
-	VertexArrayAttribFormat                  :: #force_inline proc "c" (vaobj: u32, attribindex: u32, size: i32, type: u32, normalized: bool, relativeoffset: u32, loc := #caller_location)                                                                          {        impl_VertexArrayAttribFormat(vaobj, attribindex, size, type, normalized, relativeoffset);                                         debug_helper(loc, 0, vaobj, attribindex, size, type, normalized, relativeoffset)                                                        }
-	VertexArrayAttribIFormat                 :: #force_inline proc "c" (vaobj: u32, attribindex: u32, size: i32, type: u32, relativeoffset: u32, loc := #caller_location)                                                                                            {        impl_VertexArrayAttribIFormat(vaobj, attribindex, size, type, relativeoffset);                                                    debug_helper(loc, 0, vaobj, attribindex, size, type, relativeoffset)                                                                    }
-	VertexArrayAttribLFormat                 :: #force_inline proc "c" (vaobj: u32, attribindex: u32, size: i32, type: u32, relativeoffset: u32, loc := #caller_location)                                                                                            {        impl_VertexArrayAttribLFormat(vaobj, attribindex, size, type, relativeoffset);                                                    debug_helper(loc, 0, vaobj, attribindex, size, type, relativeoffset)                                                                    }
-	VertexArrayBindingDivisor                :: #force_inline proc "c" (vaobj: u32, bindingindex: u32, divisor: u32, loc := #caller_location)                                                                                                                        {        impl_VertexArrayBindingDivisor(vaobj, bindingindex, divisor);                                                                      debug_helper(loc, 0, vaobj, bindingindex, divisor)                                                                                       }
-	GetVertexArrayiv                         :: #force_inline proc "c" (vaobj: u32, pname: u32, param: ^i32, loc := #caller_location)                                                                                                                                {        impl_GetVertexArrayiv(vaobj, pname, param);                                                                                        debug_helper(loc, 0, vaobj, pname, param)                                                                                                }
-	GetVertexArrayIndexediv                  :: #force_inline proc "c" (vaobj: u32, index: u32, pname: u32, param: ^i32, loc := #caller_location)                                                                                                                    {        impl_GetVertexArrayIndexediv(vaobj, index, pname, param);                                                                          debug_helper(loc, 0, vaobj, index, pname, param)                                                                                         }
-	GetVertexArrayIndexed64iv                :: #force_inline proc "c" (vaobj: u32, index: u32, pname: u32, param: ^i64, loc := #caller_location)                                                                                                                    {        impl_GetVertexArrayIndexed64iv(vaobj, index, pname, param);                                                                        debug_helper(loc, 0, vaobj, index, pname, param)                                                                                         }
-	CreateSamplers                           :: #force_inline proc "c" (n: i32, samplers: [^]u32, loc := #caller_location)                                                                                                                                           {        impl_CreateSamplers(n, samplers);                                                                                                  debug_helper(loc, 0, n, samplers)                                                                                                        }
-	CreateProgramPipelines                   :: #force_inline proc "c" (n: i32, pipelines: [^]u32, loc := #caller_location)                                                                                                                                          {        impl_CreateProgramPipelines(n, pipelines);                                                                                         debug_helper(loc, 0, n, pipelines)                                                                                                       }
-	CreateQueries                            :: #force_inline proc "c" (target: u32, n: i32, ids: [^]u32, loc := #caller_location)                                                                                                                                   {        impl_CreateQueries(target, n, ids);                                                                                                debug_helper(loc, 0, target, n, ids)                                                                                                     }
-	GetQueryBufferObjecti64v                 :: #force_inline proc "c" (id: u32, buffer: u32, pname: u32, offset: int, loc := #caller_location)                                                                                                                      {        impl_GetQueryBufferObjecti64v(id, buffer, pname, offset);                                                                          debug_helper(loc, 0, id, buffer, pname, offset)                                                                                          }
-	GetQueryBufferObjectiv                   :: #force_inline proc "c" (id: u32, buffer: u32, pname: u32, offset: int, loc := #caller_location)                                                                                                                      {        impl_GetQueryBufferObjectiv(id, buffer, pname, offset);                                                                            debug_helper(loc, 0, id, buffer, pname, offset)                                                                                          }
-	GetQueryBufferObjectui64v                :: #force_inline proc "c" (id: u32, buffer: u32, pname: u32, offset: int, loc := #caller_location)                                                                                                                      {        impl_GetQueryBufferObjectui64v(id, buffer, pname, offset);                                                                         debug_helper(loc, 0, id, buffer, pname, offset)                                                                                          }
-	GetQueryBufferObjectuiv                  :: #force_inline proc "c" (id: u32, buffer: u32, pname: u32, offset: int, loc := #caller_location)                                                                                                                      {        impl_GetQueryBufferObjectuiv(id, buffer, pname, offset);                                                                           debug_helper(loc, 0, id, buffer, pname, offset)                                                                                          }
-	MemoryBarrierByRegion                    :: #force_inline proc "c" (barriers: u32, loc := #caller_location)                                                                                                                                                      {        impl_MemoryBarrierByRegion(barriers);                                                                                              debug_helper(loc, 0, barriers)                                                                                                           }
-	GetTextureSubImage                       :: #force_inline proc "c" (texture: u32, level: i32, xoffset: i32, yoffset: i32, zoffset: i32, width: i32, height: i32, depth: i32, format: u32, type: u32, bufSize: i32, pixels: rawptr, loc := #caller_location)      {        impl_GetTextureSubImage(texture, level, xoffset, yoffset, zoffset, width, height, depth, format, type, bufSize, pixels);          debug_helper(loc, 0, texture, level, xoffset, yoffset, zoffset, width, height, depth, format, type, bufSize, pixels)                    }
-	GetCompressedTextureSubImage             :: #force_inline proc "c" (texture: u32, level: i32, xoffset: i32, yoffset: i32, zoffset: i32, width: i32, height: i32, depth: i32, bufSize: i32, pixels: rawptr, loc := #caller_location)                              {        impl_GetCompressedTextureSubImage(texture, level, xoffset, yoffset, zoffset, width, height, depth, bufSize, pixels);               debug_helper(loc, 0, texture, level, xoffset, yoffset, zoffset, width, height, depth, bufSize, pixels)                                   }
-	GetGraphicsResetStatus                   :: #force_inline proc "c" (loc := #caller_location) -> u32                                                                                                                                                              { ret := impl_GetGraphicsResetStatus();                                                                                                     debug_helper(loc, 1, ret);                                                                                                    return ret }
-	GetnCompressedTexImage                   :: #force_inline proc "c" (target: u32, lod: i32, bufSize: i32, pixels: rawptr, loc := #caller_location)                                                                                                                {        impl_GetnCompressedTexImage(target, lod, bufSize, pixels);                                                                         debug_helper(loc, 0, target, lod, bufSize, pixels)                                                                                       }
-	GetnTexImage                             :: #force_inline proc "c" (target: u32, level: i32, format: u32, type: u32, bufSize: i32, pixels: rawptr, loc := #caller_location)                                                                                      {        impl_GetnTexImage(target, level, format, type, bufSize, pixels);                                                                  debug_helper(loc, 0, target, level, format, type, bufSize, pixels)                                                                      }
-	GetnUniformdv                            :: #force_inline proc "c" (program: u32, location: i32, bufSize: i32, params: [^]f64, loc := #caller_location)                                                                                                          {        impl_GetnUniformdv(program, location, bufSize, params);                                                                            debug_helper(loc, 0, program, location, bufSize, params)                                                                                 }
-	GetnUniformfv                            :: #force_inline proc "c" (program: u32, location: i32, bufSize: i32, params: [^]f32, loc := #caller_location)                                                                                                          {        impl_GetnUniformfv(program, location, bufSize, params);                                                                            debug_helper(loc, 0, program, location, bufSize, params)                                                                                 }
-	GetnUniformiv                            :: #force_inline proc "c" (program: u32, location: i32, bufSize: i32, params: [^]i32, loc := #caller_location)                                                                                                          {        impl_GetnUniformiv(program, location, bufSize, params);                                                                            debug_helper(loc, 0, program, location, bufSize, params)                                                                                 }
-	GetnUniformuiv                           :: #force_inline proc "c" (program: u32, location: i32, bufSize: i32, params: [^]u32, loc := #caller_location)                                                                                                          {        impl_GetnUniformuiv(program, location, bufSize, params);                                                                           debug_helper(loc, 0, program, location, bufSize, params)                                                                                 }
-	ReadnPixels                              :: #force_inline proc "c" (x: i32, y: i32, width: i32, height: i32, format: u32, type: u32, bufSize: i32, data: rawptr, loc := #caller_location)                                                                        {        impl_ReadnPixels(x, y, width, height, format, type, bufSize, data);                                                               debug_helper(loc, 0, x, y, width, height, format, type, bufSize, data)                                                                  }
-	GetnMapdv                                :: #force_inline proc "c" (target: u32, query: u32, bufSize: i32, v: [^]f64, loc := #caller_location)                                                                                                                     {        impl_GetnMapdv(target, query, bufSize, v);                                                                                         debug_helper(loc, 0, target, query, bufSize, v)                                                                                          }
-	GetnMapfv                                :: #force_inline proc "c" (target: u32, query: u32, bufSize: i32, v: [^]f32, loc := #caller_location)                                                                                                                     {        impl_GetnMapfv(target, query, bufSize, v);                                                                                         debug_helper(loc, 0, target, query, bufSize, v)                                                                                          }
-	GetnMapiv                                :: #force_inline proc "c" (target: u32, query: u32, bufSize: i32, v: [^]i32, loc := #caller_location)                                                                                                                     {        impl_GetnMapiv(target, query, bufSize, v);                                                                                         debug_helper(loc, 0, target, query, bufSize, v)                                                                                          }
-	GetnPixelMapusv                          :: #force_inline proc "c" (map_: u32, bufSize: i32, values: [^]u16, loc := #caller_location)                                                                                                                            {        impl_GetnPixelMapusv(map_, bufSize, values);                                                                                       debug_helper(loc, 0, map_, bufSize, values)                                                                                              }
-	GetnPixelMapfv                           :: #force_inline proc "c" (map_: u32, bufSize: i32, values: [^]f32, loc := #caller_location)                                                                                                                            {        impl_GetnPixelMapfv(map_, bufSize, values);                                                                                        debug_helper(loc, 0, map_, bufSize, values)                                                                                              }
-	GetnPixelMapuiv                          :: #force_inline proc "c" (map_: u32, bufSize: i32, values: [^]u32, loc := #caller_location)                                                                                                                            {        impl_GetnPixelMapuiv(map_, bufSize, values);                                                                                       debug_helper(loc, 0, map_, bufSize, values)                                                                                              }
-	GetnPolygonStipple                       :: #force_inline proc "c" (bufSize: i32, pattern: [^]u8, loc := #caller_location)                                                                                                                                         {        impl_GetnPolygonStipple(bufSize, pattern);                                                                                         debug_helper(loc, 0, bufSize, pattern)                                                                                                   }
-	GetnColorTable                           :: #force_inline proc "c" (target: u32, format: u32, type: u32, bufSize: i32, table: rawptr, loc := #caller_location)                                                                                                   {        impl_GetnColorTable(target, format, type, bufSize, table);                                                                        debug_helper(loc, 0, target, format, type, bufSize, table)                                                                                }
-	GetnConvolutionFilter                    :: #force_inline proc "c" (target: u32, format: u32, type: u32, bufSize: i32, image: rawptr, loc := #caller_location)                                                                                                   {        impl_GetnConvolutionFilter(target, format, type, bufSize, image);                                                                 debug_helper(loc, 0, target, format, type, bufSize, image)                                                                                }
-	GetnSeparableFilter                      :: #force_inline proc "c" (target: u32, format: u32, type: u32, rowBufSize: i32, row: rawptr, columnBufSize: i32, column: rawptr, span: rawptr, loc := #caller_location)                                                {        impl_GetnSeparableFilter(target, format, type, rowBufSize, row, columnBufSize, column, span);                                     debug_helper(loc, 0, target, format, type, rowBufSize, row, columnBufSize, column, span)                                                  }
-	GetnHistogram                            :: #force_inline proc "c" (target: u32, reset: bool, format: u32, type: u32, bufSize: i32, values: rawptr, loc := #caller_location)                                                                                     {        impl_GetnHistogram(target, reset, format, type, bufSize, values);                                                                 debug_helper(loc, 0, target, reset, format, type, bufSize, values)                                                                        }
-	GetnMinmax                               :: #force_inline proc "c" (target: u32, reset: bool, format: u32, type: u32, bufSize: i32, values: rawptr, loc := #caller_location)                                                                                     {        impl_GetnMinmax(target, reset, format, type, bufSize, values);                                                                    debug_helper(loc, 0, target, reset, format, type, bufSize, values)                                                                        }
-	TextureBarrier                           :: #force_inline proc "c" (loc := #caller_location)                                                                                                                                                                     {        impl_TextureBarrier();                                                                                                             debug_helper(loc, 0)                                                                                                                     }
-	GetUnsignedBytevEXT                      :: #force_inline proc "c" (pname: u32, data: ^byte, loc := #caller_location)                                                                                                                                            {        impl_GetUnsignedBytevEXT(pname, data);                                                                                             debug_helper(loc, 0, pname, data)                                                                                                        }
-	TexPageCommitmentARB                     :: #force_inline proc "c"(target: u32, level: i32, xoffset: i32, yoffset: i32, zoffset: i32, width: i32, height: i32, depth: i32, commit: bool, loc := #caller_location) { impl_TexPageCommitmentARB(target, level, xoffset, yoffset, zoffset, width, height, depth, commit); debug_helper(loc, 0, target, level, xoffset, yoffset, zoffset, width, height, depth, commit) }
+	ClipControl                              :: proc "c" (origin: u32, depth: u32, loc := #caller_location)                                                                                                                                            {        impl_ClipControl(origin, depth);                                                                                                   debug_helper(loc, 0, origin, depth)                                                                                                      }
+	CreateTransformFeedbacks                 :: proc "c" (n: i32, ids: [^]u32, loc := #caller_location)                                                                                                                                                {        impl_CreateTransformFeedbacks(n, ids);                                                                                             debug_helper(loc, 0, n, ids)                                                                                                             }
+	TransformFeedbackBufferBase              :: proc "c" (xfb: u32, index: u32, buffer: u32, loc := #caller_location)                                                                                                                                  {        impl_TransformFeedbackBufferBase(xfb, index, buffer);                                                                              debug_helper(loc, 0, xfb, index, buffer)                                                                                                 }
+	TransformFeedbackBufferRange             :: proc "c" (xfb: u32, index: u32, buffer: u32, offset: int, size: int, loc := #caller_location)                                                                                                          {        impl_TransformFeedbackBufferRange(xfb, index, buffer, offset, size);                                                               debug_helper(loc, 0, xfb, index, buffer, offset, size)                                                                                   }
+	GetTransformFeedbackiv                   :: proc "c" (xfb: u32, pname: u32, param: ^i32, loc := #caller_location)                                                                                                                                  {        impl_GetTransformFeedbackiv(xfb, pname, param);                                                                                    debug_helper(loc, 0, xfb, pname, param)                                                                                                  }
+	GetTransformFeedbacki_v                  :: proc "c" (xfb: u32, pname: u32, index: u32, param: ^i32, loc := #caller_location)                                                                                                                      {        impl_GetTransformFeedbacki_v(xfb, pname, index, param);                                                                            debug_helper(loc, 0, xfb, pname, index, param)                                                                                           }
+	GetTransformFeedbacki64_v                :: proc "c" (xfb: u32, pname: u32, index: u32, param: ^i64, loc := #caller_location)                                                                                                                      {        impl_GetTransformFeedbacki64_v(xfb, pname, index, param);                                                                          debug_helper(loc, 0, xfb, pname, index, param)                                                                                           }
+	CreateBuffers                            :: proc "c" (n: i32, buffers: [^]u32, loc := #caller_location)                                                                                                                                            {        impl_CreateBuffers(n, buffers);                                                                                                    debug_helper(loc, 0, n, buffers)                                                                                                         }
+	NamedBufferStorage                       :: proc "c" (buffer: u32, size: int, data: rawptr, flags: u32, loc := #caller_location)                                                                                                                   {        impl_NamedBufferStorage(buffer, size, data, flags);                                                                                debug_helper(loc, 0, buffer, size, data, flags)                                                                                          }
+	NamedBufferData                          :: proc "c" (buffer: u32, size: int, data: rawptr, usage: u32, loc := #caller_location)                                                                                                                   {        impl_NamedBufferData(buffer, size, data, usage);                                                                                   debug_helper(loc, 0, buffer, size, data, usage)                                                                                          }
+	NamedBufferSubData                       :: proc "c" (buffer: u32, offset: int, size: int, data: rawptr, loc := #caller_location)                                                                                                                  {        impl_NamedBufferSubData(buffer, offset, size, data);                                                                               debug_helper(loc, 0, buffer, offset, size, data)                                                                                         }
+	CopyNamedBufferSubData                   :: proc "c" (readBuffer: u32, writeBuffer: u32, readOffset: int, writeOffset: int, size: int, loc := #caller_location)                                                                                    {        impl_CopyNamedBufferSubData(readBuffer, writeBuffer, readOffset, writeOffset, size);                                               debug_helper(loc, 0, readBuffer, writeBuffer, readOffset, writeOffset, size)                                                             }
+	ClearNamedBufferData                     :: proc "c" (buffer: u32, internalformat: u32, format: u32, type: u32, data: rawptr, loc := #caller_location)                                                                                             {        impl_ClearNamedBufferData(buffer, internalformat, format, type, data);                                                            debug_helper(loc, 0, buffer, internalformat, format, type, data)                                                                        }
+	ClearNamedBufferSubData                  :: proc "c" (buffer: u32, internalformat: u32, offset: int, size: int, format: u32, type: u32, data: rawptr, loc := #caller_location)                                                                     {        impl_ClearNamedBufferSubData(buffer, internalformat, offset, size, format, type, data);                                           debug_helper(loc, 0, buffer, internalformat, offset, size, format, type, data)                                                          }
+	MapNamedBuffer                           :: proc "c" (buffer: u32, access: u32, loc := #caller_location) -> rawptr                                                                                                                                 { ret := impl_MapNamedBuffer(buffer, access);                                                                                               debug_helper(loc, 1, ret, buffer, access);                                                                                    return ret }
+	MapNamedBufferRange                      :: proc "c" (buffer: u32, offset: int, length: int, access: u32, loc := #caller_location) -> rawptr                                                                                                       { ret := impl_MapNamedBufferRange(buffer, offset, length, access);                                                                          debug_helper(loc, 1, ret, buffer, offset, length, access);                                                                    return ret }
+	UnmapNamedBuffer                         :: proc "c" (buffer: u32, loc := #caller_location) -> bool                                                                                                                                                { ret := impl_UnmapNamedBuffer(buffer);                                                                                                     debug_helper(loc, 1, ret, buffer);                                                                                            return ret }
+	FlushMappedNamedBufferRange              :: proc "c" (buffer: u32, offset: int, length: int, loc := #caller_location)                                                                                                                              {        impl_FlushMappedNamedBufferRange(buffer, offset, length);                                                                          debug_helper(loc, 0, buffer, offset, length)                                                                                             }
+	GetNamedBufferParameteriv                :: proc "c" (buffer: u32, pname: u32, params: [^]i32, loc := #caller_location)                                                                                                                            {        impl_GetNamedBufferParameteriv(buffer, pname, params);                                                                             debug_helper(loc, 0, buffer, pname, params)                                                                                              }
+	GetNamedBufferParameteri64v              :: proc "c" (buffer: u32, pname: u32, params: [^]i64, loc := #caller_location)                                                                                                                            {        impl_GetNamedBufferParameteri64v(buffer, pname, params);                                                                           debug_helper(loc, 0, buffer, pname, params)                                                                                              }
+	GetNamedBufferPointerv                   :: proc "c" (buffer: u32, pname: u32, params: [^]rawptr, loc := #caller_location)                                                                                                                         {        impl_GetNamedBufferPointerv(buffer, pname, params);                                                                                debug_helper(loc, 0, buffer, pname, params)                                                                                              }
+	GetNamedBufferSubData                    :: proc "c" (buffer: u32, offset: int, size: int, data: rawptr, loc := #caller_location)                                                                                                                  {        impl_GetNamedBufferSubData(buffer, offset, size, data);                                                                            debug_helper(loc, 0, buffer, offset, size, data)                                                                                         }
+	CreateFramebuffers                       :: proc "c" (n: i32, framebuffers: [^]u32, loc := #caller_location)                                                                                                                                       {        impl_CreateFramebuffers(n, framebuffers);                                                                                          debug_helper(loc, 0, n, framebuffers)                                                                                                    }
+	NamedFramebufferRenderbuffer             :: proc "c" (framebuffer: u32, attachment: u32, renderbuffertarget: u32, renderbuffer: u32, loc := #caller_location)                                                                                      {        impl_NamedFramebufferRenderbuffer(framebuffer, attachment, renderbuffertarget, renderbuffer);                                      debug_helper(loc, 0, framebuffer, attachment, renderbuffertarget, renderbuffer)                                                          }
+	NamedFramebufferParameteri               :: proc "c" (framebuffer: u32, pname: u32, param: i32, loc := #caller_location)                                                                                                                           {        impl_NamedFramebufferParameteri(framebuffer, pname, param);                                                                        debug_helper(loc, 0, framebuffer, pname, param)                                                                                          }
+	NamedFramebufferTexture                  :: proc "c" (framebuffer: u32, attachment: u32, texture: u32, level: i32, loc := #caller_location)                                                                                                        {        impl_NamedFramebufferTexture(framebuffer, attachment, texture, level);                                                             debug_helper(loc, 0, framebuffer, attachment, texture, level)                                                                            }
+	NamedFramebufferTextureLayer             :: proc "c" (framebuffer: u32, attachment: u32, texture: u32, level: i32, layer: i32, loc := #caller_location)                                                                                            {        impl_NamedFramebufferTextureLayer(framebuffer, attachment, texture, level, layer);                                                 debug_helper(loc, 0, framebuffer, attachment, texture, level, layer)                                                                     }
+	NamedFramebufferDrawBuffer               :: proc "c" (framebuffer: u32, buf: u32, loc := #caller_location)                                                                                                                                         {        impl_NamedFramebufferDrawBuffer(framebuffer, buf);                                                                                 debug_helper(loc, 0, framebuffer, buf)                                                                                                   }
+	NamedFramebufferDrawBuffers              :: proc "c" (framebuffer: u32, n: i32, bufs: [^]u32, loc := #caller_location)                                                                                                                             {        impl_NamedFramebufferDrawBuffers(framebuffer, n, bufs);                                                                            debug_helper(loc, 0, framebuffer, n, bufs)                                                                                               }
+	NamedFramebufferReadBuffer               :: proc "c" (framebuffer: u32, src: u32, loc := #caller_location)                                                                                                                                         {        impl_NamedFramebufferReadBuffer(framebuffer, src);                                                                                 debug_helper(loc, 0, framebuffer, src)                                                                                                   }
+	InvalidateNamedFramebufferData           :: proc "c" (framebuffer: u32, numAttachments: i32, attachments: [^]u32, loc := #caller_location)                                                                                                           {        impl_InvalidateNamedFramebufferData(framebuffer, numAttachments, attachments);                                                     debug_helper(loc, 0, framebuffer, numAttachments, attachments)                                                                           }
+	InvalidateNamedFramebufferSubData        :: proc "c" (framebuffer: u32, numAttachments: i32, attachments: [^]u32, x: i32, y: i32, width: i32, height: i32, loc := #caller_location)                                                                  {        impl_InvalidateNamedFramebufferSubData(framebuffer, numAttachments, attachments, x, y, width, height);                             debug_helper(loc, 0, framebuffer, numAttachments, attachments, x, y, width, height)                                                      }
+	ClearNamedFramebufferiv                  :: proc "c" (framebuffer: u32, buffer: u32, drawbuffer: i32, value: ^i32, loc := #caller_location)                                                                                                        {        impl_ClearNamedFramebufferiv(framebuffer, buffer, drawbuffer, value);                                                              debug_helper(loc, 0, framebuffer, buffer, drawbuffer, value)                                                                             }
+	ClearNamedFramebufferuiv                 :: proc "c" (framebuffer: u32, buffer: u32, drawbuffer: i32, value: ^u32, loc := #caller_location)                                                                                                        {        impl_ClearNamedFramebufferuiv(framebuffer, buffer, drawbuffer, value);                                                             debug_helper(loc, 0, framebuffer, buffer, drawbuffer, value)                                                                             }
+	ClearNamedFramebufferfv                  :: proc "c" (framebuffer: u32, buffer: u32, drawbuffer: i32, value: ^f32, loc := #caller_location)                                                                                                        {        impl_ClearNamedFramebufferfv(framebuffer, buffer, drawbuffer, value);                                                              debug_helper(loc, 0, framebuffer, buffer, drawbuffer, value)                                                                             }
+	ClearNamedFramebufferfi                  :: proc "c" (framebuffer: u32, buffer: u32, drawbuffer: i32, depth: f32, stencil: i32, loc := #caller_location)                                                                                           {        impl_ClearNamedFramebufferfi(framebuffer, buffer, drawbuffer, depth, stencil);                                                     debug_helper(loc, 0, framebuffer, buffer, drawbuffer, depth, stencil)                                                                    }
+	BlitNamedFramebuffer                     :: proc "c" (readFramebuffer: u32, drawFramebuffer: u32, srcX0: i32, srcY0: i32, srcX1: i32, srcY1: i32, dstX0: i32, dstY0: i32, dstX1: i32, dstY1: i32, mask: u32, filter: u32, loc := #caller_location) {        impl_BlitNamedFramebuffer(readFramebuffer, drawFramebuffer, srcX0, srcY0, srcX1, srcY1, dstX0, dstY0, dstX1, dstY1, mask, filter); debug_helper(loc, 0, readFramebuffer, drawFramebuffer, srcX0, srcY0, srcX1, srcY1, dstX0, dstY0, dstX1, dstY1, mask, filter)             }
+	CheckNamedFramebufferStatus              :: proc "c" (framebuffer: u32, target: u32, loc := #caller_location) -> u32                                                                                                                               { ret := impl_CheckNamedFramebufferStatus(framebuffer, target);                                                                             debug_helper(loc, 1, ret, framebuffer, target); return ret                                                                               }
+	GetNamedFramebufferParameteriv           :: proc "c" (framebuffer: u32, pname: u32, param: ^i32, loc := #caller_location)                                                                                                                          {        impl_GetNamedFramebufferParameteriv(framebuffer, pname, param);                                                                    debug_helper(loc, 0, framebuffer, pname, param)                                                                                          }
+	GetNamedFramebufferAttachmentParameteriv :: proc "c" (framebuffer: u32, attachment: u32, pname: u32, params: [^]i32, loc := #caller_location)                                                                                                      {        impl_GetNamedFramebufferAttachmentParameteriv(framebuffer, attachment, pname, params);                                             debug_helper(loc, 0, framebuffer, attachment, pname, params)                                                                             }
+	CreateRenderbuffers                      :: proc "c" (n: i32, renderbuffers: [^]u32, loc := #caller_location)                                                                                                                                      {        impl_CreateRenderbuffers(n, renderbuffers);                                                                                        debug_helper(loc, 0, n, renderbuffers)                                                                                                   }
+	NamedRenderbufferStorage                 :: proc "c" (renderbuffer: u32, internalformat: u32, width: i32, height: i32, loc := #caller_location)                                                                                                    {        impl_NamedRenderbufferStorage(renderbuffer, internalformat, width, height);                                                        debug_helper(loc, 0, renderbuffer, internalformat, width, height)                                                                        }
+	NamedRenderbufferStorageMultisample      :: proc "c" (renderbuffer: u32, samples: i32, internalformat: u32, width: i32, height: i32, loc := #caller_location)                                                                                      {        impl_NamedRenderbufferStorageMultisample(renderbuffer, samples, internalformat, width, height);                                    debug_helper(loc, 0, renderbuffer, samples, internalformat, width, height)                                                               }
+	GetNamedRenderbufferParameteriv          :: proc "c" (renderbuffer: u32, pname: u32, params: [^]i32, loc := #caller_location)                                                                                                                      {        impl_GetNamedRenderbufferParameteriv(renderbuffer, pname, params);                                                                 debug_helper(loc, 0, renderbuffer, pname, params)                                                                                        }
+	CreateTextures                           :: proc "c" (target: u32, n: i32, textures: [^]u32, loc := #caller_location)                                                                                                                              {        impl_CreateTextures(target, n, textures);                                                                                          debug_helper(loc, 0, target, n, textures)                                                                                                }
+	TextureBuffer                            :: proc "c" (texture: u32, internalformat: u32, buffer: u32, loc := #caller_location)                                                                                                                     {        impl_TextureBuffer(texture, internalformat, buffer);                                                                               debug_helper(loc, 0, texture, internalformat, buffer)                                                                                    }
+	TextureBufferRange                       :: proc "c" (texture: u32, internalformat: u32, buffer: u32, offset: int, size: int, loc := #caller_location)                                                                                             {        impl_TextureBufferRange(texture, internalformat, buffer, offset, size);                                                            debug_helper(loc, 0, texture, internalformat, buffer, offset, size)                                                                      }
+	TextureStorage1D                         :: proc "c" (texture: u32, levels: i32, internalformat: u32, width: i32, loc := #caller_location)                                                                                                         {        impl_TextureStorage1D(texture, levels, internalformat, width);                                                                     debug_helper(loc, 0, texture, levels, internalformat, width)                                                                             }
+	TextureStorage2D                         :: proc "c" (texture: u32, levels: i32, internalformat: u32, width: i32, height: i32, loc := #caller_location)                                                                                            {        impl_TextureStorage2D(texture, levels, internalformat, width, height);                                                             debug_helper(loc, 0, texture, levels, internalformat, width, height)                                                                     }
+	TextureStorage3D                         :: proc "c" (texture: u32, levels: i32, internalformat: u32, width: i32, height: i32, depth: i32, loc := #caller_location)                                                                                {        impl_TextureStorage3D(texture, levels, internalformat, width, height, depth);                                                      debug_helper(loc, 0, texture, levels, internalformat, width, height, depth)                                                              }
+	TextureStorage2DMultisample              :: proc "c" (texture: u32, samples: i32, internalformat: u32, width: i32, height: i32, fixedsamplelocations: bool, loc := #caller_location)                                                                 {        impl_TextureStorage2DMultisample(texture, samples, internalformat, width, height, fixedsamplelocations);                           debug_helper(loc, 0, texture, samples, internalformat, width, height, fixedsamplelocations)                                              }
+	TextureStorage3DMultisample              :: proc "c" (texture: u32, samples: i32, internalformat: u32, width: i32, height: i32, depth: i32, fixedsamplelocations: bool, loc := #caller_location)                                                     {        impl_TextureStorage3DMultisample(texture, samples, internalformat, width, height, depth, fixedsamplelocations);                    debug_helper(loc, 0, texture, samples, internalformat, width, height, depth, fixedsamplelocations)                                       }
+	TextureSubImage1D                        :: proc "c" (texture: u32, level: i32, xoffset: i32, width: i32, format: u32, type: u32, pixels: rawptr, loc := #caller_location)                                                                         {        impl_TextureSubImage1D(texture, level, xoffset, width, format, type, pixels);                                                     debug_helper(loc, 0, texture, level, xoffset, width, format, type, pixels)                                                              }
+	TextureSubImage2D                        :: proc "c" (texture: u32, level: i32, xoffset: i32, yoffset: i32, width: i32, height: i32, format: u32, type: u32, pixels: rawptr, loc := #caller_location)                                              {        impl_TextureSubImage2D(texture, level, xoffset, yoffset, width, height, format, type, pixels);                                    debug_helper(loc, 0, texture, level, xoffset, yoffset, width, height, format, type, pixels)                                             }
+	TextureSubImage3D                        :: proc "c" (texture: u32, level: i32, xoffset: i32, yoffset: i32, zoffset: i32, width: i32, height: i32, depth: i32, format: u32, type: u32, pixels: rawptr, loc := #caller_location)                    {        impl_TextureSubImage3D(texture, level, xoffset, yoffset, zoffset, width, height, depth, format, type, pixels);                    debug_helper(loc, 0, texture, level, xoffset, yoffset, zoffset, width, height, depth, format, type, pixels)                             }
+	CompressedTextureSubImage1D              :: proc "c" (texture: u32, level: i32, xoffset: i32, width: i32, format: u32, imageSize: i32, data: rawptr, loc := #caller_location)                                                                      {        impl_CompressedTextureSubImage1D(texture, level, xoffset, width, format, imageSize, data);                                         debug_helper(loc, 0, texture, level, xoffset, width, format, imageSize, data)                                                            }
+	CompressedTextureSubImage2D              :: proc "c" (texture: u32, level: i32, xoffset: i32, yoffset: i32, width: i32, height: i32, format: u32, imageSize: i32, data: rawptr, loc := #caller_location)                                           {        impl_CompressedTextureSubImage2D(texture, level, xoffset, yoffset, width, height, format, imageSize, data);                        debug_helper(loc, 0, texture, level, xoffset, yoffset, width, height, format, imageSize, data)                                           }
+	CompressedTextureSubImage3D              :: proc "c" (texture: u32, level: i32, xoffset: i32, yoffset: i32, zoffset: i32, width: i32, height: i32, depth: i32, format: u32, imageSize: i32, data: rawptr, loc := #caller_location)                 {        impl_CompressedTextureSubImage3D(texture, level, xoffset, yoffset, zoffset, width, height, depth, format, imageSize, data);        debug_helper(loc, 0, texture, level, xoffset, yoffset, zoffset, width, height, depth, format, imageSize, data)                           }
+	CopyTextureSubImage1D                    :: proc "c" (texture: u32, level: i32, xoffset: i32, x: i32, y: i32, width: i32, loc := #caller_location)                                                                                                 {        impl_CopyTextureSubImage1D(texture, level, xoffset, x, y, width);                                                                  debug_helper(loc, 0, texture, level, xoffset, x, y, width)                                                                               }
+	CopyTextureSubImage2D                    :: proc "c" (texture: u32, level: i32, xoffset: i32, yoffset: i32, x: i32, y: i32, width: i32, height: i32, loc := #caller_location)                                                                      {        impl_CopyTextureSubImage2D(texture, level, xoffset, yoffset, x, y, width, height);                                                 debug_helper(loc, 0, texture, level, xoffset, yoffset, x, y, width, height)                                                              }
+	CopyTextureSubImage3D                    :: proc "c" (texture: u32, level: i32, xoffset: i32, yoffset: i32, zoffset: i32, x: i32, y: i32, width: i32, height: i32, loc := #caller_location)                                                        {        impl_CopyTextureSubImage3D(texture, level, xoffset, yoffset, zoffset, x, y, width, height);                                        debug_helper(loc, 0, texture, level, xoffset, yoffset, zoffset, x, y, width, height)                                                     }
+	TextureParameterf                        :: proc "c" (texture: u32, pname: u32, param: f32, loc := #caller_location)                                                                                                                               {        impl_TextureParameterf(texture, pname, param);                                                                                     debug_helper(loc, 0, texture, pname, param)                                                                                              }
+	TextureParameterfv                       :: proc "c" (texture: u32, pname: u32, param: ^f32, loc := #caller_location)                                                                                                                              {        impl_TextureParameterfv(texture, pname, param);                                                                                    debug_helper(loc, 0, texture, pname, param)                                                                                              }
+	TextureParameteri                        :: proc "c" (texture: u32, pname: u32, param: i32, loc := #caller_location)                                                                                                                               {        impl_TextureParameteri(texture, pname, param);                                                                                     debug_helper(loc, 0, texture, pname, param)                                                                                              }
+	TextureParameterIiv                      :: proc "c" (texture: u32, pname: u32, params: [^]i32, loc := #caller_location)                                                                                                                           {        impl_TextureParameterIiv(texture, pname, params);                                                                                  debug_helper(loc, 0, texture, pname, params)                                                                                             }
+	TextureParameterIuiv                     :: proc "c" (texture: u32, pname: u32, params: [^]u32, loc := #caller_location)                                                                                                                           {        impl_TextureParameterIuiv(texture, pname, params);                                                                                 debug_helper(loc, 0, texture, pname, params)                                                                                             }
+	TextureParameteriv                       :: proc "c" (texture: u32, pname: u32, param: ^i32, loc := #caller_location)                                                                                                                              {        impl_TextureParameteriv(texture, pname, param);                                                                                    debug_helper(loc, 0, texture, pname, param)                                                                                              }
+	GenerateTextureMipmap                    :: proc "c" (texture: u32, loc := #caller_location)                                                                                                                                                       {        impl_GenerateTextureMipmap(texture);                                                                                               debug_helper(loc, 0, texture)                                                                                                            }
+	BindTextureUnit                          :: proc "c" (unit: u32, texture: u32, loc := #caller_location)                                                                                                                                            {        impl_BindTextureUnit(unit, texture);                                                                                               debug_helper(loc, 0, unit, texture)                                                                                                      }
+	GetTextureImage                          :: proc "c" (texture: u32, level: i32, format: u32, type: u32, bufSize: i32, pixels: rawptr, loc := #caller_location)                                                                                     {        impl_GetTextureImage(texture, level, format, type, bufSize, pixels);                                                              debug_helper(loc, 0, texture, level, format, type, bufSize, pixels)                                                                     }
+	GetCompressedTextureImage                :: proc "c" (texture: u32, level: i32, bufSize: i32, pixels: rawptr, loc := #caller_location)                                                                                                             {        impl_GetCompressedTextureImage(texture, level, bufSize, pixels);                                                                   debug_helper(loc, 0, texture, level, bufSize, pixels)                                                                                    }
+	GetTextureLevelParameterfv               :: proc "c" (texture: u32, level: i32, pname: u32, params: [^]f32, loc := #caller_location)                                                                                                               {        impl_GetTextureLevelParameterfv(texture, level, pname, params);                                                                    debug_helper(loc, 0, texture, level, pname, params)                                                                                      }
+	GetTextureLevelParameteriv               :: proc "c" (texture: u32, level: i32, pname: u32, params: [^]i32, loc := #caller_location)                                                                                                               {        impl_GetTextureLevelParameteriv(texture, level, pname, params);                                                                    debug_helper(loc, 0, texture, level, pname, params)                                                                                      }
+	GetTextureParameterfv                    :: proc "c" (texture: u32, pname: u32, params: [^]f32, loc := #caller_location)                                                                                                                           {        impl_GetTextureParameterfv(texture, pname, params);                                                                                debug_helper(loc, 0, texture, pname, params)                                                                                             }
+	GetTextureParameterIiv                   :: proc "c" (texture: u32, pname: u32, params: [^]i32, loc := #caller_location)                                                                                                                           {        impl_GetTextureParameterIiv(texture, pname, params);                                                                               debug_helper(loc, 0, texture, pname, params)                                                                                             }
+	GetTextureParameterIuiv                  :: proc "c" (texture: u32, pname: u32, params: [^]u32, loc := #caller_location)                                                                                                                           {        impl_GetTextureParameterIuiv(texture, pname, params);                                                                              debug_helper(loc, 0, texture, pname, params)                                                                                             }
+	GetTextureParameteriv                    :: proc "c" (texture: u32, pname: u32, params: [^]i32, loc := #caller_location)                                                                                                                           {        impl_GetTextureParameteriv(texture, pname, params);                                                                                debug_helper(loc, 0, texture, pname, params)                                                                                             }
+	CreateVertexArrays                       :: proc "c" (n: i32, arrays: [^]u32, loc := #caller_location)                                                                                                                                             {        impl_CreateVertexArrays(n, arrays);                                                                                                debug_helper(loc, 0, n, arrays)                                                                                                          }
+	DisableVertexArrayAttrib                 :: proc "c" (vaobj: u32, index: u32, loc := #caller_location)                                                                                                                                             {        impl_DisableVertexArrayAttrib(vaobj, index);                                                                                       debug_helper(loc, 0, vaobj, index)                                                                                                       }
+	EnableVertexArrayAttrib                  :: proc "c" (vaobj: u32, index: u32, loc := #caller_location)                                                                                                                                             {        impl_EnableVertexArrayAttrib(vaobj, index);                                                                                        debug_helper(loc, 0, vaobj, index)                                                                                                       }
+	VertexArrayElementBuffer                 :: proc "c" (vaobj: u32, buffer: u32, loc := #caller_location)                                                                                                                                            {        impl_VertexArrayElementBuffer(vaobj, buffer);                                                                                      debug_helper(loc, 0, vaobj, buffer)                                                                                                      }
+	VertexArrayVertexBuffer                  :: proc "c" (vaobj: u32, bindingindex: u32, buffer: u32, offset: int, stride: i32, loc := #caller_location)                                                                                               {        impl_VertexArrayVertexBuffer(vaobj, bindingindex, buffer, offset, stride);                                                         debug_helper(loc, 0, vaobj, bindingindex, buffer, offset, stride)                                                                        }
+	VertexArrayVertexBuffers                 :: proc "c" (vaobj: u32, first: u32, count: i32, buffers: [^]u32, offsets: [^]uintptr, strides: [^]i32, loc := #caller_location)                                                                          {        impl_VertexArrayVertexBuffers(vaobj, first, count, buffers, offsets, strides);                                                     debug_helper(loc, 0, vaobj, first, count, buffers, offsets, strides)                                                                     }
+	VertexArrayAttribBinding                 :: proc "c" (vaobj: u32, attribindex: u32, bindingindex: u32, loc := #caller_location)                                                                                                                    {        impl_VertexArrayAttribBinding(vaobj, attribindex, bindingindex);                                                                   debug_helper(loc, 0, vaobj, attribindex, bindingindex)                                                                                   }
+	VertexArrayAttribFormat                  :: proc "c" (vaobj: u32, attribindex: u32, size: i32, type: u32, normalized: bool, relativeoffset: u32, loc := #caller_location)                                                                          {        impl_VertexArrayAttribFormat(vaobj, attribindex, size, type, normalized, relativeoffset);                                         debug_helper(loc, 0, vaobj, attribindex, size, type, normalized, relativeoffset)                                                        }
+	VertexArrayAttribIFormat                 :: proc "c" (vaobj: u32, attribindex: u32, size: i32, type: u32, relativeoffset: u32, loc := #caller_location)                                                                                            {        impl_VertexArrayAttribIFormat(vaobj, attribindex, size, type, relativeoffset);                                                    debug_helper(loc, 0, vaobj, attribindex, size, type, relativeoffset)                                                                    }
+	VertexArrayAttribLFormat                 :: proc "c" (vaobj: u32, attribindex: u32, size: i32, type: u32, relativeoffset: u32, loc := #caller_location)                                                                                            {        impl_VertexArrayAttribLFormat(vaobj, attribindex, size, type, relativeoffset);                                                    debug_helper(loc, 0, vaobj, attribindex, size, type, relativeoffset)                                                                    }
+	VertexArrayBindingDivisor                :: proc "c" (vaobj: u32, bindingindex: u32, divisor: u32, loc := #caller_location)                                                                                                                        {        impl_VertexArrayBindingDivisor(vaobj, bindingindex, divisor);                                                                      debug_helper(loc, 0, vaobj, bindingindex, divisor)                                                                                       }
+	GetVertexArrayiv                         :: proc "c" (vaobj: u32, pname: u32, param: ^i32, loc := #caller_location)                                                                                                                                {        impl_GetVertexArrayiv(vaobj, pname, param);                                                                                        debug_helper(loc, 0, vaobj, pname, param)                                                                                                }
+	GetVertexArrayIndexediv                  :: proc "c" (vaobj: u32, index: u32, pname: u32, param: ^i32, loc := #caller_location)                                                                                                                    {        impl_GetVertexArrayIndexediv(vaobj, index, pname, param);                                                                          debug_helper(loc, 0, vaobj, index, pname, param)                                                                                         }
+	GetVertexArrayIndexed64iv                :: proc "c" (vaobj: u32, index: u32, pname: u32, param: ^i64, loc := #caller_location)                                                                                                                    {        impl_GetVertexArrayIndexed64iv(vaobj, index, pname, param);                                                                        debug_helper(loc, 0, vaobj, index, pname, param)                                                                                         }
+	CreateSamplers                           :: proc "c" (n: i32, samplers: [^]u32, loc := #caller_location)                                                                                                                                           {        impl_CreateSamplers(n, samplers);                                                                                                  debug_helper(loc, 0, n, samplers)                                                                                                        }
+	CreateProgramPipelines                   :: proc "c" (n: i32, pipelines: [^]u32, loc := #caller_location)                                                                                                                                          {        impl_CreateProgramPipelines(n, pipelines);                                                                                         debug_helper(loc, 0, n, pipelines)                                                                                                       }
+	CreateQueries                            :: proc "c" (target: u32, n: i32, ids: [^]u32, loc := #caller_location)                                                                                                                                   {        impl_CreateQueries(target, n, ids);                                                                                                debug_helper(loc, 0, target, n, ids)                                                                                                     }
+	GetQueryBufferObjecti64v                 :: proc "c" (id: u32, buffer: u32, pname: u32, offset: int, loc := #caller_location)                                                                                                                      {        impl_GetQueryBufferObjecti64v(id, buffer, pname, offset);                                                                          debug_helper(loc, 0, id, buffer, pname, offset)                                                                                          }
+	GetQueryBufferObjectiv                   :: proc "c" (id: u32, buffer: u32, pname: u32, offset: int, loc := #caller_location)                                                                                                                      {        impl_GetQueryBufferObjectiv(id, buffer, pname, offset);                                                                            debug_helper(loc, 0, id, buffer, pname, offset)                                                                                          }
+	GetQueryBufferObjectui64v                :: proc "c" (id: u32, buffer: u32, pname: u32, offset: int, loc := #caller_location)                                                                                                                      {        impl_GetQueryBufferObjectui64v(id, buffer, pname, offset);                                                                         debug_helper(loc, 0, id, buffer, pname, offset)                                                                                          }
+	GetQueryBufferObjectuiv                  :: proc "c" (id: u32, buffer: u32, pname: u32, offset: int, loc := #caller_location)                                                                                                                      {        impl_GetQueryBufferObjectuiv(id, buffer, pname, offset);                                                                           debug_helper(loc, 0, id, buffer, pname, offset)                                                                                          }
+	MemoryBarrierByRegion                    :: proc "c" (barriers: u32, loc := #caller_location)                                                                                                                                                      {        impl_MemoryBarrierByRegion(barriers);                                                                                              debug_helper(loc, 0, barriers)                                                                                                           }
+	GetTextureSubImage                       :: proc "c" (texture: u32, level: i32, xoffset: i32, yoffset: i32, zoffset: i32, width: i32, height: i32, depth: i32, format: u32, type: u32, bufSize: i32, pixels: rawptr, loc := #caller_location)      {        impl_GetTextureSubImage(texture, level, xoffset, yoffset, zoffset, width, height, depth, format, type, bufSize, pixels);          debug_helper(loc, 0, texture, level, xoffset, yoffset, zoffset, width, height, depth, format, type, bufSize, pixels)                    }
+	GetCompressedTextureSubImage             :: proc "c" (texture: u32, level: i32, xoffset: i32, yoffset: i32, zoffset: i32, width: i32, height: i32, depth: i32, bufSize: i32, pixels: rawptr, loc := #caller_location)                              {        impl_GetCompressedTextureSubImage(texture, level, xoffset, yoffset, zoffset, width, height, depth, bufSize, pixels);               debug_helper(loc, 0, texture, level, xoffset, yoffset, zoffset, width, height, depth, bufSize, pixels)                                   }
+	GetGraphicsResetStatus                   :: proc "c" (loc := #caller_location) -> u32                                                                                                                                                              { ret := impl_GetGraphicsResetStatus();                                                                                                     debug_helper(loc, 1, ret);                                                                                                    return ret }
+	GetnCompressedTexImage                   :: proc "c" (target: u32, lod: i32, bufSize: i32, pixels: rawptr, loc := #caller_location)                                                                                                                {        impl_GetnCompressedTexImage(target, lod, bufSize, pixels);                                                                         debug_helper(loc, 0, target, lod, bufSize, pixels)                                                                                       }
+	GetnTexImage                             :: proc "c" (target: u32, level: i32, format: u32, type: u32, bufSize: i32, pixels: rawptr, loc := #caller_location)                                                                                      {        impl_GetnTexImage(target, level, format, type, bufSize, pixels);                                                                  debug_helper(loc, 0, target, level, format, type, bufSize, pixels)                                                                      }
+	GetnUniformdv                            :: proc "c" (program: u32, location: i32, bufSize: i32, params: [^]f64, loc := #caller_location)                                                                                                          {        impl_GetnUniformdv(program, location, bufSize, params);                                                                            debug_helper(loc, 0, program, location, bufSize, params)                                                                                 }
+	GetnUniformfv                            :: proc "c" (program: u32, location: i32, bufSize: i32, params: [^]f32, loc := #caller_location)                                                                                                          {        impl_GetnUniformfv(program, location, bufSize, params);                                                                            debug_helper(loc, 0, program, location, bufSize, params)                                                                                 }
+	GetnUniformiv                            :: proc "c" (program: u32, location: i32, bufSize: i32, params: [^]i32, loc := #caller_location)                                                                                                          {        impl_GetnUniformiv(program, location, bufSize, params);                                                                            debug_helper(loc, 0, program, location, bufSize, params)                                                                                 }
+	GetnUniformuiv                           :: proc "c" (program: u32, location: i32, bufSize: i32, params: [^]u32, loc := #caller_location)                                                                                                          {        impl_GetnUniformuiv(program, location, bufSize, params);                                                                           debug_helper(loc, 0, program, location, bufSize, params)                                                                                 }
+	ReadnPixels                              :: proc "c" (x: i32, y: i32, width: i32, height: i32, format: u32, type: u32, bufSize: i32, data: rawptr, loc := #caller_location)                                                                        {        impl_ReadnPixels(x, y, width, height, format, type, bufSize, data);                                                               debug_helper(loc, 0, x, y, width, height, format, type, bufSize, data)                                                                  }
+	GetnMapdv                                :: proc "c" (target: u32, query: u32, bufSize: i32, v: [^]f64, loc := #caller_location)                                                                                                                     {        impl_GetnMapdv(target, query, bufSize, v);                                                                                         debug_helper(loc, 0, target, query, bufSize, v)                                                                                          }
+	GetnMapfv                                :: proc "c" (target: u32, query: u32, bufSize: i32, v: [^]f32, loc := #caller_location)                                                                                                                     {        impl_GetnMapfv(target, query, bufSize, v);                                                                                         debug_helper(loc, 0, target, query, bufSize, v)                                                                                          }
+	GetnMapiv                                :: proc "c" (target: u32, query: u32, bufSize: i32, v: [^]i32, loc := #caller_location)                                                                                                                     {        impl_GetnMapiv(target, query, bufSize, v);                                                                                         debug_helper(loc, 0, target, query, bufSize, v)                                                                                          }
+	GetnPixelMapusv                          :: proc "c" (map_: u32, bufSize: i32, values: [^]u16, loc := #caller_location)                                                                                                                            {        impl_GetnPixelMapusv(map_, bufSize, values);                                                                                       debug_helper(loc, 0, map_, bufSize, values)                                                                                              }
+	GetnPixelMapfv                           :: proc "c" (map_: u32, bufSize: i32, values: [^]f32, loc := #caller_location)                                                                                                                            {        impl_GetnPixelMapfv(map_, bufSize, values);                                                                                        debug_helper(loc, 0, map_, bufSize, values)                                                                                              }
+	GetnPixelMapuiv                          :: proc "c" (map_: u32, bufSize: i32, values: [^]u32, loc := #caller_location)                                                                                                                            {        impl_GetnPixelMapuiv(map_, bufSize, values);                                                                                       debug_helper(loc, 0, map_, bufSize, values)                                                                                              }
+	GetnPolygonStipple                       :: proc "c" (bufSize: i32, pattern: [^]u8, loc := #caller_location)                                                                                                                                         {        impl_GetnPolygonStipple(bufSize, pattern);                                                                                         debug_helper(loc, 0, bufSize, pattern)                                                                                                   }
+	GetnColorTable                           :: proc "c" (target: u32, format: u32, type: u32, bufSize: i32, table: rawptr, loc := #caller_location)                                                                                                   {        impl_GetnColorTable(target, format, type, bufSize, table);                                                                        debug_helper(loc, 0, target, format, type, bufSize, table)                                                                                }
+	GetnConvolutionFilter                    :: proc "c" (target: u32, format: u32, type: u32, bufSize: i32, image: rawptr, loc := #caller_location)                                                                                                   {        impl_GetnConvolutionFilter(target, format, type, bufSize, image);                                                                 debug_helper(loc, 0, target, format, type, bufSize, image)                                                                                }
+	GetnSeparableFilter                      :: proc "c" (target: u32, format: u32, type: u32, rowBufSize: i32, row: rawptr, columnBufSize: i32, column: rawptr, span: rawptr, loc := #caller_location)                                                {        impl_GetnSeparableFilter(target, format, type, rowBufSize, row, columnBufSize, column, span);                                     debug_helper(loc, 0, target, format, type, rowBufSize, row, columnBufSize, column, span)                                                  }
+	GetnHistogram                            :: proc "c" (target: u32, reset: bool, format: u32, type: u32, bufSize: i32, values: rawptr, loc := #caller_location)                                                                                     {        impl_GetnHistogram(target, reset, format, type, bufSize, values);                                                                 debug_helper(loc, 0, target, reset, format, type, bufSize, values)                                                                        }
+	GetnMinmax                               :: proc "c" (target: u32, reset: bool, format: u32, type: u32, bufSize: i32, values: rawptr, loc := #caller_location)                                                                                     {        impl_GetnMinmax(target, reset, format, type, bufSize, values);                                                                    debug_helper(loc, 0, target, reset, format, type, bufSize, values)                                                                        }
+	TextureBarrier                           :: proc "c" (loc := #caller_location)                                                                                                                                                                     {        impl_TextureBarrier();                                                                                                             debug_helper(loc, 0)                                                                                                                     }
+	GetUnsignedBytevEXT                      :: proc "c" (pname: u32, data: ^byte, loc := #caller_location)                                                                                                                                            {        impl_GetUnsignedBytevEXT(pname, data);                                                                                             debug_helper(loc, 0, pname, data)                                                                                                        }
+	TexPageCommitmentARB                     :: proc "c"(target: u32, level: i32, xoffset: i32, yoffset: i32, zoffset: i32, width: i32, height: i32, depth: i32, commit: bool, loc := #caller_location) { impl_TexPageCommitmentARB(target, level, xoffset, yoffset, zoffset, width, height, depth, commit); debug_helper(loc, 0, target, level, xoffset, yoffset, zoffset, width, height, depth, commit) }
 	
 	// VERSION_4_6
-	SpecializeShader               :: #force_inline proc "c" (shader: u32, pEntryPoint: cstring, numSpecializationConstants: u32, pConstantIndex: ^u32, pConstantValue: ^u32, loc := #caller_location) { impl_SpecializeShader(shader, pEntryPoint, numSpecializationConstants, pConstantIndex, pConstantValue); debug_helper(loc, 0, shader, pEntryPoint, numSpecializationConstants, pConstantIndex, pConstantValue) }
-	MultiDrawArraysIndirectCount   :: #force_inline proc "c" (mode: i32, indirect: [^]DrawArraysIndirectCommand, drawcount: i32, maxdrawcount, stride: i32, loc := #caller_location)                   { impl_MultiDrawArraysIndirectCount(mode, indirect, drawcount, maxdrawcount, stride);                     debug_helper(loc, 0, mode, indirect, drawcount, maxdrawcount, stride)                                 }
-	MultiDrawElementsIndirectCount :: #force_inline proc "c" (mode: i32, type: i32, indirect: [^]DrawElementsIndirectCommand, drawcount: i32, maxdrawcount, stride: i32, loc := #caller_location)      { impl_MultiDrawElementsIndirectCount(mode, type, indirect, drawcount, maxdrawcount, stride);             debug_helper(loc, 0, mode, type, indirect, drawcount, maxdrawcount, stride)                           }
-	PolygonOffsetClamp             :: #force_inline proc "c" (factor, units, clamp: f32, loc := #caller_location)                                                                                      { impl_PolygonOffsetClamp(factor, units, clamp);                                                          debug_helper(loc, 0, factor, units, clamp)                                                            }
+	SpecializeShader               :: proc "c" (shader: u32, pEntryPoint: cstring, numSpecializationConstants: u32, pConstantIndex: ^u32, pConstantValue: ^u32, loc := #caller_location) { impl_SpecializeShader(shader, pEntryPoint, numSpecializationConstants, pConstantIndex, pConstantValue); debug_helper(loc, 0, shader, pEntryPoint, numSpecializationConstants, pConstantIndex, pConstantValue) }
+	MultiDrawArraysIndirectCount   :: proc "c" (mode: i32, indirect: [^]DrawArraysIndirectCommand, drawcount: i32, maxdrawcount, stride: i32, loc := #caller_location)                   { impl_MultiDrawArraysIndirectCount(mode, indirect, drawcount, maxdrawcount, stride);                     debug_helper(loc, 0, mode, indirect, drawcount, maxdrawcount, stride)                                 }
+	MultiDrawElementsIndirectCount :: proc "c" (mode: i32, type: i32, indirect: [^]DrawElementsIndirectCommand, drawcount: i32, maxdrawcount, stride: i32, loc := #caller_location)      { impl_MultiDrawElementsIndirectCount(mode, type, indirect, drawcount, maxdrawcount, stride);             debug_helper(loc, 0, mode, type, indirect, drawcount, maxdrawcount, stride)                           }
+	PolygonOffsetClamp             :: proc "c" (factor, units, clamp: f32, loc := #caller_location)                                                                                      { impl_PolygonOffsetClamp(factor, units, clamp);                                                          debug_helper(loc, 0, factor, units, clamp)                                                            }
 }

From 8a2c829e07763173864b73d3b6ca46e27f810e72 Mon Sep 17 00:00:00 2001
From: gingerBill <bill@gingerbill.org>
Date: Sun, 21 Nov 2021 14:06:15 +0000
Subject: [PATCH 34/38] Patch odin doc binary format

---
 core/odin/doc-format/doc_format.odin | 2 +-
 src/docs_format.cpp                  | 5 +++--
 2 files changed, 4 insertions(+), 3 deletions(-)

diff --git a/core/odin/doc-format/doc_format.odin b/core/odin/doc-format/doc_format.odin
index 8fa9f453c..c80be2489 100644
--- a/core/odin/doc-format/doc_format.odin
+++ b/core/odin/doc-format/doc_format.odin
@@ -11,7 +11,7 @@ String :: distinct Array(byte)
 
 Version_Type_Major :: 0
 Version_Type_Minor :: 2
-Version_Type_Patch :: 0
+Version_Type_Patch :: 1
 
 Version_Type :: struct {
 	major, minor, patch: u8,
diff --git a/src/docs_format.cpp b/src/docs_format.cpp
index 4cdb19a68..1c3af6257 100644
--- a/src/docs_format.cpp
+++ b/src/docs_format.cpp
@@ -15,7 +15,7 @@ struct OdinDocVersionType {
 
 #define OdinDocVersionType_Major 0
 #define OdinDocVersionType_Minor 2
-#define OdinDocVersionType_Patch 0
+#define OdinDocVersionType_Patch 1
 
 struct OdinDocHeaderBase {
 	u8                 magic[8];
@@ -175,7 +175,8 @@ enum OdinDocEntityFlag : u64 {
 
 struct OdinDocEntity {
 	OdinDocEntityKind  kind;
-	u32                flags;
+	u32                reserved;
+	u64                flags;
 	OdinDocPosition    pos;
 	OdinDocString      name;
 	OdinDocTypeIndex   type;

From f40f12d480173274fd64a04dfc7414b7697f5a7c Mon Sep 17 00:00:00 2001
From: gingerBill <bill@gingerbill.org>
Date: Sun, 21 Nov 2021 14:06:32 +0000
Subject: [PATCH 35/38] Minor cleanup to math constants

---
 core/math/math.odin        | 31 ++++++++++++++-----------------
 core/math/math_gamma.odin  | 18 +++++++++---------
 core/math/math_lgamma.odin |  8 ++++----
 core/math/math_log1p.odin  | 18 +++++++++---------
 4 files changed, 36 insertions(+), 39 deletions(-)

diff --git a/core/math/math.odin b/core/math/math.odin
index ef89562c9..caaa6f51b 100644
--- a/core/math/math.odin
+++ b/core/math/math.odin
@@ -607,9 +607,9 @@ floor_mod :: proc "contextless" (x, y: $T) -> T
 }
 
 modf_f16   :: proc "contextless" (x: f16) -> (int: f16, frac: f16) {
-	shift :: 16 - 5 - 1
-	mask  :: 0x1f
-	bias  :: 15
+	shift :: F16_SHIFT
+	mask  :: F16_MASK
+	bias  :: F16_BIAS
 
 	if x < 1 {
 		switch {
@@ -641,9 +641,9 @@ modf_f16be :: proc "contextless" (x: f16be) -> (int: f16be, frac: f16be) {
 	return f16be(i), f16be(f)
 }
 modf_f32   :: proc "contextless" (x: f32) -> (int: f32, frac: f32) {
-	shift :: 32 - 8 - 1
-	mask  :: 0xff
-	bias  :: 127
+	shift :: F32_SHIFT
+	mask  :: F32_MASK
+	bias  :: F32_BIAS
 
 	if x < 1 {
 		switch {
@@ -674,10 +674,10 @@ modf_f32be :: proc "contextless" (x: f32be) -> (int: f32be, frac: f32be) {
 	i, f := #force_inline modf_f32(f32(x))
 	return f32be(i), f32be(f)
 }
-modf_f64   :: proc "contextless" (x: f64) -> (int: f64, frac: f64) {
-	shift :: 64 - 11 - 1
-	mask  :: 0x7ff
-	bias  :: 1023
+modf_f64 :: proc "contextless" (x: f64) -> (int: f64, frac: f64) {
+	shift :: F64_SHIFT
+	mask  :: F64_MASK
+	bias  :: F64_BIAS
 
 	if x < 1 {
 		switch {
@@ -708,7 +708,7 @@ modf_f64be :: proc "contextless" (x: f64be) -> (int: f64be, frac: f64be) {
 	i, f := #force_inline modf_f64(f64(x))
 	return f64be(i), f64be(f)
 }
-modf       :: proc{
+modf :: proc{
 	modf_f16, modf_f16le, modf_f16be,
 	modf_f32, modf_f32le, modf_f32be,
 	modf_f64, modf_f64le, modf_f64be,
@@ -1127,13 +1127,11 @@ inf_f32be :: proc "contextless" (sign: int) -> f32be {
 	return f32be(inf_f64(sign))
 }
 inf_f64   :: proc "contextless" (sign: int) -> f64 {
-	v: u64
 	if sign >= 0 {
-		v = 0x7ff00000_00000000
+		return 0h7ff00000_00000000
 	} else {
-		v = 0xfff00000_00000000
+		return 0hfff00000_00000000
 	}
-	return transmute(f64)v
 }
 inf_f64le :: proc "contextless" (sign: int) -> f64le {
 	return f64le(inf_f64(sign))
@@ -1161,8 +1159,7 @@ nan_f32be :: proc "contextless" () -> f32be {
 	return f32be(nan_f64())
 }
 nan_f64   :: proc "contextless" () -> f64 {
-	v: u64 = 0x7ff80000_00000001
-	return transmute(f64)v
+	return 0h7ff80000_00000001
 }
 nan_f64le :: proc "contextless" () -> f64le {
 	return f64le(nan_f64())
diff --git a/core/math/math_gamma.odin b/core/math/math_gamma.odin
index 0a6188a9f..6b783cc25 100644
--- a/core/math/math_gamma.odin
+++ b/core/math/math_gamma.odin
@@ -68,17 +68,17 @@ package math
 @(private="file")
 stirling :: proc "contextless" (x: f64) -> (f64, f64) {
 	@(static) gamS := [?]f64{
-		7.87311395793093628397e-04,
+		+7.87311395793093628397e-04,
 		-2.29549961613378126380e-04,
 		-2.68132617805781232825e-03,
-		3.47222221605458667310e-03,
-		8.33333333333482257126e-02,
+		+3.47222221605458667310e-03,
+		+8.33333333333482257126e-02,
 	}
 	
 	if x > 200 {
 		return inf_f64(1), 1
 	}
-	SQRT_TWO_PI :: 2.506628274631000502417
+	SQRT_TWO_PI :: 0h40040d931ff62706 // 2.506628274631000502417
 	MAX_STIRLING :: 143.01608
 	w := 1 / x
 	w = 1 + w*((((gamS[0]*w+gamS[1])*w+gamS[2])*w+gamS[3])*w+gamS[4])
@@ -113,13 +113,13 @@ gamma_f64 :: proc "contextless" (x: f64) -> f64 {
 	}
 	@(static) gamQ := [?]f64{
 		-2.31581873324120129819e-05,
-		5.39605580493303397842e-04,
+		+5.39605580493303397842e-04,
 		-4.45641913851797240494e-03,
-		1.18139785222060435552e-02,
-		3.58236398605498653373e-02,
+		+1.18139785222060435552e-02,
+		+3.58236398605498653373e-02,
 		-2.34591795718243348568e-01,
-		7.14304917030273074085e-02,
-		1.00000000000000000320e+00,
+		+7.14304917030273074085e-02,
+		+1.00000000000000000320e+00,
 	}
 
 	
diff --git a/core/math/math_lgamma.odin b/core/math/math_lgamma.odin
index e6cbdf6cd..98b2731c9 100644
--- a/core/math/math_lgamma.odin
+++ b/core/math/math_lgamma.odin
@@ -197,9 +197,9 @@ lgamma_f64 :: proc "contextless" (x: f64) -> (lgamma: f64, sign: int) {
 	}
 
 	
-	Y_MIN  :: 1.461632144968362245
+	Y_MIN  :: 0h3ff762d86356be3f // 1.461632144968362245
 	TWO_52 :: 0h4330000000000000 // ~4.5036e+15
-	TWO_53  :: 0h4340000000000000 // ~9.0072e+15
+	TWO_53 :: 0h4340000000000000 // ~9.0072e+15
 	TWO_58 :: 0h4390000000000000 // ~2.8823e+17
 	TINY   :: 0h3b90000000000000 // ~8.47033e-22
 	Tc     :: 0h3FF762D86356BE3F
@@ -345,8 +345,8 @@ lgamma_f64 :: proc "contextless" (x: f64) -> (lgamma: f64, sign: int) {
 }
 
 
-lgamma_f16 :: proc "contextless" (x: f16) -> (lgamma: f16, sign: int) { r, s := lgamma_f64(f64(x)); return f16(r), s }
-lgamma_f32 :: proc "contextless" (x: f32) -> (lgamma: f32, sign: int) { r, s := lgamma_f64(f64(x)); return f32(r), s }
+lgamma_f16   :: proc "contextless" (x: f16)   -> (lgamma: f16, sign: int)   { r, s := lgamma_f64(f64(x)); return f16(r), s }
+lgamma_f32   :: proc "contextless" (x: f32)   -> (lgamma: f32, sign: int)   { r, s := lgamma_f64(f64(x)); return f32(r), s }
 lgamma_f16le :: proc "contextless" (x: f16le) -> (lgamma: f16le, sign: int) { r, s := lgamma_f64(f64(x)); return f16le(r), s }
 lgamma_f16be :: proc "contextless" (x: f16be) -> (lgamma: f16be, sign: int) { r, s := lgamma_f64(f64(x)); return f16be(r), s }
 lgamma_f32le :: proc "contextless" (x: f32le) -> (lgamma: f32le, sign: int) { r, s := lgamma_f64(f64(x)); return f32le(r), s }
diff --git a/core/math/math_log1p.odin b/core/math/math_log1p.odin
index 07e790666..a4a1aa2ae 100644
--- a/core/math/math_log1p.odin
+++ b/core/math/math_log1p.odin
@@ -100,11 +100,11 @@ log1p_f64le :: proc "contextless" (x: f64le) -> f64le { return f64le(log1p_f64(f
 log1p_f64be :: proc "contextless" (x: f64be) -> f64be { return f64be(log1p_f64(f64(x))) }
 
 log1p_f64 :: proc "contextless" (x: f64) -> f64 {
-	SQRT2_M1      :: 0h3fda827999fcef34 // Sqrt(2)-1 
-	SQRT2_HALF_M1 :: 0hbfd2bec333018866 // Sqrt(2)/2-1
+	SQRT2_M1      :: 0h3fda827999fcef34 // sqrt(2)-1 
+	SQRT2_HALF_M1 :: 0hbfd2bec333018866 // sqrt(2)/2-1
 	SMALL         :: 0h3e20000000000000 // 2**-29
-	TINY          :: 1.0 / (1 << 54)    // 2**-54
-	TWO53         :: 1 << 53            // 2**53
+	TINY          :: 0h3c90000000000000 // 2**-54
+	TWO53         :: 0h4340000000000000 // 2**53
 	LN2HI         :: 0h3fe62e42fee00000
 	LN2LO         :: 0h3dea39ef35793c76
 	LP1           :: 0h3FE5555555555593
@@ -128,15 +128,15 @@ log1p_f64 :: proc "contextless" (x: f64) -> f64 {
 	f: f64
 	iu: u64
 	k := 1
-	if absx < SQRT2_M1 { //  |x| < Sqrt(2)-1
+	if absx < SQRT2_M1 { //  |x| < sqrt(2)-1
 		if absx < SMALL { // |x| < 2**-29
 			if absx < TINY { // |x| < 2**-54
 				return x
 			}
 			return x - x*x*0.5
 		}
-		if x > SQRT2_HALF_M1 { // Sqrt(2)/2-1 < x
-			// (Sqrt(2)/2-1) < x < (Sqrt(2)-1)
+		if x > SQRT2_HALF_M1 { // sqrt(2)/2-1 < x
+			// (sqrt(2)/2-1) < x < (sqrt(2)-1)
 			k = 0
 			f = x
 			iu = 1
@@ -163,14 +163,14 @@ log1p_f64 :: proc "contextless" (x: f64) -> f64 {
 			c = 0
 		}
 		iu &= 0x000fffffffffffff
-		if iu < 0x0006a09e667f3bcd { // mantissa of Sqrt(2)
+		if iu < 0x0006a09e667f3bcd { // mantissa of sqrt(2)
 			u = transmute(f64)(iu | 0x3ff0000000000000) // normalize u
 		} else {
 			k += 1
 			u = transmute(f64)(iu | 0x3fe0000000000000) // normalize u/2
 			iu = (0x0010000000000000 - iu) >> 2
 		}
-		f = u - 1.0 // Sqrt(2)/2 < u < Sqrt(2)
+		f = u - 1.0 // sqrt(2)/2 < u < sqrt(2)
 	}
 	hfsq := 0.5 * f * f
 	s, R, z: f64

From de435c93187b042c52c6555d95efea97f908e33b Mon Sep 17 00:00:00 2001
From: gingerBill <bill@gingerbill.org>
Date: Sun, 21 Nov 2021 14:52:40 +0000
Subject: [PATCH 36/38] Remove unneeded semicolons from vendor:OpenGL

---
 vendor/OpenGL/constants.odin | 2 +-
 vendor/OpenGL/wrappers.odin  | 2 +-
 2 files changed, 2 insertions(+), 2 deletions(-)

diff --git a/vendor/OpenGL/constants.odin b/vendor/OpenGL/constants.odin
index c70fd4d95..28c923903 100644
--- a/vendor/OpenGL/constants.odin
+++ b/vendor/OpenGL/constants.odin
@@ -1409,4 +1409,4 @@ TRANSFORM_FEEDBACK_OVERFLOW    :: 0x82EC
 TRANSFORM_FEEDBACK_STREAM_OVERFLOW :: 0x82ED
 
 // Extensions, extended as necessary
-DEVICE_LUID_EXT :: 0x9599;
+DEVICE_LUID_EXT :: 0x9599
diff --git a/vendor/OpenGL/wrappers.odin b/vendor/OpenGL/wrappers.odin
index f3bd9166b..10a601eec 100644
--- a/vendor/OpenGL/wrappers.odin
+++ b/vendor/OpenGL/wrappers.odin
@@ -1,6 +1,6 @@
 package odin_gl
 
-#assert(size_of(bool) == size_of(u8));
+#assert(size_of(bool) == size_of(u8))
 
 when !ODIN_DEBUG {
 	// VERSION_1_0

From a55f0cfb631cc9e25d0e2de7f5ba0d047232237d Mon Sep 17 00:00:00 2001
From: Dale Weiler <weilercdale@gmail.com>
Date: Mon, 22 Nov 2021 10:25:54 -0500
Subject: [PATCH 37/38] fix memory leak in path.join

---
 core/path/path.odin | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/core/path/path.odin b/core/path/path.odin
index d54106b3a..186176b42 100644
--- a/core/path/path.odin
+++ b/core/path/path.odin
@@ -150,7 +150,7 @@ join :: proc(elems: ..string, allocator := context.allocator) -> string {
 	context.allocator = allocator
 	for elem, i in elems {
 		if elem != "" {
-			s := strings.join(elems[i:], "/")
+			s := strings.join(elems[i:], "/", context.temp_allocator)
 			return clean(s)
 		}
 	}

From 9246e89c4a0bb35048253c1c5bf6ea86c146b289 Mon Sep 17 00:00:00 2001
From: gingerBill <bill@gingerbill.org>
Date: Tue, 23 Nov 2021 11:43:32 +0000
Subject: [PATCH 38/38] Fix #1328

---
 src/llvm_backend_utility.cpp | 18 +++++-------------
 src/types.cpp                |  5 +++++
 2 files changed, 10 insertions(+), 13 deletions(-)

diff --git a/src/llvm_backend_utility.cpp b/src/llvm_backend_utility.cpp
index 46f7a22a3..0350f7287 100644
--- a/src/llvm_backend_utility.cpp
+++ b/src/llvm_backend_utility.cpp
@@ -179,32 +179,24 @@ lbValue lb_emit_transmute(lbProcedure *p, lbValue value, Type *t) {
 	GB_ASSERT_MSG(sz == dz, "Invalid transmute conversion: '%s' to '%s'", type_to_string(src_type), type_to_string(t));
 
 	// NOTE(bill): Casting between an integer and a pointer cannot be done through a bitcast
-	if (is_type_uintptr(src) && is_type_pointer(dst)) {
+	if (is_type_uintptr(src) && is_type_internally_pointer_like(dst)) {
 		res.value = LLVMBuildIntToPtr(p->builder, value.value, lb_type(m, t), "");
 		return res;
 	}
-	if (is_type_pointer(src) && is_type_uintptr(dst)) {
-		res.value = LLVMBuildPtrToInt(p->builder, value.value, lb_type(m, t), "");
-		return res;
-	}
-	if (is_type_uintptr(src) && is_type_proc(dst)) {
-		res.value = LLVMBuildIntToPtr(p->builder, value.value, lb_type(m, t), "");
-		return res;
-	}
-	if (is_type_proc(src) && is_type_uintptr(dst)) {
+	if (is_type_internally_pointer_like(src) && is_type_uintptr(dst)) {
 		res.value = LLVMBuildPtrToInt(p->builder, value.value, lb_type(m, t), "");
 		return res;
 	}
 
-	if (is_type_integer(src) && (is_type_pointer(dst) || is_type_cstring(dst))) {
+	if (is_type_integer(src) && is_type_internally_pointer_like(dst)) {
 		res.value = LLVMBuildIntToPtr(p->builder, value.value, lb_type(m, t), "");
 		return res;
-	} else if ((is_type_pointer(src) || is_type_cstring(src)) && is_type_integer(dst)) {
+	} else if (is_type_internally_pointer_like(src) && is_type_integer(dst)) {
 		res.value = LLVMBuildPtrToInt(p->builder, value.value, lb_type(m, t), "");
 		return res;
 	}
 
-	if (is_type_pointer(src) && is_type_pointer(dst)) {
+	if (is_type_internally_pointer_like(src) && is_type_internally_pointer_like(dst)) {
 		res.value = LLVMBuildPointerCast(p->builder, value.value, lb_type(p->module, t), "");
 		return res;
 	}
diff --git a/src/types.cpp b/src/types.cpp
index c8bdbd72a..2b7ea93dc 100644
--- a/src/types.cpp
+++ b/src/types.cpp
@@ -697,6 +697,7 @@ Type *   bit_set_to_int(Type *t);
 bool are_types_identical(Type *x, Type *y);
 
 bool is_type_pointer(Type *t);
+bool is_type_proc(Type *t);
 bool is_type_slice(Type *t);
 bool is_type_integer(Type *t);
 bool type_set_offsets(Type *t);
@@ -1284,6 +1285,10 @@ bool is_type_multi_pointer(Type *t) {
 	t = base_type(t);
 	return t->kind == Type_MultiPointer;
 }
+bool is_type_internally_pointer_like(Type *t) {
+	return is_type_pointer(t) || is_type_multi_pointer(t) || is_type_cstring(t) || is_type_proc(t);
+}
+
 bool is_type_tuple(Type *t) {
 	t = base_type(t);
 	return t->kind == Type_Tuple;