Strip even more semicolons if followed by a `}` or `)` on the same line

36 files changed, 2099 insertions, 2099 deletions

diff --git a/core/encoding/base64/base64.odin b/core/encoding/base64/base64.odin
index ca509326b..cf2ea1c12 100644
--- a/core/encoding/base64/base64.odin
+++ b/core/encoding/base64/base64.odin
@@ -53,8 +53,8 @@ encode :: proc(data: []byte, ENC_TBL := ENC_TABLE, allocator := context.allocato
     for i, d := 0, 0; i < length; i, d = i + 3, d + 4 {
         c0, c1, c2 = int(data[i]), -1, -1
 
-        if i + 1 < length { c1 = int(data[i + 1]); }
-        if i + 2 < length { c2 = int(data[i + 2]); }
+        if i + 1 < length { c1 = int(data[i + 1]) }
+        if i + 2 < length { c2 = int(data[i + 2]) }
 
         block = (c0 << 16) | (max(c1, 0) << 8) | max(c2, 0)
 
diff --git a/core/encoding/json/marshal.odin b/core/encoding/json/marshal.odin
index cea3c3df6..1e23ff0d3 100644
--- a/core/encoding/json/marshal.odin
+++ b/core/encoding/json/marshal.odin
@@ -163,7 +163,7 @@ marshal_arg :: proc(b: ^strings.Builder, v: any) -> Marshal_Error {
 	case runtime.Type_Info_Array:
 		strings.write_byte(b, '[')
 		for i in 0..<info.count {
-			if i > 0 { strings.write_string(b, ", "); }
+			if i > 0 { strings.write_string(b, ", ") }
 
 			data := uintptr(v.data) + uintptr(i*info.elem_size)
 			marshal_arg(b, any{rawptr(data), info.elem.id})
@@ -174,7 +174,7 @@ marshal_arg :: proc(b: ^strings.Builder, v: any) -> Marshal_Error {
 		strings.write_byte(b, '[')
 		array := cast(^mem.Raw_Dynamic_Array)v.data
 		for i in 0..<array.len {
-			if i > 0 { strings.write_string(b, ", "); }
+			if i > 0 { strings.write_string(b, ", ") }
 
 			data := uintptr(array.data) + uintptr(i*info.elem_size)
 			marshal_arg(b, any{rawptr(data), info.elem.id})
@@ -185,7 +185,7 @@ marshal_arg :: proc(b: ^strings.Builder, v: any) -> Marshal_Error {
 		strings.write_byte(b, '[')
 		slice := cast(^mem.Raw_Slice)v.data
 		for i in 0..<slice.len {
-			if i > 0 { strings.write_string(b, ", "); }
+			if i > 0 { strings.write_string(b, ", ") }
 
 			data := uintptr(slice.data) + uintptr(i*info.elem_size)
 			marshal_arg(b, any{rawptr(data), info.elem.id})
@@ -207,7 +207,7 @@ marshal_arg :: proc(b: ^strings.Builder, v: any) -> Marshal_Error {
 			entry_size := ed.elem_size
 
 			for i in 0..<entries.len {
-				if i > 0 { strings.write_string(b, ", "); }
+				if i > 0 { strings.write_string(b, ", ") }
 
 				data := uintptr(entries.data) + uintptr(i*entry_size)
 				key   := rawptr(data + entry_type.offsets[2])
@@ -223,7 +223,7 @@ marshal_arg :: proc(b: ^strings.Builder, v: any) -> Marshal_Error {
 	case runtime.Type_Info_Struct:
 		strings.write_byte(b, '{')
 		for name, i in info.names {
-			if i > 0 { strings.write_string(b, ", "); }
+			if i > 0 { strings.write_string(b, ", ") }
 			strings.write_quoted_string(b, name)
 			strings.write_string(b, ": ")
 
diff --git a/core/fmt/fmt.odin b/core/fmt/fmt.odin
index 8c667390f..ca51be3b6 100644
--- a/core/fmt/fmt.odin
+++ b/core/fmt/fmt.odin
@@ -85,13 +85,13 @@ fprint_typeid :: proc(fd: os.Handle, id: typeid) -> int {
 }
 
 // print* procedures return the number of bytes written
-print   :: proc(args: ..any, sep := " ") -> int { return fprint(fd=os.stdout, args=args, sep=sep); }
-println :: proc(args: ..any, sep := " ") -> int { return fprintln(fd=os.stdout, args=args, sep=sep); }
-printf  :: proc(fmt: string, args: ..any) -> int { return fprintf(os.stdout, fmt, ..args); }
+print   :: proc(args: ..any, sep := " ") -> int { return fprint(fd=os.stdout, args=args, sep=sep) }
+println :: proc(args: ..any, sep := " ") -> int { return fprintln(fd=os.stdout, args=args, sep=sep) }
+printf  :: proc(fmt: string, args: ..any) -> int { return fprintf(os.stdout, fmt, ..args) }
 
-eprint   :: proc(args: ..any, sep := " ") -> int { return fprint(fd=os.stderr, args=args, sep=sep); }
-eprintln :: proc(args: ..any, sep := " ") -> int { return fprintln(fd=os.stderr, args=args, sep=sep); }
-eprintf  :: proc(fmt: string, args: ..any) -> int { return fprintf(os.stderr, fmt, ..args); }
+eprint   :: proc(args: ..any, sep := " ") -> int { return fprint(fd=os.stderr, args=args, sep=sep) }
+eprintln :: proc(args: ..any, sep := " ") -> int { return fprintln(fd=os.stderr, args=args, sep=sep) }
+eprintf  :: proc(fmt: string, args: ..any) -> int { return fprintf(os.stderr, fmt, ..args) }
 
 
 // aprint* procedures return a string that was allocated with the current context
@@ -688,9 +688,9 @@ _fmt_int :: proc(fi: ^Info, u: u64, base: int, is_signed: bool, bit_size: int, d
 	start := 0
 
 	flags: strconv.Int_Flags
-	if fi.hash && !fi.zero { flags |= {.Prefix}; }
-	if fi.plus             { flags |= {.Plus};   }
-	if fi.space            { flags |= {.Space};  }
+	if fi.hash && !fi.zero { flags |= {.Prefix} }
+	if fi.plus             { flags |= {.Plus}   }
+	if fi.space            { flags |= {.Space}  }
 	s := strconv.append_bits(buf[start:], u, base, is_signed, bit_size, digits, flags)
 
 	if fi.hash && fi.zero && fi.indent == 0 {
@@ -754,9 +754,9 @@ _fmt_int_128 :: proc(fi: ^Info, u: u128, base: int, is_signed: bool, bit_size: i
 	start := 0
 
 	flags: strconv.Int_Flags
-	if fi.hash && !fi.zero { flags |= {.Prefix}; }
-	if fi.plus             { flags |= {.Plus};   }
-	if fi.space            { flags |= {.Space};  }
+	if fi.hash && !fi.zero { flags |= {.Prefix} }
+	if fi.plus             { flags |= {.Plus}   }
+	if fi.space            { flags |= {.Space}  }
 	s := strconv.append_bits_128(buf[start:], u, base, is_signed, bit_size, digits, flags)
 
 	if fi.hash && fi.zero && fi.indent == 0 {
@@ -1154,19 +1154,19 @@ fmt_bit_set :: proc(fi: ^Info, v: any, name: string = "") {
 			bits = u128(x)
 		case 16:
 			x := (^u16)(v.data)^
-			if do_byte_swap { x = byte_swap(x); }
+			if do_byte_swap { x = byte_swap(x) }
 			bits = u128(x)
 		case 32:
 			x := (^u32)(v.data)^
-			if do_byte_swap { x = byte_swap(x); }
+			if do_byte_swap { x = byte_swap(x) }
 			bits = u128(x)
 		case 64:
 			x := (^u64)(v.data)^
-			if do_byte_swap { x = byte_swap(x); }
+			if do_byte_swap { x = byte_swap(x) }
 			bits = u128(x)
 		case 128:
 			x := (^u128)(v.data)^
-			if do_byte_swap { x = byte_swap(x); }
+			if do_byte_swap { x = byte_swap(x) }
 			bits = x
 		case: panic("unknown bit_size size")
 		}
@@ -1237,7 +1237,7 @@ fmt_write_array :: proc(fi: ^Info, array_data: rawptr, count: int, elem_size: in
 		}
 	} else {
 		for i in 0..<count {
-			if i > 0 { io.write_string(fi.writer, ", "); }
+			if i > 0 { io.write_string(fi.writer, ", ") }
 
 			data := uintptr(array_data) + uintptr(i*elem_size)
 			fmt_arg(fi, any{rawptr(data), elem_id}, verb)
@@ -1437,7 +1437,7 @@ fmt_value :: proc(fi: ^Info, v: any, verb: rune) {
 			}
 			defer {
 				if hash {
-					for in 0..<indent { io.write_byte(fi.writer, '\t'); }
+					for in 0..<indent { io.write_byte(fi.writer, '\t') }
 				}
 				io.write_byte(fi.writer, ']' if is_soa else '}')
 			}
@@ -1452,11 +1452,11 @@ fmt_value :: proc(fi: ^Info, v: any, verb: rune) {
 				}
 
 				for index in 0..<uintptr(b.soa_len) {
-					if !hash && index > 0 { io.write_string(fi.writer, ", "); }
+					if !hash && index > 0 { io.write_string(fi.writer, ", ") }
 
 					field_count := -1
 
-					if !hash && field_count > 0 { io.write_string(fi.writer, ", "); }
+					if !hash && field_count > 0 { io.write_string(fi.writer, ", ") }
 
 					io.write_string(fi.writer, base_type_name)
 					io.write_byte(fi.writer, '{')
@@ -1465,7 +1465,7 @@ fmt_value :: proc(fi: ^Info, v: any, verb: rune) {
 					for name, i in b.names {
 						field_count += 1
 
-						if !hash && field_count > 0 { io.write_string(fi.writer, ", "); }
+						if !hash && field_count > 0 { io.write_string(fi.writer, ", ") }
 						if hash {
 							fmt_write_indent(fi)
 						}
@@ -1482,7 +1482,7 @@ fmt_value :: proc(fi: ^Info, v: any, verb: rune) {
 							fmt_arg(fi, any{data, t.id}, 'v')
 						}
 
-						if hash { io.write_string(fi.writer, ",\n"); }
+						if hash { io.write_string(fi.writer, ",\n") }
 					}
 				}
 			} else {
@@ -1490,7 +1490,7 @@ fmt_value :: proc(fi: ^Info, v: any, verb: rune) {
 				for name, i in b.names {
 					field_count += 1
 
-					if !hash && field_count > 0 { io.write_string(fi.writer, ", "); }
+					if !hash && field_count > 0 { io.write_string(fi.writer, ", ") }
 					if hash {
 						fmt_write_indent(fi)
 					}
@@ -1505,7 +1505,7 @@ fmt_value :: proc(fi: ^Info, v: any, verb: rune) {
 						fmt_arg(fi, any{data, t.id}, 'v')
 					}
 
-					if hash { io.write_string(fi.writer, ",\n"); }
+					if hash { io.write_string(fi.writer, ",\n") }
 				}
 			}
 
@@ -1652,7 +1652,7 @@ fmt_value :: proc(fi: ^Info, v: any, verb: rune) {
 			io.write_byte(fi.writer, '[')
 			defer io.write_byte(fi.writer, ']')
 			for i in 0..<info.count {
-				if i > 0 { io.write_string(fi.writer, ", "); }
+				if i > 0 { io.write_string(fi.writer, ", ") }
 
 				idx, ok := stored_enum_value_to_string(info.index, info.min_value, i)
 				if ok {
@@ -1683,7 +1683,7 @@ fmt_value :: proc(fi: ^Info, v: any, verb: rune) {
 		io.write_byte(fi.writer, '<')
 		defer io.write_byte(fi.writer, '>')
 		for i in 0..<info.count {
-			if i > 0 { io.write_string(fi.writer, ", "); }
+			if i > 0 { io.write_string(fi.writer, ", ") }
 
 			data := uintptr(v.data) + uintptr(i*info.elem_size)
 			fmt_arg(fi, any{rawptr(data), info.elem.id}, verb)
@@ -1721,7 +1721,7 @@ fmt_value :: proc(fi: ^Info, v: any, verb: rune) {
 			entry_size := ed.elem_size
 
 			for i in 0..<entries.len {
-				if i > 0 { io.write_string(fi.writer, ", "); }
+				if i > 0 { io.write_string(fi.writer, ", ") }
 
 				data := uintptr(entries.data) + uintptr(i*entry_size)
 
@@ -1751,7 +1751,7 @@ fmt_value :: proc(fi: ^Info, v: any, verb: rune) {
 		// fi.hash = false;
 
 
-		if hash	{ io.write_byte(fi.writer, '\n'); }
+		if hash	{ io.write_byte(fi.writer, '\n') }
 
 		if is_soa {
 			fi.indent += 1
@@ -1780,11 +1780,11 @@ fmt_value :: proc(fi: ^Info, v: any, verb: rune) {
 
 
 			for index in 0..<n {
-				if !hash && index > 0 { io.write_string(fi.writer, ", "); }
+				if !hash && index > 0 { io.write_string(fi.writer, ", ") }
 
 				field_count := -1
 
-				if !hash && field_count > 0 { io.write_string(fi.writer, ", "); }
+				if !hash && field_count > 0 { io.write_string(fi.writer, ", ") }
 
 				io.write_string(fi.writer, base_type_name)
 				io.write_byte(fi.writer, '{')
@@ -1794,7 +1794,7 @@ fmt_value :: proc(fi: ^Info, v: any, verb: rune) {
 					name := info.names[i]
 					field_count += 1
 
-					if !hash && field_count > 0 { io.write_string(fi.writer, ", "); }
+					if !hash && field_count > 0 { io.write_string(fi.writer, ", ") }
 					if hash {
 						fmt_write_indent(fi)
 					}
@@ -1823,7 +1823,7 @@ fmt_value :: proc(fi: ^Info, v: any, verb: rune) {
 						}
 					}
 
-					if hash { io.write_string(fi.writer, ",\n"); }
+					if hash { io.write_string(fi.writer, ",\n") }
 				}
 			}
 		} else {
@@ -1831,7 +1831,7 @@ fmt_value :: proc(fi: ^Info, v: any, verb: rune) {
 			for name, i in info.names {
 				field_count += 1
 
-				if !hash && field_count > 0 { io.write_string(fi.writer, ", "); }
+				if !hash && field_count > 0 { io.write_string(fi.writer, ", ") }
 				if hash {
 					fmt_write_indent(fi)
 				}
@@ -1942,7 +1942,7 @@ fmt_value :: proc(fi: ^Info, v: any, verb: rune) {
 			defer io.write_byte(fi.writer, ']')
 
 			for i in 0..<len {
-				if i > 0 { io.write_string(fi.writer, ", "); }
+				if i > 0 { io.write_string(fi.writer, ", ") }
 
 				data := uintptr(ptr) + uintptr(i*slice_type.elem_size)
 				fmt_arg(fi, any{rawptr(data), slice_type.elem.id}, verb)
diff --git a/core/log/file_console_logger.odin b/core/log/file_console_logger.odin
index a3070cd0b..cc019617f 100644
--- a/core/log/file_console_logger.odin
+++ b/core/log/file_console_logger.odin
@@ -77,8 +77,8 @@ file_console_logger_proc :: proc(logger_data: rawptr, level: Level, text: string
 			t := time.now()
 			y, m, d := time.date(t)
 			h, min, s := time.clock(t)
-			if .Date in options { fmt.sbprintf(&buf, "%d-%02d-%02d ", y, m, d);    }
-			if .Time in options { fmt.sbprintf(&buf, "%02d:%02d:%02d", h, min, s); }
+			if .Date in options { fmt.sbprintf(&buf, "%d-%02d-%02d ", y, m, d)    }
+			if .Time in options { fmt.sbprintf(&buf, "%02d:%02d:%02d", h, min, s) }
 			fmt.sbprint(&buf, "] ")
 		}
 	}
diff --git a/core/math/big/common.odin b/core/math/big/common.odin
index 643e8b49d..c43346f5a 100644
--- a/core/math/big/common.odin
+++ b/core/math/big/common.odin
@@ -87,7 +87,7 @@ FACTORIAL_BINARY_SPLIT_MAX_RECURSIONS := 100
 */
 MATH_BIG_FORCE_64_BIT :: #config(MATH_BIG_FORCE_64_BIT, false)
 MATH_BIG_FORCE_32_BIT :: #config(MATH_BIG_FORCE_32_BIT, false)
-when (MATH_BIG_FORCE_32_BIT && MATH_BIG_FORCE_64_BIT) { #panic("Cannot force 32-bit and 64-bit big backend simultaneously."); }
+when (MATH_BIG_FORCE_32_BIT && MATH_BIG_FORCE_64_BIT) { #panic("Cannot force 32-bit and 64-bit big backend simultaneously.") }
 
 _LOW_MEMORY           :: #config(BIGINT_SMALL_MEMORY, false)
 when _LOW_MEMORY {
diff --git a/core/math/big/helpers.odin b/core/math/big/helpers.odin
index 6b01fc241..45c6771da 100644
--- a/core/math/big/helpers.odin
+++ b/core/math/big/helpers.odin
@@ -56,7 +56,7 @@ int_copy :: proc(dest, src: ^Int, minimize := false, allocator := context.alloca
 	/*
 		If dest == src, do nothing
 	*/
-	if (dest == src) { return nil; }
+	if (dest == src) { return nil }
 
 	/*
 		Check that `src` is usable and `dest` isn't immutable.
@@ -383,7 +383,7 @@ assert_initialized :: proc(a: ^Int, loc := #caller_location) {
 
 zero_unused :: proc(dest: ^Int, old_used := -1) {
 	assert_if_nil(dest)
-	if ! #force_inline is_initialized(dest) { return; }
+	if ! #force_inline is_initialized(dest) { return }
 
 	#force_inline internal_zero_unused(dest, old_used)
 }
@@ -405,13 +405,13 @@ clear_if_uninitialized_multi :: proc(args: ..^Int, allocator := context.allocato
 clear_if_uninitialized :: proc {clear_if_uninitialized_single, clear_if_uninitialized_multi, }
 
 error_if_immutable_single :: proc(arg: ^Int) -> (err: Error) {
-	if arg != nil && .Immutable in arg.flags { return .Assignment_To_Immutable; }
+	if arg != nil && .Immutable in arg.flags { return .Assignment_To_Immutable }
 	return nil
 }
 
 error_if_immutable_multi :: proc(args: ..^Int) -> (err: Error) {
 	for i in args {
-		if i != nil && .Immutable in i.flags { return .Assignment_To_Immutable; }
+		if i != nil && .Immutable in i.flags { return .Assignment_To_Immutable }
 	}
 	return nil
 }
@@ -489,7 +489,7 @@ int_to_bytes_little :: proc(a: ^Int, buf: []u8, signed := false, allocator := co
 
 	size_in_bytes := int_to_bytes_size(a, signed, allocator) or_return
 	l := len(buf)
-	if size_in_bytes > l { return .Buffer_Overflow; }
+	if size_in_bytes > l { return .Buffer_Overflow }
 
 	size_in_bits := internal_count_bits(a)
 	i := 0
@@ -512,7 +512,7 @@ int_to_bytes_big :: proc(a: ^Int, buf: []u8, signed := false, allocator := conte
 
 	size_in_bytes := int_to_bytes_size(a, signed, allocator) or_return
 	l := len(buf)
-	if size_in_bytes > l { return .Buffer_Overflow; }
+	if size_in_bytes > l { return .Buffer_Overflow }
 
 	size_in_bits := internal_count_bits(a)
 	i := l - 1
@@ -534,11 +534,11 @@ int_to_bytes_big :: proc(a: ^Int, buf: []u8, signed := false, allocator := conte
 int_to_bytes_little_python :: proc(a: ^Int, buf: []u8, signed := false, allocator := context.allocator) -> (err: Error) {
 	assert_if_nil(a)
 
-	if !signed && a.sign == .Negative { return .Invalid_Argument; }
+	if !signed && a.sign == .Negative { return .Invalid_Argument }
 
 	l := len(buf)
 	size_in_bytes := int_to_bytes_size(a, signed, allocator) or_return
-	if size_in_bytes > l { return .Buffer_Overflow;  }
+	if size_in_bytes > l { return .Buffer_Overflow  }
 
 	if a.sign == .Negative {
 		t := &Int{}
@@ -570,12 +570,12 @@ int_to_bytes_little_python :: proc(a: ^Int, buf: []u8, signed := false, allocato
 int_to_bytes_big_python :: proc(a: ^Int, buf: []u8, signed := false, allocator := context.allocator) -> (err: Error) {
 	assert_if_nil(a)
 
-	if !signed && a.sign == .Negative { return .Invalid_Argument; }
-	if a.sign == .Zero_or_Positive    { return int_to_bytes_big(a, buf, signed, allocator); }
+	if !signed && a.sign == .Negative { return .Invalid_Argument }
+	if a.sign == .Zero_or_Positive    { return int_to_bytes_big(a, buf, signed, allocator) }
 
 	l := len(buf)
 	size_in_bytes := int_to_bytes_size(a, signed, allocator) or_return
-	if size_in_bytes > l { return .Buffer_Overflow;  }
+	if size_in_bytes > l { return .Buffer_Overflow  }
 
 	t := &Int{}
 	defer destroy(t)
@@ -601,7 +601,7 @@ int_from_bytes_big :: proc(a: ^Int, buf: []u8, signed := false, allocator := con
 	assert_if_nil(a)
 	buf := buf
 	l := len(buf)
-	if l == 0 { return .Invalid_Argument; }
+	if l == 0 { return .Invalid_Argument }
 
 	sign: Sign
 	size_in_bits := l * 8
@@ -638,7 +638,7 @@ int_from_bytes_big_python :: proc(a: ^Int, buf: []u8, signed := false, allocator
 	assert_if_nil(a)
 	buf := buf
 	l := len(buf)
-	if l == 0 { return .Invalid_Argument; }
+	if l == 0 { return .Invalid_Argument }
 
 	sign: Sign
 	size_in_bits := l * 8
@@ -684,7 +684,7 @@ int_from_bytes_little :: proc(a: ^Int, buf: []u8, signed := false, allocator :=
 	assert_if_nil(a)
 	buf := buf
 	l := len(buf)
-	if l == 0 { return .Invalid_Argument; }
+	if l == 0 { return .Invalid_Argument }
 
 	sign: Sign
 	size_in_bits   := l * 8
@@ -722,7 +722,7 @@ int_from_bytes_little_python :: proc(a: ^Int, buf: []u8, signed := false, alloca
 	assert_if_nil(a)
 	buf := buf
 	l := len(buf)
-	if l == 0 { return .Invalid_Argument; }
+	if l == 0 { return .Invalid_Argument }
 
 	sign: Sign
 	size_in_bits := l * 8
diff --git a/core/math/big/internal.odin b/core/math/big/internal.odin
index b0e0c1f5d..63c702f5e 100644
--- a/core/math/big/internal.odin
+++ b/core/math/big/internal.odin
@@ -628,7 +628,7 @@ internal_int_mul :: proc(dest, src, multiplier: ^Int, allocator := context.alloc
 	/*
 		Early out for `multiplier` is zero; Set `dest` to zero.
 	*/
-	if multiplier.used == 0 || src.used == 0 { return internal_zero(dest); }
+	if multiplier.used == 0 || src.used == 0 { return internal_zero(dest) }
 
 	neg := src.sign != multiplier.sign
 
@@ -715,7 +715,7 @@ internal_sqr :: proc (dest, src: ^Int, allocator := context.allocator) -> (res:
 */
 internal_int_divmod :: proc(quotient, remainder, numerator, denominator: ^Int, allocator := context.allocator) -> (err: Error) {
 	context.allocator = allocator
-	if denominator.used == 0 { return .Division_by_Zero; }
+	if denominator.used == 0 { return .Division_by_Zero }
 	/*
 		If numerator < denominator then quotient = 0, remainder = numerator.
 	*/
@@ -757,7 +757,7 @@ internal_int_divmod_digit :: proc(quotient, numerator: ^Int, denominator: DIGIT,
 	/*
 		Cannot divide by zero.
 	*/
-	if denominator == 0 { return 0, .Division_by_Zero; }
+	if denominator == 0 { return 0, .Division_by_Zero }
 
 	/*
 		Quick outs.
@@ -854,7 +854,7 @@ internal_div :: proc { internal_int_div, }
 internal_int_mod :: proc(remainder, numerator, denominator: ^Int, allocator := context.allocator) -> (err: Error) {
 	#force_inline internal_int_divmod(nil, remainder, numerator, denominator, allocator) or_return
 
-	if remainder.used == 0 || denominator.sign == remainder.sign { return nil; }
+	if remainder.used == 0 || denominator.sign == remainder.sign { return nil }
 
 	return #force_inline internal_add(remainder, remainder, numerator, allocator)
 }
@@ -937,7 +937,7 @@ internal_int_factorial :: proc(res: ^Int, n: int, allocator := context.allocator
 	`res_gcd` and `res_lcm` can be nil or ^Int depending on which results are desired.
 */
 internal_int_gcd_lcm :: proc(res_gcd, res_lcm, a, b: ^Int, allocator := context.allocator) -> (err: Error) {
-	if res_gcd == nil && res_lcm == nil { return nil; }
+	if res_gcd == nil && res_lcm == nil { return nil }
 
 	return #force_inline _private_int_gcd_lcm(res_gcd, res_lcm, a, b, allocator)
 }
@@ -951,7 +951,7 @@ internal_int_mod_bits :: proc(remainder, numerator: ^Int, bits: int, allocator :
 	/*
 		Everything is divisible by 1 << 0 == 1, so this returns 0.
 	*/
-	if bits == 0 { return internal_zero(remainder); }
+	if bits == 0 { return internal_zero(remainder) }
 
 	/*
 		If the modulus is larger than the value, return the value.
@@ -1034,7 +1034,7 @@ internal_is_negative :: proc { internal_int_is_negative, }
 	Assumes `a` not to be `nil`.
 */
 internal_int_is_even :: #force_inline proc(a: ^Int) -> (even: bool) {
-	if internal_is_zero(a) { return true; }
+	if internal_is_zero(a) { return true }
 
 	/*
 		`a.used` > 0 here, because the above handled `is_zero`.
@@ -1062,23 +1062,23 @@ internal_int_is_power_of_two :: #force_inline proc(a: ^Int) -> (power_of_two: bo
 	/*
 		Early out for Int == 0.
 	*/
-	if #force_inline internal_is_zero(a) { return true; }
+	if #force_inline internal_is_zero(a) { return true }
 
 	/*
 		For an `Int` to be a power of two, its bottom limb has to be a power of two.
 	*/
-	if ! #force_inline platform_int_is_power_of_two(int(a.digit[a.used - 1])) { return false; }
+	if ! #force_inline platform_int_is_power_of_two(int(a.digit[a.used - 1])) { return false }
 
 	/*
 		We've established that the bottom limb is a power of two.
 		If it's the only limb, that makes the entire Int a power of two.
 	*/
-	if a.used == 1 { return true; }
+	if a.used == 1 { return true }
 
 	/*
 		For an `Int` to be a power of two, all limbs except the top one have to be zero.
 	*/
-	for i := 1; i < a.used && a.digit[i - 1] != 0; i += 1 { return false; }
+	for i := 1; i < a.used && a.digit[i - 1] != 0; i += 1 { return false }
 
 	return true
 }
@@ -1096,11 +1096,11 @@ internal_int_compare :: #force_inline proc(a, b: ^Int) -> (comparison: int) {
 	/*
 		Compare based on sign.
 	*/
-	if a.sign != b.sign { return -1 if a_is_negative else +1; }
+	if a.sign != b.sign { return -1 if a_is_negative else +1 }
 
 	/*
 		If `a` is negative, compare in the opposite direction */
-	if a_is_negative { return #force_inline internal_compare_magnitude(b, a); }
+	if a_is_negative { return #force_inline internal_compare_magnitude(b, a) }
 
 	return #force_inline internal_compare_magnitude(a, b)
 }
@@ -1186,20 +1186,20 @@ internal_int_is_square :: proc(a: ^Int, allocator := context.allocator) -> (squa
 	*/
 	square = false
 
-	if internal_is_negative(a)                                       { return; }
-	if internal_is_zero(a)                                           { return; }
+	if internal_is_negative(a)                                       { return }
+	if internal_is_zero(a)                                           { return }
 
 	/*
 		First check mod 128 (suppose that _DIGIT_BITS is at least 7).
 	*/
-	if _private_int_rem_128[127 & a.digit[0]] == 1                   { return; }
+	if _private_int_rem_128[127 & a.digit[0]] == 1                   { return }
 
 	/*
 		Next check mod 105 (3*5*7).
 	*/
 	c: DIGIT
 	c, err = internal_mod(a, 105)
-	if _private_int_rem_105[c] == 1                                  { return; }
+	if _private_int_rem_105[c] == 1                                  { return }
 
 	t := &Int{}
 	defer destroy(t)
@@ -1215,13 +1215,13 @@ internal_int_is_square :: proc(a: ^Int, allocator := context.allocator) -> (squa
 		free "t" so the easiest way is to goto LBL_ERR.  We know that err
 		is already equal to MP_OKAY from the mp_mod call
 	*/
-	if (1 << (r % 11) &      0x5C4) != 0                             { return; }
-	if (1 << (r % 13) &      0x9E4) != 0                             { return; }
-	if (1 << (r % 17) &     0x5CE8) != 0                             { return; }
-	if (1 << (r % 19) &    0x4F50C) != 0                             { return; }
-	if (1 << (r % 23) &   0x7ACCA0) != 0                             { return; }
-	if (1 << (r % 29) &  0xC2EDD0C) != 0                             { return; }
-	if (1 << (r % 31) & 0x6DE2B848) != 0                             { return; }
+	if (1 << (r % 11) &      0x5C4) != 0                             { return }
+	if (1 << (r % 13) &      0x9E4) != 0                             { return }
+	if (1 << (r % 17) &     0x5CE8) != 0                             { return }
+	if (1 << (r % 19) &    0x4F50C) != 0                             { return }
+	if (1 << (r % 23) &   0x7ACCA0) != 0                             { return }
+	if (1 << (r % 29) &  0xC2EDD0C) != 0                             { return }
+	if (1 << (r % 31) & 0x6DE2B848) != 0                             { return }
 
 	/*
 		Final check - is sqr(sqrt(arg)) == arg?
@@ -1243,20 +1243,20 @@ internal_int_is_square :: proc(a: ^Int, allocator := context.allocator) -> (squa
 	Assumes `a` to not be `nil` and have been iniialized.
 */
 internal_int_log :: proc(a: ^Int, base: DIGIT) -> (res: int, err: Error) {
-	if base < 2 || DIGIT(base) > _DIGIT_MAX { return -1, .Invalid_Argument; }
+	if base < 2 || DIGIT(base) > _DIGIT_MAX { return -1, .Invalid_Argument }
 
-	if internal_is_negative(a) { return -1, .Math_Domain_Error; }
-	if internal_is_zero(a)     { return -1, .Math_Domain_Error; }
+	if internal_is_negative(a) { return -1, .Math_Domain_Error }
+	if internal_is_zero(a)     { return -1, .Math_Domain_Error }
 
 	/*
 		Fast path for bases that are a power of two.
 	*/
-	if platform_int_is_power_of_two(int(base)) { return _private_log_power_of_two(a, base); }
+	if platform_int_is_power_of_two(int(base)) { return _private_log_power_of_two(a, base) }
 
 	/*
 		Fast path for `Int`s that fit within a single `DIGIT`.
 	*/
-	if a.used == 1 { return internal_log(a.digit[0], DIGIT(base)); }
+	if a.used == 1 { return internal_log(a.digit[0], DIGIT(base)) }
 
 	return _private_int_log(a, base)
 
@@ -1270,12 +1270,12 @@ internal_digit_log :: proc(a: DIGIT, base: DIGIT) -> (log: int, err: Error) {
 		If the number is smaller than the base, it fits within a fraction.
 		Therefore, we return 0.
 	*/
-	if a  < base { return 0, nil; }
+	if a  < base { return 0, nil }
 
 	/*
 		If a number equals the base, the log is 1.
 	*/
-	if a == base { return 1, nil; }
+	if a == base { return 1, nil }
 
 	N := _WORD(a)
 	bracket_low  := _WORD(1)
@@ -1334,8 +1334,8 @@ internal_int_pow :: proc(dest, base: ^Int, power: int, allocator := context.allo
 			internal_zero(dest) or_return
 			return .Math_Domain_Error
 		}
-		if power == 0 { return  internal_one(dest); }
-		if power  > 0 { return internal_zero(dest); }
+		if power == 0 { return  internal_one(dest) }
+		if power  > 0 { return internal_zero(dest) }
 
 	}
 	if power < 0 {
@@ -1435,12 +1435,12 @@ internal_int_sqrt :: proc(dest, src: ^Int, allocator := context.allocator) -> (e
 	/*
 		Must be positive.
 	*/
-	if #force_inline internal_is_negative(src)  { return .Invalid_Argument; }
+	if #force_inline internal_is_negative(src)  { return .Invalid_Argument }
 
 	/*
 		Easy out. If src is zero, so is dest.
 	*/
-	if #force_inline internal_is_zero(src)      { return internal_zero(dest); }
+	if #force_inline internal_is_zero(src)      { return internal_zero(dest) }
 
 	/*
 		Set up temporaries.
@@ -1489,11 +1489,11 @@ internal_int_root_n :: proc(dest, src: ^Int, n: int, allocator := context.alloca
 	/*
 		Fast path for n == 2
 	*/
-	if n == 2 { return #force_inline internal_sqrt(dest, src); }
+	if n == 2 { return #force_inline internal_sqrt(dest, src) }
 
-	if n < 0 || n > int(_DIGIT_MAX) { return .Invalid_Argument; }
+	if n < 0 || n > int(_DIGIT_MAX) { return .Invalid_Argument }
 
-	if n & 1 == 0 && #force_inline internal_is_negative(src) { return .Invalid_Argument; }
+	if n & 1 == 0 && #force_inline internal_is_negative(src) { return .Invalid_Argument }
 
 	/*
 		Set up temporaries.
@@ -1576,8 +1576,8 @@ internal_int_root_n :: proc(dest, src: ^Int, n: int, allocator := context.alloca
 			 Number of rounds is at most log_2(root). If it is more it
 			 got stuck, so break out of the loop and do the rest manually.
 		*/
-		if ilog2 -= 1;    ilog2 == 0 { break; }
-		if internal_cmp(t1, t2) == 0 { break; }
+		if ilog2 -= 1;    ilog2 == 0 { break }
+		if internal_cmp(t1, t2) == 0 { break }
 
 		iterations += 1
 		if iterations == MAX_ITERATIONS_ROOT_N {
@@ -1615,7 +1615,7 @@ internal_int_root_n :: proc(dest, src: ^Int, n: int, allocator := context.alloca
 	for {
 		internal_pow(t2, t1, n) or_return
 	
-		if internal_cmp(t2, a) != 1 { break; }
+		if internal_cmp(t2, a) != 1 { break }
 		
 		internal_sub(t1, t1, DIGIT(1)) or_return
 
@@ -1712,7 +1712,7 @@ internal_int_copy :: proc(dest, src: ^Int, minimize := false, allocator := conte
 	/*
 		If dest == src, do nothing
 	*/
-	if (dest == src) { return nil; }
+	if (dest == src) { return nil }
 
 	internal_error_if_immutable(dest) or_return
 
@@ -1821,17 +1821,17 @@ internal_int_inverse_modulo :: proc(dest, a, b: ^Int, allocator := context.alloc
 	/*
 		For all n in N and n > 0, n = 0 mod 1.
 	*/
-	if internal_is_positive(a) && internal_cmp(b, 1) == 0 { return internal_zero(dest);	}
+	if internal_is_positive(a) && internal_cmp(b, 1) == 0 { return internal_zero(dest)	}
 
 	/*
 		`b` cannot be negative and has to be > 1
 	*/
-	if internal_is_negative(b) && internal_cmp(b, 1) != 1 { return .Invalid_Argument; }
+	if internal_is_negative(b) && internal_cmp(b, 1) != 1 { return .Invalid_Argument }
 
 	/*
 		If the modulus is odd we can use a faster routine instead.
 	*/
-	if internal_is_odd(b) { return _private_inverse_modulo_odd(dest, a, b); }
+	if internal_is_odd(b) { return _private_inverse_modulo_odd(dest, a, b) }
 
 	return _private_inverse_modulo(dest, a, b)
 }
@@ -1850,12 +1850,12 @@ internal_int_bitfield_extract :: proc(a: ^Int, offset, count: int) -> (res: _WOR
 	*/
 	if count == 1 {
 		limb := offset / _DIGIT_BITS
-		if limb < 0 || limb >= a.used  { return 0, .Invalid_Argument; }
+		if limb < 0 || limb >= a.used  { return 0, .Invalid_Argument }
 		i := _WORD(1 << _WORD((offset % _DIGIT_BITS)))
 		return 1 if ((_WORD(a.digit[limb]) & i) != 0) else 0, nil
 	}
 
-	if count > _WORD_BITS || count < 1 { return 0, .Invalid_Argument; }
+	if count > _WORD_BITS || count < 1 { return 0, .Invalid_Argument }
 
 	/*
 		There are 3 possible cases.
@@ -1880,7 +1880,7 @@ internal_int_bitfield_extract :: proc(a: ^Int, offset, count: int) -> (res: _WOR
 	res          = (_WORD(a.digit[limb]) >> uint(shift)) & mask
 
 	bits_left -= num_bits
-	if bits_left == 0 { return res, nil; }
+	if bits_left == 0 { return res, nil }
 
 	res_shift := num_bits
 	num_bits   = min(bits_left, _DIGIT_BITS)
@@ -1889,7 +1889,7 @@ internal_int_bitfield_extract :: proc(a: ^Int, offset, count: int) -> (res: _WOR
 	res |= (_WORD(a.digit[limb + 1]) & mask) << uint(res_shift)
 
 	bits_left -= num_bits
-	if bits_left == 0 { return res, nil; }
+	if bits_left == 0 { return res, nil }
 
 	mask     = (1 << uint(bits_left)) - 1
 	res_shift += _DIGIT_BITS
@@ -1908,7 +1908,7 @@ internal_int_bitfield_extract :: proc(a: ^Int, offset, count: int) -> (res: _WOR
 internal_int_shrink :: proc(a: ^Int) -> (err: Error) {
 	needed := max(_MIN_DIGIT_COUNT, a.used)
 
-	if a.used != needed { return internal_grow(a, needed, true); }
+	if a.used != needed { return internal_grow(a, needed, true) }
 	return nil
 }
 internal_shrink :: proc { internal_int_shrink, }
@@ -2006,7 +2006,7 @@ internal_nan :: proc { internal_int_nan, }
 internal_int_power_of_two :: proc(a: ^Int, power: int, allocator := context.allocator) -> (err: Error) {
 	context.allocator = allocator
 
-	if power < 0 || power > _MAX_BIT_COUNT { return .Invalid_Argument; }
+	if power < 0 || power > _MAX_BIT_COUNT { return .Invalid_Argument }
 
 	/*
 		Grow to accomodate the single bit.
@@ -2080,7 +2080,7 @@ internal_int_get :: proc(a: ^Int, $T: typeid) -> (res: T, err: Error) where intr
 		/*
 			Set the sign.
 		*/
-		if a.sign == .Negative { res = -res; }
+		if a.sign == .Negative { res = -res }
 	}
 	return
 }
@@ -2326,7 +2326,7 @@ internal_int_shrmod :: proc(quotient, remainder, numerator: ^Int, bits: int, all
 	context.allocator = allocator
 
 	bits := bits
-	if bits < 0 { return .Invalid_Argument; }
+	if bits < 0 { return .Invalid_Argument }
 
 	internal_copy(quotient, numerator) or_return
 
@@ -2387,12 +2387,12 @@ internal_shr :: proc { internal_int_shr, }
 internal_int_shr_digit :: proc(quotient: ^Int, digits: int, allocator := context.allocator) -> (err: Error) {
 	context.allocator = allocator
 
-	if digits <= 0 { return nil; }
+	if digits <= 0 { return nil }
 
 	/*
 		If digits > used simply zero and return.
 	*/
-	if digits > quotient.used { return internal_zero(quotient); }
+	if digits > quotient.used { return internal_zero(quotient) }
 
 	/*
 		Much like `int_shl_digit`, this is implemented using a sliding window,
@@ -2436,7 +2436,7 @@ internal_int_shl :: proc(dest, src: ^Int, bits: int, allocator := context.alloca
 
 	bits := bits
 
-	if bits < 0 { return .Invalid_Argument; }
+	if bits < 0 { return .Invalid_Argument }
 
 	internal_copy(dest, src) or_return
 
@@ -2487,7 +2487,7 @@ internal_shl :: proc { internal_int_shl, }
 internal_int_shl_digit :: proc(quotient: ^Int, digits: int, allocator := context.allocator) -> (err: Error) {
 	context.allocator = allocator
 
-	if digits <= 0 { return nil; }
+	if digits <= 0 { return nil }
 
 	/*
 		No need to shift a zero.
@@ -2527,7 +2527,7 @@ internal_count_bits :: proc(a: ^Int) -> (count: int) {
 	/*
 		Fast path for zero.
 	*/
-	if #force_inline internal_is_zero(a) { return {}; }
+	if #force_inline internal_is_zero(a) { return {} }
 	/*
 		Get the number of DIGITs and use it.
 	*/
@@ -2550,7 +2550,7 @@ internal_int_count_lsb :: proc(a: ^Int) -> (count: int, err: Error) {
 	/*
 		Easy out.
 	*/
-	if #force_inline internal_is_zero(a) { return {}, nil; }
+	if #force_inline internal_is_zero(a) { return {}, nil }
 
 	/*
 		Scan lower digits until non-zero.
@@ -2588,7 +2588,7 @@ internal_int_rand :: proc(dest: ^Int, bits: int, r: ^rnd.Rand = nil, allocator :
 
 	bits := bits
 
-	if bits <= 0 { return .Invalid_Argument; }
+	if bits <= 0 { return .Invalid_Argument }
 
 	digits := bits / _DIGIT_BITS
 	bits   %= _DIGIT_BITS
@@ -2632,7 +2632,7 @@ internal_clear_if_uninitialized_multi :: proc(args: ..^Int, allocator := context
 	for i in args {
 		if ! #force_inline internal_is_initialized(i) {
 			e := #force_inline internal_grow(i, _DEFAULT_DIGIT_COUNT)
-			if e != nil { err = e; }
+			if e != nil { err = e }
 		}
 	}
 	return err
@@ -2640,13 +2640,13 @@ internal_clear_if_uninitialized_multi :: proc(args: ..^Int, allocator := context
 internal_clear_if_uninitialized :: proc {internal_clear_if_uninitialized_single, internal_clear_if_uninitialized_multi, }
 
 internal_error_if_immutable_single :: proc(arg: ^Int) -> (err: Error) {
-	if arg != nil && .Immutable in arg.flags { return .Assignment_To_Immutable; }
+	if arg != nil && .Immutable in arg.flags { return .Assignment_To_Immutable }
 	return nil
 }
 
 internal_error_if_immutable_multi :: proc(args: ..^Int) -> (err: Error) {
 	for i in args {
-		if i != nil && .Immutable in i.flags { return .Assignment_To_Immutable; }
+		if i != nil && .Immutable in i.flags { return .Assignment_To_Immutable }
 	}
 	return nil
 }
@@ -2674,9 +2674,9 @@ internal_init_multi :: proc { internal_int_init_multi, }
 	Typically very fast.  Also fixes the sign if there are no more leading digits.
 */
 internal_clamp :: proc(a: ^Int) -> (err: Error) {
-	for a.used > 0 && a.digit[a.used - 1] == 0 { a.used -= 1; }
+	for a.used > 0 && a.digit[a.used - 1] == 0 { a.used -= 1 }
 
-	if #force_inline internal_is_zero(a) { a.sign = .Zero_or_Positive; }
+	if #force_inline internal_is_zero(a) { a.sign = .Zero_or_Positive }
 
 	return nil
 }
diff --git a/core/math/big/logical.odin b/core/math/big/logical.odin
index d455d480d..008450319 100644
--- a/core/math/big/logical.odin
+++ b/core/math/big/logical.odin
@@ -77,7 +77,7 @@ int_shrmod :: proc(quotient, remainder, numerator: ^Int, bits: int, allocator :=
 	assert_if_nil(quotient, numerator)
 	context.allocator = allocator
 
-	if err = internal_clear_if_uninitialized(quotient, numerator);  err != nil { return err; }
+	if err = internal_clear_if_uninitialized(quotient, numerator);  err != nil { return err }
 	return #force_inline internal_int_shrmod(quotient, remainder, numerator, bits)
 }
 shrmod :: proc { int_shrmod, }
diff --git a/core/math/big/prime.odin b/core/math/big/prime.odin
index b943da83b..f78c1894c 100644
--- a/core/math/big/prime.odin
+++ b/core/math/big/prime.odin
@@ -183,7 +183,7 @@ internal_int_montgomery_setup :: proc(n: ^Int) -> (rho: DIGIT, err: Error) {
 		                  =>  2*(1) - (1)     = 1
 	*/
 	b := n.digit[0]
-	if b & 1 == 0 { return 0, .Invalid_Argument; }
+	if b & 1 == 0 { return 0, .Invalid_Argument }
 
 	x := (((b + 2) & 4) << 1) + b /* here x*a==1 mod 2**4 */
 	x *= 2 - (b * x)              /* here x*a==1 mod 2**8 */
diff --git a/core/math/big/private.odin b/core/math/big/private.odin
index f0d73a008..241cd7441 100644
--- a/core/math/big/private.odin
+++ b/core/math/big/private.odin
@@ -1088,7 +1088,7 @@ _private_int_div_school :: proc(quotient, remainder, numerator, denominator: ^In
 		Step 3. for i from n down to (t + 1).

 	*/

 	#no_bounds_check for i := n; i >= (t + 1); i -= 1 {

-		if (i > x.used) { continue; }

+		if (i > x.used) { continue }

 

 		/*

 			step 3.1 if xi == yt then set q{i-t-1} to b-1, otherwise set q{i-t-1} to (xi*b + x{i-1})/yt

@@ -1744,7 +1744,7 @@ _private_montgomery_reduce_comba :: proc(x, n: ^Int, rho: DIGIT, allocator := co
 	context.allocator = allocator

 	W: [_WARRAY]_WORD = ---

 

-	if x.used > _WARRAY { return .Invalid_Argument; }

+	if x.used > _WARRAY { return .Invalid_Argument }

 

 	/*

 		Get old used count.

@@ -2022,7 +2022,7 @@ _private_inverse_modulo_odd :: proc(dest, a, b: ^Int, allocator := context.alloc
 	/*

 		2. [modified] `b` must be odd.

 	*/

-	if internal_is_even(b) { return .Invalid_Argument; }

+	if internal_is_even(b) { return .Invalid_Argument }

 

 	/*

 		Init all our temps.

@@ -2042,7 +2042,7 @@ _private_inverse_modulo_odd :: proc(dest, a, b: ^Int, allocator := context.alloc
 	/*

 		If one of `x`, `y` is zero return an error!

 	*/

-	if internal_is_zero(x) || internal_is_zero(y) { return .Invalid_Argument; }

+	if internal_is_zero(x) || internal_is_zero(y) { return .Invalid_Argument }

 

 	/*

 		3. `u` = `x`, `v` = `y`, `A` = 1, `B` = 0, `C` = 0, `D` = 1

@@ -2122,7 +2122,7 @@ _private_inverse_modulo_odd :: proc(dest, a, b: ^Int, allocator := context.alloc
 		/*

 			If not zero goto step 4.

 		*/

-		if internal_is_zero(u) { break; }

+		if internal_is_zero(u) { break }

 	}

 

 	/*

diff --git a/core/math/big/public.odin b/core/math/big/public.odin
index 9f82e618b..d7c6ec19c 100644
--- a/core/math/big/public.odin
+++ b/core/math/big/public.odin
@@ -120,7 +120,7 @@ int_double :: proc(dest, src: ^Int, allocator := context.allocator) -> (err: Err
 	/*

 		Grow destination as required.

 	*/

-	if dest != src { grow(dest, src.used + 1) or_return; }

+	if dest != src { grow(dest, src.used + 1) or_return }

 

 	return #force_inline internal_int_shl1(dest, src)

 }

@@ -153,7 +153,7 @@ int_mul :: proc(dest, src, multiplier: ^Int, allocator := context.allocator) ->
 

 mul :: proc { int_mul, int_mul_digit, }

 

-sqr :: proc(dest, src: ^Int) -> (err: Error) { return mul(dest, src, src); }

+sqr :: proc(dest, src: ^Int) -> (err: Error) { return mul(dest, src, src) }

 

 /*

 	divmod.

@@ -165,7 +165,7 @@ int_divmod :: proc(quotient, remainder, numerator, denominator: ^Int, allocator
 	/*

 		Early out if neither of the results is wanted.

 	*/

-	if quotient == nil && remainder == nil { return nil; }

+	if quotient == nil && remainder == nil { return nil }

 	internal_clear_if_uninitialized(numerator, denominator) or_return

 

 	return #force_inline internal_divmod(quotient, remainder, numerator, denominator)

@@ -275,7 +275,7 @@ sqrmod :: proc { int_sqrmod, }
 

 

 int_factorial :: proc(res: ^Int, n: int, allocator := context.allocator) -> (err: Error) {

-	if n < 0 || n > FACTORIAL_MAX_N { return .Invalid_Argument; }

+	if n < 0 || n > FACTORIAL_MAX_N { return .Invalid_Argument }

 	assert_if_nil(res)

 

 	return #force_inline internal_int_factorial(res, n, allocator)

@@ -302,8 +302,8 @@ int_choose_digit :: proc(res: ^Int, n, k: int, allocator := context.allocator) -
 	assert_if_nil(res)

 	context.allocator = allocator

 

-	if n < 0 || n > FACTORIAL_MAX_N { return .Invalid_Argument; }

-	if k > n { return internal_zero(res); }

+	if n < 0 || n > FACTORIAL_MAX_N { return .Invalid_Argument }

+	if k > n { return internal_zero(res) }

 

 	/*

 		res = n! / (k! * (n - k)!)

@@ -326,7 +326,7 @@ choose :: proc { int_choose_digit, }
 	Function computing both GCD and (if target isn't `nil`) also LCM.

 */

 int_gcd_lcm :: proc(res_gcd, res_lcm, a, b: ^Int, allocator := context.allocator) -> (err: Error) {

-	if res_gcd == nil && res_lcm == nil { return nil; }

+	if res_gcd == nil && res_lcm == nil { return nil }

 	assert_if_nil(a, b)

 	context.allocator = allocator

 

@@ -359,7 +359,7 @@ int_mod_bits :: proc(remainder, numerator: ^Int, bits: int, allocator := context
 	context.allocator = allocator

 

 	internal_clear_if_uninitialized(remainder, numerator) or_return

-	if bits < 0 { return .Invalid_Argument; }

+	if bits < 0 { return .Invalid_Argument }

 

 	return #force_inline internal_int_mod_bits(remainder, numerator, bits)

 }

@@ -439,7 +439,7 @@ int_root_n :: proc(dest, src: ^Int, n: int, allocator := context.allocator) -> (
 	/*

 		Fast path for n == 2.

 	*/

-	if n == 2 { return sqrt(dest, src); }

+	if n == 2 { return sqrt(dest, src) }

 

 	assert_if_nil(dest, src)

 	/*

@@ -456,7 +456,7 @@ root_n :: proc { int_root_n, }
 */

 

 int_is_initialized :: proc(a: ^Int) -> bool {

-	if a == nil { return false; }

+	if a == nil { return false }

 

 	return #force_inline internal_int_is_initialized(a)

 }

diff --git a/core/math/big/radix.odin b/core/math/big/radix.odin
index 8908f7775..f0a80d7b2 100644
--- a/core/math/big/radix.odin
+++ b/core/math/big/radix.odin
@@ -244,7 +244,7 @@ int_atoi :: proc(res: ^Int, input: string, radix := i8(10), allocator := context
 		Make sure the radix is ok.
 	*/
 
-	if radix < 2 || radix > 64 { return .Invalid_Argument; }
+	if radix < 2 || radix > 64 { return .Invalid_Argument }
 
 	/*
 		Set the integer to the default of zero.
@@ -327,7 +327,7 @@ radix_size :: proc(a: ^Int, radix: i8, zero_terminate := false, allocator := con
 	a := a
 	assert_if_nil(a)
 
-	if radix < 2 || radix > 64                     { return -1, .Invalid_Argument; }
+	if radix < 2 || radix > 64                     { return -1, .Invalid_Argument }
 	clear_if_uninitialized(a) or_return
 
 	if internal_is_zero(a) {
diff --git a/core/math/big/test.odin b/core/math/big/test.odin
index 8a48962cb..76cb6b7ef 100644
--- a/core/math/big/test.odin
+++ b/core/math/big/test.odin
@@ -44,17 +44,17 @@ PyRes :: struct {
 	aa, bb, sum := &Int{}, &Int{}, &Int{}
 	defer internal_destroy(aa, bb, sum)
 
-	if err = atoi(aa, string(a), 16); err != nil { return PyRes{res=":add:atoi(a):", err=err}; }
-	if err = atoi(bb, string(b), 16); err != nil { return PyRes{res=":add:atoi(b):", err=err}; }
+	if err = atoi(aa, string(a), 16); err != nil { return PyRes{res=":add:atoi(a):", err=err} }
+	if err = atoi(bb, string(b), 16); err != nil { return PyRes{res=":add:atoi(b):", err=err} }
 	if bb.used == 1 {
-		if err = #force_inline internal_add(sum, aa, bb.digit[0]); err != nil { return PyRes{res=":add:add(sum,a,b):", err=err}; }	
+		if err = #force_inline internal_add(sum, aa, bb.digit[0]); err != nil { return PyRes{res=":add:add(sum,a,b):", err=err} }	
 	} else {
-		if err = #force_inline internal_add(sum, aa, bb); err != nil { return PyRes{res=":add:add(sum,a,b):", err=err}; }
+		if err = #force_inline internal_add(sum, aa, bb); err != nil { return PyRes{res=":add:add(sum,a,b):", err=err} }
 	}
 
 	r: cstring
 	r, err = int_itoa_cstring(sum, 16, context.temp_allocator)
-	if err != nil { return PyRes{res=":add:itoa(sum):", err=err}; }
+	if err != nil { return PyRes{res=":add:itoa(sum):", err=err} }
 	return PyRes{res = r, err = nil}
 }
 
@@ -65,17 +65,17 @@ PyRes :: struct {
 	aa, bb, sum := &Int{}, &Int{}, &Int{}
 	defer internal_destroy(aa, bb, sum)
 
-	if err = atoi(aa, string(a), 16); err != nil { return PyRes{res=":sub:atoi(a):", err=err}; }
-	if err = atoi(bb, string(b), 16); err != nil { return PyRes{res=":sub:atoi(b):", err=err}; }
+	if err = atoi(aa, string(a), 16); err != nil { return PyRes{res=":sub:atoi(a):", err=err} }
+	if err = atoi(bb, string(b), 16); err != nil { return PyRes{res=":sub:atoi(b):", err=err} }
 	if bb.used == 1 {
-		if err = #force_inline internal_sub(sum, aa, bb.digit[0]); err != nil { return PyRes{res=":sub:sub(sum,a,b):", err=err}; }
+		if err = #force_inline internal_sub(sum, aa, bb.digit[0]); err != nil { return PyRes{res=":sub:sub(sum,a,b):", err=err} }
 	} else {
-		if err = #force_inline internal_sub(sum, aa, bb); err != nil { return PyRes{res=":sub:sub(sum,a,b):", err=err}; }
+		if err = #force_inline internal_sub(sum, aa, bb); err != nil { return PyRes{res=":sub:sub(sum,a,b):", err=err} }
 	}
 
 	r: cstring
 	r, err = int_itoa_cstring(sum, 16, context.temp_allocator)
-	if err != nil { return PyRes{res=":sub:itoa(sum):", err=err}; }
+	if err != nil { return PyRes{res=":sub:itoa(sum):", err=err} }
 	return PyRes{res = r, err = nil}
 }
 
@@ -86,13 +86,13 @@ PyRes :: struct {
 	aa, bb, product := &Int{}, &Int{}, &Int{}
 	defer internal_destroy(aa, bb, product)
 
-	if err = atoi(aa, string(a), 16); err != nil { return PyRes{res=":mul:atoi(a):", err=err}; }
-	if err = atoi(bb, string(b), 16); err != nil { return PyRes{res=":mul:atoi(b):", err=err}; }
-	if err = #force_inline internal_mul(product, aa, bb); err != nil { return PyRes{res=":mul:mul(product,a,b):", err=err}; }
+	if err = atoi(aa, string(a), 16); err != nil { return PyRes{res=":mul:atoi(a):", err=err} }
+	if err = atoi(bb, string(b), 16); err != nil { return PyRes{res=":mul:atoi(b):", err=err} }
+	if err = #force_inline internal_mul(product, aa, bb); err != nil { return PyRes{res=":mul:mul(product,a,b):", err=err} }
 
 	r: cstring
 	r, err = int_itoa_cstring(product, 16, context.temp_allocator)
-	if err != nil { return PyRes{res=":mul:itoa(product):", err=err}; }
+	if err != nil { return PyRes{res=":mul:itoa(product):", err=err} }
 	return PyRes{res = r, err = nil}
 }
 
@@ -103,12 +103,12 @@ PyRes :: struct {
 	aa, square := &Int{}, &Int{}
 	defer internal_destroy(aa, square)
 
-	if err = atoi(aa, string(a), 16); err != nil { return PyRes{res=":sqr:atoi(a):", err=err}; }
-	if err = #force_inline internal_sqr(square, aa); err != nil { return PyRes{res=":sqr:sqr(square,a):", err=err}; }
+	if err = atoi(aa, string(a), 16); err != nil { return PyRes{res=":sqr:atoi(a):", err=err} }
+	if err = #force_inline internal_sqr(square, aa); err != nil { return PyRes{res=":sqr:sqr(square,a):", err=err} }
 
 	r: cstring
 	r, err = int_itoa_cstring(square, 16, context.temp_allocator)
-	if err != nil { return PyRes{res=":sqr:itoa(square):", err=err}; }
+	if err != nil { return PyRes{res=":sqr:itoa(square):", err=err} }
 	return PyRes{res = r, err = nil}
 }
 
@@ -122,13 +122,13 @@ PyRes :: struct {
 	aa, bb, quotient := &Int{}, &Int{}, &Int{}
 	defer internal_destroy(aa, bb, quotient)
 
-	if err = atoi(aa, string(a), 16); err != nil { return PyRes{res=":div:atoi(a):", err=err}; }
-	if err = atoi(bb, string(b), 16); err != nil { return PyRes{res=":div:atoi(b):", err=err}; }
-	if err = #force_inline internal_div(quotient, aa, bb); err != nil { return PyRes{res=":div:div(quotient,a,b):", err=err}; }
+	if err = atoi(aa, string(a), 16); err != nil { return PyRes{res=":div:atoi(a):", err=err} }
+	if err = atoi(bb, string(b), 16); err != nil { return PyRes{res=":div:atoi(b):", err=err} }
+	if err = #force_inline internal_div(quotient, aa, bb); err != nil { return PyRes{res=":div:div(quotient,a,b):", err=err} }
 
 	r: cstring
 	r, err = int_itoa_cstring(quotient, 16, context.temp_allocator)
-	if err != nil { return PyRes{res=":div:itoa(quotient):", err=err}; }
+	if err != nil { return PyRes{res=":div:itoa(quotient):", err=err} }
 	return PyRes{res = r, err = nil}
 }
 
@@ -144,8 +144,8 @@ PyRes :: struct {
 	aa := &Int{}
 	defer internal_destroy(aa)
 
-	if err = atoi(aa, string(a), 16); err != nil { return PyRes{res=":log:atoi(a):", err=err}; }
-	if l, err = #force_inline internal_log(aa, base); err != nil { return PyRes{res=":log:log(a, base):", err=err}; }
+	if err = atoi(aa, string(a), 16); err != nil { return PyRes{res=":log:atoi(a):", err=err} }
+	if l, err = #force_inline internal_log(aa, base); err != nil { return PyRes{res=":log:log(a, base):", err=err} }
 
 	#force_inline internal_zero(aa)
 	aa.digit[0] = DIGIT(l)  & _MASK
@@ -155,7 +155,7 @@ PyRes :: struct {
 
 	r: cstring
 	r, err = int_itoa_cstring(aa, 16, context.temp_allocator)
-	if err != nil { return PyRes{res=":log:itoa(res):", err=err}; }
+	if err != nil { return PyRes{res=":log:itoa(res):", err=err} }
 	return PyRes{res = r, err = nil}
 }
 
@@ -169,12 +169,12 @@ PyRes :: struct {
 	dest, bb := &Int{}, &Int{}
 	defer internal_destroy(dest, bb)
 
-	if err = atoi(bb, string(base), 16); err != nil { return PyRes{res=":pow:atoi(base):", err=err}; }
-	if err = #force_inline internal_pow(dest, bb, power); err != nil { return PyRes{res=":pow:pow(dest, base, power):", err=err}; }
+	if err = atoi(bb, string(base), 16); err != nil { return PyRes{res=":pow:atoi(base):", err=err} }
+	if err = #force_inline internal_pow(dest, bb, power); err != nil { return PyRes{res=":pow:pow(dest, base, power):", err=err} }
 
 	r: cstring
 	r, err = int_itoa_cstring(dest, 16, context.temp_allocator)
-	if err != nil { return PyRes{res=":log:itoa(res):", err=err}; }
+	if err != nil { return PyRes{res=":log:itoa(res):", err=err} }
 	return PyRes{res = r, err = nil}
 }
 
@@ -188,12 +188,12 @@ PyRes :: struct {
 	src := &Int{}
 	defer internal_destroy(src)
 
-	if err = atoi(src, string(source), 16); err != nil { return PyRes{res=":sqrt:atoi(src):", err=err}; }
-	if err = #force_inline internal_sqrt(src, src); err != nil { return PyRes{res=":sqrt:sqrt(src):", err=err}; }
+	if err = atoi(src, string(source), 16); err != nil { return PyRes{res=":sqrt:atoi(src):", err=err} }
+	if err = #force_inline internal_sqrt(src, src); err != nil { return PyRes{res=":sqrt:sqrt(src):", err=err} }
 
 	r: cstring
 	r, err = int_itoa_cstring(src, 16, context.temp_allocator)
-	if err != nil { return PyRes{res=":log:itoa(res):", err=err}; }
+	if err != nil { return PyRes{res=":log:itoa(res):", err=err} }
 	return PyRes{res = r, err = nil}
 }
 
@@ -207,12 +207,12 @@ PyRes :: struct {
 	src := &Int{}
 	defer internal_destroy(src)
 
-	if err = atoi(src, string(source), 16); err != nil { return PyRes{res=":root_n:atoi(src):", err=err}; }
-	if err = #force_inline internal_root_n(src, src, power); err != nil { return PyRes{res=":root_n:root_n(src):", err=err}; }
+	if err = atoi(src, string(source), 16); err != nil { return PyRes{res=":root_n:atoi(src):", err=err} }
+	if err = #force_inline internal_root_n(src, src, power); err != nil { return PyRes{res=":root_n:root_n(src):", err=err} }
 
 	r: cstring
 	r, err = int_itoa_cstring(src, 16, context.temp_allocator)
-	if err != nil { return PyRes{res=":root_n:itoa(res):", err=err}; }
+	if err != nil { return PyRes{res=":root_n:itoa(res):", err=err} }
 	return PyRes{res = r, err = nil}
 }
 
@@ -226,12 +226,12 @@ PyRes :: struct {
 	src := &Int{}
 	defer internal_destroy(src)
 
-	if err = atoi(src, string(source), 16); err != nil { return PyRes{res=":shr_digit:atoi(src):", err=err}; }
-	if err = #force_inline internal_shr_digit(src, digits); err != nil { return PyRes{res=":shr_digit:shr_digit(src):", err=err}; }
+	if err = atoi(src, string(source), 16); err != nil { return PyRes{res=":shr_digit:atoi(src):", err=err} }
+	if err = #force_inline internal_shr_digit(src, digits); err != nil { return PyRes{res=":shr_digit:shr_digit(src):", err=err} }
 
 	r: cstring
 	r, err = int_itoa_cstring(src, 16, context.temp_allocator)
-	if err != nil { return PyRes{res=":shr_digit:itoa(res):", err=err}; }
+	if err != nil { return PyRes{res=":shr_digit:itoa(res):", err=err} }
 	return PyRes{res = r, err = nil}
 }
 
@@ -245,12 +245,12 @@ PyRes :: struct {
 	src := &Int{}
 	defer internal_destroy(src)
 
-	if err = atoi(src, string(source), 16); err != nil { return PyRes{res=":shl_digit:atoi(src):", err=err}; }
-	if err = #force_inline internal_shl_digit(src, digits); err != nil { return PyRes{res=":shl_digit:shr_digit(src):", err=err}; }
+	if err = atoi(src, string(source), 16); err != nil { return PyRes{res=":shl_digit:atoi(src):", err=err} }
+	if err = #force_inline internal_shl_digit(src, digits); err != nil { return PyRes{res=":shl_digit:shr_digit(src):", err=err} }
 
 	r: cstring
 	r, err = int_itoa_cstring(src, 16, context.temp_allocator)
-	if err != nil { return PyRes{res=":shl_digit:itoa(res):", err=err}; }
+	if err != nil { return PyRes{res=":shl_digit:itoa(res):", err=err} }
 	return PyRes{res = r, err = nil}
 }
 
@@ -264,12 +264,12 @@ PyRes :: struct {
 	src := &Int{}
 	defer internal_destroy(src)
 
-	if err = atoi(src, string(source), 16); err != nil { return PyRes{res=":shr:atoi(src):", err=err}; }
-	if err = #force_inline internal_shr(src, src, bits); err != nil { return PyRes{res=":shr:shr(src, bits):", err=err}; }
+	if err = atoi(src, string(source), 16); err != nil { return PyRes{res=":shr:atoi(src):", err=err} }
+	if err = #force_inline internal_shr(src, src, bits); err != nil { return PyRes{res=":shr:shr(src, bits):", err=err} }
 
 	r: cstring
 	r, err = int_itoa_cstring(src, 16, context.temp_allocator)
-	if err != nil { return PyRes{res=":shr:itoa(res):", err=err}; }
+	if err != nil { return PyRes{res=":shr:itoa(res):", err=err} }
 	return PyRes{res = r, err = nil}
 }
 
@@ -283,12 +283,12 @@ PyRes :: struct {
 	src := &Int{}
 	defer internal_destroy(src)
 
-	if err = atoi(src, string(source), 16); err != nil { return PyRes{res=":shr_signed:atoi(src):", err=err}; }
-	if err = #force_inline internal_shr_signed(src, src, bits); err != nil { return PyRes{res=":shr_signed:shr_signed(src, bits):", err=err}; }
+	if err = atoi(src, string(source), 16); err != nil { return PyRes{res=":shr_signed:atoi(src):", err=err} }
+	if err = #force_inline internal_shr_signed(src, src, bits); err != nil { return PyRes{res=":shr_signed:shr_signed(src, bits):", err=err} }
 
 	r: cstring
 	r, err = int_itoa_cstring(src, 16, context.temp_allocator)
-	if err != nil { return PyRes{res=":shr_signed:itoa(res):", err=err}; }
+	if err != nil { return PyRes{res=":shr_signed:itoa(res):", err=err} }
 	return PyRes{res = r, err = nil}
 }
 
@@ -302,12 +302,12 @@ PyRes :: struct {
 	src := &Int{}
 	defer internal_destroy(src)
 
-	if err = atoi(src, string(source), 16); err != nil { return PyRes{res=":shl:atoi(src):", err=err}; }
-	if err = #force_inline internal_shl(src, src, bits); err != nil { return PyRes{res=":shl:shl(src, bits):", err=err}; }
+	if err = atoi(src, string(source), 16); err != nil { return PyRes{res=":shl:atoi(src):", err=err} }
+	if err = #force_inline internal_shl(src, src, bits); err != nil { return PyRes{res=":shl:shl(src, bits):", err=err} }
 
 	r: cstring
 	r, err = int_itoa_cstring(src, 16, context.temp_allocator)
-	if err != nil { return PyRes{res=":shl:itoa(res):", err=err}; }
+	if err != nil { return PyRes{res=":shl:itoa(res):", err=err} }
 	return PyRes{res = r, err = nil}
 }
 
@@ -321,11 +321,11 @@ PyRes :: struct {
 	dest := &Int{}
 	defer internal_destroy(dest)
 
-	if err = #force_inline internal_int_factorial(dest, n); err != nil { return PyRes{res=":factorial:factorial(n):", err=err}; }
+	if err = #force_inline internal_int_factorial(dest, n); err != nil { return PyRes{res=":factorial:factorial(n):", err=err} }
 
 	r: cstring
 	r, err = int_itoa_cstring(dest, 16, context.temp_allocator)
-	if err != nil { return PyRes{res=":factorial:itoa(res):", err=err}; }
+	if err != nil { return PyRes{res=":factorial:itoa(res):", err=err} }
 	return PyRes{res = r, err = nil}
 }
 
@@ -339,13 +339,13 @@ PyRes :: struct {
 	ai, bi, dest := &Int{}, &Int{}, &Int{}
 	defer internal_destroy(ai, bi, dest)
 
-	if err = atoi(ai, string(a), 16); err != nil { return PyRes{res=":gcd:atoi(a):", err=err}; }
-	if err = atoi(bi, string(b), 16); err != nil { return PyRes{res=":gcd:atoi(b):", err=err}; }
-	if err = #force_inline internal_int_gcd_lcm(dest, nil, ai, bi); err != nil { return PyRes{res=":gcd:gcd(a, b):", err=err}; }
+	if err = atoi(ai, string(a), 16); err != nil { return PyRes{res=":gcd:atoi(a):", err=err} }
+	if err = atoi(bi, string(b), 16); err != nil { return PyRes{res=":gcd:atoi(b):", err=err} }
+	if err = #force_inline internal_int_gcd_lcm(dest, nil, ai, bi); err != nil { return PyRes{res=":gcd:gcd(a, b):", err=err} }
 
 	r: cstring
 	r, err = int_itoa_cstring(dest, 16, context.temp_allocator)
-	if err != nil { return PyRes{res=":gcd:itoa(res):", err=err}; }
+	if err != nil { return PyRes{res=":gcd:itoa(res):", err=err} }
 	return PyRes{res = r, err = nil}
 }
 
@@ -359,13 +359,13 @@ PyRes :: struct {
 	ai, bi, dest := &Int{}, &Int{}, &Int{}
 	defer internal_destroy(ai, bi, dest)
 
-	if err = atoi(ai, string(a), 16); err != nil { return PyRes{res=":lcm:atoi(a):", err=err}; }
-	if err = atoi(bi, string(b), 16); err != nil { return PyRes{res=":lcm:atoi(b):", err=err}; }
-	if err = #force_inline internal_int_gcd_lcm(nil, dest, ai, bi); err != nil { return PyRes{res=":lcm:lcm(a, b):", err=err}; }
+	if err = atoi(ai, string(a), 16); err != nil { return PyRes{res=":lcm:atoi(a):", err=err} }
+	if err = atoi(bi, string(b), 16); err != nil { return PyRes{res=":lcm:atoi(b):", err=err} }
+	if err = #force_inline internal_int_gcd_lcm(nil, dest, ai, bi); err != nil { return PyRes{res=":lcm:lcm(a, b):", err=err} }
 
 	r: cstring
 	r, err = int_itoa_cstring(dest, 16, context.temp_allocator)
-	if err != nil { return PyRes{res=":lcm:itoa(res):", err=err}; }
+	if err != nil { return PyRes{res=":lcm:itoa(res):", err=err} }
 	return PyRes{res = r, err = nil}
 }
 
@@ -380,8 +380,8 @@ PyRes :: struct {
 	ai := &Int{}
 	defer internal_destroy(ai)
 
-	if err = atoi(ai, string(a), 16); err != nil { return PyRes{res=":is_square:atoi(a):", err=err}; }
-	if square, err = #force_inline internal_int_is_square(ai); err != nil { return PyRes{res=":is_square:is_square(a):", err=err}; }
+	if err = atoi(ai, string(a), 16); err != nil { return PyRes{res=":is_square:atoi(a):", err=err} }
+	if square, err = #force_inline internal_int_is_square(ai); err != nil { return PyRes{res=":is_square:is_square(a):", err=err} }
 
 	if square {
 		return PyRes{"True", nil}
diff --git a/core/math/bits/bits.odin b/core/math/bits/bits.odin
index 0d05b356d..ff16e9aa0 100644
--- a/core/math/bits/bits.odin
+++ b/core/math/bits/bits.odin
@@ -64,30 +64,30 @@ rotate_left :: proc(x: uint, k: int) -> uint {
 	return x <<s | x>>(n-s)
 }
 
-from_be_u8   :: proc(i:   u8) ->   u8 { return i; }
-from_be_u16  :: proc(i:  u16) ->  u16 { when ODIN_ENDIAN == "big" { return i; } else { return byte_swap(i); } }
-from_be_u32  :: proc(i:  u32) ->  u32 { when ODIN_ENDIAN == "big" { return i; } else { return byte_swap(i); } }
-from_be_u64  :: proc(i:  u64) ->  u64 { when ODIN_ENDIAN == "big" { return i; } else { return byte_swap(i); } }
-from_be_uint :: proc(i: uint) -> uint { when ODIN_ENDIAN == "big" { return i; } else { return byte_swap(i); } }
+from_be_u8   :: proc(i:   u8) ->   u8 { return i }
+from_be_u16  :: proc(i:  u16) ->  u16 { when ODIN_ENDIAN == "big" { return i } else { return byte_swap(i) } }
+from_be_u32  :: proc(i:  u32) ->  u32 { when ODIN_ENDIAN == "big" { return i } else { return byte_swap(i) } }
+from_be_u64  :: proc(i:  u64) ->  u64 { when ODIN_ENDIAN == "big" { return i } else { return byte_swap(i) } }
+from_be_uint :: proc(i: uint) -> uint { when ODIN_ENDIAN == "big" { return i } else { return byte_swap(i) } }
 
-from_le_u8   :: proc(i:   u8) ->   u8 { return i; }
-from_le_u16  :: proc(i:  u16) ->  u16 { when ODIN_ENDIAN == "little" { return i; } else { return byte_swap(i); } }
-from_le_u32  :: proc(i:  u32) ->  u32 { when ODIN_ENDIAN == "little" { return i; } else { return byte_swap(i); } }
-from_le_u64  :: proc(i:  u64) ->  u64 { when ODIN_ENDIAN == "little" { return i; } else { return byte_swap(i); } }
-from_le_uint :: proc(i: uint) -> uint { when ODIN_ENDIAN == "little" { return i; } else { return byte_swap(i); } }
+from_le_u8   :: proc(i:   u8) ->   u8 { return i }
+from_le_u16  :: proc(i:  u16) ->  u16 { when ODIN_ENDIAN == "little" { return i } else { return byte_swap(i) } }
+from_le_u32  :: proc(i:  u32) ->  u32 { when ODIN_ENDIAN == "little" { return i } else { return byte_swap(i) } }
+from_le_u64  :: proc(i:  u64) ->  u64 { when ODIN_ENDIAN == "little" { return i } else { return byte_swap(i) } }
+from_le_uint :: proc(i: uint) -> uint { when ODIN_ENDIAN == "little" { return i } else { return byte_swap(i) } }
 
-to_be_u8   :: proc(i:   u8) ->   u8 { return i; }
-to_be_u16  :: proc(i:  u16) ->  u16 { when ODIN_ENDIAN == "big" { return i; } else { return byte_swap(i); } }
-to_be_u32  :: proc(i:  u32) ->  u32 { when ODIN_ENDIAN == "big" { return i; } else { return byte_swap(i); } }
-to_be_u64  :: proc(i:  u64) ->  u64 { when ODIN_ENDIAN == "big" { return i; } else { return byte_swap(i); } }
-to_be_uint :: proc(i: uint) -> uint { when ODIN_ENDIAN == "big" { return i; } else { return byte_swap(i); } }
+to_be_u8   :: proc(i:   u8) ->   u8 { return i }
+to_be_u16  :: proc(i:  u16) ->  u16 { when ODIN_ENDIAN == "big" { return i } else { return byte_swap(i) } }
+to_be_u32  :: proc(i:  u32) ->  u32 { when ODIN_ENDIAN == "big" { return i } else { return byte_swap(i) } }
+to_be_u64  :: proc(i:  u64) ->  u64 { when ODIN_ENDIAN == "big" { return i } else { return byte_swap(i) } }
+to_be_uint :: proc(i: uint) -> uint { when ODIN_ENDIAN == "big" { return i } else { return byte_swap(i) } }
 
 
-to_le_u8   :: proc(i:   u8) ->   u8 { return i; }
-to_le_u16  :: proc(i:  u16) ->  u16 { when ODIN_ENDIAN == "little" { return i; } else { return byte_swap(i); } }
-to_le_u32  :: proc(i:  u32) ->  u32 { when ODIN_ENDIAN == "little" { return i; } else { return byte_swap(i); } }
-to_le_u64  :: proc(i:  u64) ->  u64 { when ODIN_ENDIAN == "little" { return i; } else { return byte_swap(i); } }
-to_le_uint :: proc(i: uint) -> uint { when ODIN_ENDIAN == "little" { return i; } else { return byte_swap(i); } }
+to_le_u8   :: proc(i:   u8) ->   u8 { return i }
+to_le_u16  :: proc(i:  u16) ->  u16 { when ODIN_ENDIAN == "little" { return i } else { return byte_swap(i) } }
+to_le_u32  :: proc(i:  u32) ->  u32 { when ODIN_ENDIAN == "little" { return i } else { return byte_swap(i) } }
+to_le_u64  :: proc(i:  u64) ->  u64 { when ODIN_ENDIAN == "little" { return i } else { return byte_swap(i) } }
+to_le_uint :: proc(i: uint) -> uint { when ODIN_ENDIAN == "little" { return i } else { return byte_swap(i) } }
 
 
 
@@ -294,16 +294,16 @@ div :: proc{div_u32, div_u64, div_uint}
 
 
 
-is_power_of_two_u8   :: proc(i:   u8) -> bool { return i > 0 && (i & (i-1)) == 0; }
-is_power_of_two_i8   :: proc(i:   i8) -> bool { return i > 0 && (i & (i-1)) == 0; }
-is_power_of_two_u16  :: proc(i:  u16) -> bool { return i > 0 && (i & (i-1)) == 0; }
-is_power_of_two_i16  :: proc(i:  i16) -> bool { return i > 0 && (i & (i-1)) == 0; }
-is_power_of_two_u32  :: proc(i:  u32) -> bool { return i > 0 && (i & (i-1)) == 0; }
-is_power_of_two_i32  :: proc(i:  i32) -> bool { return i > 0 && (i & (i-1)) == 0; }
-is_power_of_two_u64  :: proc(i:  u64) -> bool { return i > 0 && (i & (i-1)) == 0; }
-is_power_of_two_i64  :: proc(i:  i64) -> bool { return i > 0 && (i & (i-1)) == 0; }
-is_power_of_two_uint :: proc(i: uint) -> bool { return i > 0 && (i & (i-1)) == 0; }
-is_power_of_two_int  :: proc(i:  int) -> bool { return i > 0 && (i & (i-1)) == 0; }
+is_power_of_two_u8   :: proc(i:   u8) -> bool { return i > 0 && (i & (i-1)) == 0 }
+is_power_of_two_i8   :: proc(i:   i8) -> bool { return i > 0 && (i & (i-1)) == 0 }
+is_power_of_two_u16  :: proc(i:  u16) -> bool { return i > 0 && (i & (i-1)) == 0 }
+is_power_of_two_i16  :: proc(i:  i16) -> bool { return i > 0 && (i & (i-1)) == 0 }
+is_power_of_two_u32  :: proc(i:  u32) -> bool { return i > 0 && (i & (i-1)) == 0 }
+is_power_of_two_i32  :: proc(i:  i32) -> bool { return i > 0 && (i & (i-1)) == 0 }
+is_power_of_two_u64  :: proc(i:  u64) -> bool { return i > 0 && (i & (i-1)) == 0 }
+is_power_of_two_i64  :: proc(i:  i64) -> bool { return i > 0 && (i & (i-1)) == 0 }
+is_power_of_two_uint :: proc(i: uint) -> bool { return i > 0 && (i & (i-1)) == 0 }
+is_power_of_two_int  :: proc(i:  int) -> bool { return i > 0 && (i & (i-1)) == 0 }
 
 is_power_of_two :: proc{
 	is_power_of_two_u8,   is_power_of_two_i8,
@@ -328,12 +328,12 @@ len_u8_table := [256]u8{
 }
 
 
-bitfield_extract_u8   :: proc(value:   u8, offset, bits: uint) ->   u8 { return (value >> offset) &   u8(1<<bits - 1); }
-bitfield_extract_u16  :: proc(value:  u16, offset, bits: uint) ->  u16 { return (value >> offset) &  u16(1<<bits - 1); }
-bitfield_extract_u32  :: proc(value:  u32, offset, bits: uint) ->  u32 { return (value >> offset) &  u32(1<<bits - 1); }
-bitfield_extract_u64  :: proc(value:  u64, offset, bits: uint) ->  u64 { return (value >> offset) &  u64(1<<bits - 1); }
-bitfield_extract_u128 :: proc(value: u128, offset, bits: uint) -> u128 { return (value >> offset) & u128(1<<bits - 1); }
-bitfield_extract_uint :: proc(value: uint, offset, bits: uint) -> uint { return (value >> offset) & uint(1<<bits - 1); }
+bitfield_extract_u8   :: proc(value:   u8, offset, bits: uint) ->   u8 { return (value >> offset) &   u8(1<<bits - 1) }
+bitfield_extract_u16  :: proc(value:  u16, offset, bits: uint) ->  u16 { return (value >> offset) &  u16(1<<bits - 1) }
+bitfield_extract_u32  :: proc(value:  u32, offset, bits: uint) ->  u32 { return (value >> offset) &  u32(1<<bits - 1) }
+bitfield_extract_u64  :: proc(value:  u64, offset, bits: uint) ->  u64 { return (value >> offset) &  u64(1<<bits - 1) }
+bitfield_extract_u128 :: proc(value: u128, offset, bits: uint) -> u128 { return (value >> offset) & u128(1<<bits - 1) }
+bitfield_extract_uint :: proc(value: uint, offset, bits: uint) -> uint { return (value >> offset) & uint(1<<bits - 1) }
 
 bitfield_extract_i8 :: proc(value: i8, offset, bits: uint) -> i8 {
 	v := (u8(value) >> offset) & u8(1<<bits - 1)
diff --git a/core/math/linalg/extended.odin b/core/math/linalg/extended.odin
index 8f7b2dd1e..ba64356ce 100644
--- a/core/math/linalg/extended.odin
+++ b/core/math/linalg/extended.odin
@@ -478,12 +478,12 @@ is_inf :: proc{is_inf_single, is_inf_array}
 classify :: proc{classify_single, classify_array}
 
 
-less_than_single          :: proc(x, y: $T) -> (out: bool) where !IS_ARRAY(T), IS_FLOAT(T) { return x < y; }
-less_than_equal_single    :: proc(x, y: $T) -> (out: bool) where !IS_ARRAY(T), IS_FLOAT(T) { return x <= y; }
-greater_than_single       :: proc(x, y: $T) -> (out: bool) where !IS_ARRAY(T), IS_FLOAT(T) { return x > y; }
-greater_than_equal_single :: proc(x, y: $T) -> (out: bool) where !IS_ARRAY(T), IS_FLOAT(T) { return x >= y; }
-equal_single              :: proc(x, y: $T) -> (out: bool) where !IS_ARRAY(T), IS_FLOAT(T) { return x == y; }
-not_equal_single          :: proc(x, y: $T) -> (out: bool) where !IS_ARRAY(T), IS_FLOAT(T) { return x != y; }
+less_than_single          :: proc(x, y: $T) -> (out: bool) where !IS_ARRAY(T), IS_FLOAT(T) { return x < y }
+less_than_equal_single    :: proc(x, y: $T) -> (out: bool) where !IS_ARRAY(T), IS_FLOAT(T) { return x <= y }
+greater_than_single       :: proc(x, y: $T) -> (out: bool) where !IS_ARRAY(T), IS_FLOAT(T) { return x > y }
+greater_than_equal_single :: proc(x, y: $T) -> (out: bool) where !IS_ARRAY(T), IS_FLOAT(T) { return x >= y }
+equal_single              :: proc(x, y: $T) -> (out: bool) where !IS_ARRAY(T), IS_FLOAT(T) { return x == y }
+not_equal_single          :: proc(x, y: $T) -> (out: bool) where !IS_ARRAY(T), IS_FLOAT(T) { return x != y }
 
 less_than_array :: proc(x, y: $A/[$N]$T) -> (out: [N]bool) where IS_ARRAY(A), IS_FLOAT(ELEM_TYPE(A)) {
 	for i in 0..<N {
diff --git a/core/math/linalg/general.odin b/core/math/linalg/general.odin
index 241a50f28..6c594945f 100644
--- a/core/math/linalg/general.odin
+++ b/core/math/linalg/general.odin
@@ -339,24 +339,24 @@ matrix_cast :: proc(v: $A/[$M][$N]$T, $Elem_Type: typeid) -> (w: [M][N]Elem_Type
 	return
 }
 
-to_f32  :: #force_inline proc(v: $A/[$N]$T) -> [N]f32  { return array_cast(v, f32);  }
-to_f64  :: #force_inline proc(v: $A/[$N]$T) -> [N]f64  { return array_cast(v, f64);  }
-
-to_i8   :: #force_inline proc(v: $A/[$N]$T) -> [N]i8   { return array_cast(v, i8);   }
-to_i16  :: #force_inline proc(v: $A/[$N]$T) -> [N]i16  { return array_cast(v, i16);  }
-to_i32  :: #force_inline proc(v: $A/[$N]$T) -> [N]i32  { return array_cast(v, i32);  }
-to_i64  :: #force_inline proc(v: $A/[$N]$T) -> [N]i64  { return array_cast(v, i64);  }
-to_int  :: #force_inline proc(v: $A/[$N]$T) -> [N]int  { return array_cast(v, int);  }
-
-to_u8   :: #force_inline proc(v: $A/[$N]$T) -> [N]u8   { return array_cast(v, u8);   }
-to_u16  :: #force_inline proc(v: $A/[$N]$T) -> [N]u16  { return array_cast(v, u16);  }
-to_u32  :: #force_inline proc(v: $A/[$N]$T) -> [N]u32  { return array_cast(v, u32);  }
-to_u64  :: #force_inline proc(v: $A/[$N]$T) -> [N]u64  { return array_cast(v, u64);  }
-to_uint :: #force_inline proc(v: $A/[$N]$T) -> [N]uint { return array_cast(v, uint); }
-
-to_complex32     :: #force_inline proc(v: $A/[$N]$T) -> [N]complex32     { return array_cast(v, complex32);     }
-to_complex64     :: #force_inline proc(v: $A/[$N]$T) -> [N]complex64     { return array_cast(v, complex64);     }
-to_complex128    :: #force_inline proc(v: $A/[$N]$T) -> [N]complex128    { return array_cast(v, complex128);    }
-to_quaternion64  :: #force_inline proc(v: $A/[$N]$T) -> [N]quaternion64 { return array_cast(v, quaternion64); }
-to_quaternion128 :: #force_inline proc(v: $A/[$N]$T) -> [N]quaternion128 { return array_cast(v, quaternion128); }
-to_quaternion256 :: #force_inline proc(v: $A/[$N]$T) -> [N]quaternion256 { return array_cast(v, quaternion256); }
+to_f32  :: #force_inline proc(v: $A/[$N]$T) -> [N]f32  { return array_cast(v, f32)  }
+to_f64  :: #force_inline proc(v: $A/[$N]$T) -> [N]f64  { return array_cast(v, f64)  }
+
+to_i8   :: #force_inline proc(v: $A/[$N]$T) -> [N]i8   { return array_cast(v, i8)   }
+to_i16  :: #force_inline proc(v: $A/[$N]$T) -> [N]i16  { return array_cast(v, i16)  }
+to_i32  :: #force_inline proc(v: $A/[$N]$T) -> [N]i32  { return array_cast(v, i32)  }
+to_i64  :: #force_inline proc(v: $A/[$N]$T) -> [N]i64  { return array_cast(v, i64)  }
+to_int  :: #force_inline proc(v: $A/[$N]$T) -> [N]int  { return array_cast(v, int)  }
+
+to_u8   :: #force_inline proc(v: $A/[$N]$T) -> [N]u8   { return array_cast(v, u8)   }
+to_u16  :: #force_inline proc(v: $A/[$N]$T) -> [N]u16  { return array_cast(v, u16)  }
+to_u32  :: #force_inline proc(v: $A/[$N]$T) -> [N]u32  { return array_cast(v, u32)  }
+to_u64  :: #force_inline proc(v: $A/[$N]$T) -> [N]u64  { return array_cast(v, u64)  }
+to_uint :: #force_inline proc(v: $A/[$N]$T) -> [N]uint { return array_cast(v, uint) }
+
+to_complex32     :: #force_inline proc(v: $A/[$N]$T) -> [N]complex32     { return array_cast(v, complex32)     }
+to_complex64     :: #force_inline proc(v: $A/[$N]$T) -> [N]complex64     { return array_cast(v, complex64)     }
+to_complex128    :: #force_inline proc(v: $A/[$N]$T) -> [N]complex128    { return array_cast(v, complex128)    }
+to_quaternion64  :: #force_inline proc(v: $A/[$N]$T) -> [N]quaternion64 { return array_cast(v, quaternion64) }
+to_quaternion128 :: #force_inline proc(v: $A/[$N]$T) -> [N]quaternion128 { return array_cast(v, quaternion128) }
+to_quaternion256 :: #force_inline proc(v: $A/[$N]$T) -> [N]quaternion256 { return array_cast(v, quaternion256) }
diff --git a/core/math/linalg/specific.odin b/core/math/linalg/specific.odin
index 333d17e44..dd3803c99 100644
--- a/core/math/linalg/specific.odin
+++ b/core/math/linalg/specific.odin
@@ -260,8 +260,8 @@ vector4_linear_to_srgb :: proc{
 vector4_hsl_to_rgb_f16 :: proc(h, s, l: f16, a: f16 = 1) -> Vector4f16 {
 	hue_to_rgb :: proc(p, q, t: f16) -> f16 {
 		t := t
-		if t < 0 { t += 1; }
-		if t > 1 { t -= 1; }
+		if t < 0 { t += 1 }
+		if t > 1 { t -= 1 }
 		switch {
 		case t < 1.0/6.0: return p + (q - p) * 6.0 * t
 		case t < 1.0/2.0: return q
@@ -287,8 +287,8 @@ vector4_hsl_to_rgb_f16 :: proc(h, s, l: f16, a: f16 = 1) -> Vector4f16 {
 vector4_hsl_to_rgb_f32 :: proc(h, s, l: f32, a: f32 = 1) -> Vector4f32 {
 	hue_to_rgb :: proc(p, q, t: f32) -> f32 {
 		t := t
-		if t < 0 { t += 1; }
-		if t > 1 { t -= 1; }
+		if t < 0 { t += 1 }
+		if t > 1 { t -= 1 }
 		switch {
 		case t < 1.0/6.0: return p + (q - p) * 6.0 * t
 		case t < 1.0/2.0: return q
@@ -314,8 +314,8 @@ vector4_hsl_to_rgb_f32 :: proc(h, s, l: f32, a: f32 = 1) -> Vector4f32 {
 vector4_hsl_to_rgb_f64 :: proc(h, s, l: f64, a: f64 = 1) -> Vector4f64 {
 	hue_to_rgb :: proc(p, q, t: f64) -> f64 {
 		t := t
-		if t < 0 { t += 1; }
-		if t > 1 { t -= 1; }
+		if t < 0 { t += 1 }
+		if t > 1 { t -= 1 }
 		switch {
 		case t < 1.0/6.0: return p + (q - p) * 6.0 * t
 		case t < 1.0/2.0: return q
diff --git a/core/math/math.odin b/core/math/math.odin
index 6a094cfd4..3b26a972f 100644
--- a/core/math/math.odin
+++ b/core/math/math.odin
@@ -96,96 +96,96 @@ foreign _ {
 	ldexp_f64 :: proc(val: f64, exp: i32) -> f64 ---
 }
 
-sqrt_f16le :: proc(x: f16le) -> f16le { return #force_inline f16le(sqrt_f16(f16(x))); }
-sqrt_f16be :: proc(x: f16be) -> f16be { return #force_inline f16be(sqrt_f16(f16(x))); }
-sqrt_f32le :: proc(x: f32le) -> f32le { return #force_inline f32le(sqrt_f32(f32(x))); }
-sqrt_f32be :: proc(x: f32be) -> f32be { return #force_inline f32be(sqrt_f32(f32(x))); }
-sqrt_f64le :: proc(x: f64le) -> f64le { return #force_inline f64le(sqrt_f64(f64(x))); }
-sqrt_f64be :: proc(x: f64be) -> f64be { return #force_inline f64be(sqrt_f64(f64(x))); }
+sqrt_f16le :: proc(x: f16le) -> f16le { return #force_inline f16le(sqrt_f16(f16(x))) }
+sqrt_f16be :: proc(x: f16be) -> f16be { return #force_inline f16be(sqrt_f16(f16(x))) }
+sqrt_f32le :: proc(x: f32le) -> f32le { return #force_inline f32le(sqrt_f32(f32(x))) }
+sqrt_f32be :: proc(x: f32be) -> f32be { return #force_inline f32be(sqrt_f32(f32(x))) }
+sqrt_f64le :: proc(x: f64le) -> f64le { return #force_inline f64le(sqrt_f64(f64(x))) }
+sqrt_f64be :: proc(x: f64be) -> f64be { return #force_inline f64be(sqrt_f64(f64(x))) }
 sqrt       :: proc{
 	sqrt_f16, sqrt_f16le, sqrt_f16be,
 	sqrt_f32, sqrt_f32le, sqrt_f32be,
 	sqrt_f64, sqrt_f64le, sqrt_f64be,
 }
 
-sin_f16le :: proc(θ: f16le) -> f16le { return #force_inline f16le(sin_f16(f16(θ))); }
-sin_f16be :: proc(θ: f16be) -> f16be { return #force_inline f16be(sin_f16(f16(θ))); }
-sin_f32le :: proc(θ: f32le) -> f32le { return #force_inline f32le(sin_f32(f32(θ))); }
-sin_f32be :: proc(θ: f32be) -> f32be { return #force_inline f32be(sin_f32(f32(θ))); }
-sin_f64le :: proc(θ: f64le) -> f64le { return #force_inline f64le(sin_f64(f64(θ))); }
-sin_f64be :: proc(θ: f64be) -> f64be { return #force_inline f64be(sin_f64(f64(θ))); }
+sin_f16le :: proc(θ: f16le) -> f16le { return #force_inline f16le(sin_f16(f16(θ))) }
+sin_f16be :: proc(θ: f16be) -> f16be { return #force_inline f16be(sin_f16(f16(θ))) }
+sin_f32le :: proc(θ: f32le) -> f32le { return #force_inline f32le(sin_f32(f32(θ))) }
+sin_f32be :: proc(θ: f32be) -> f32be { return #force_inline f32be(sin_f32(f32(θ))) }
+sin_f64le :: proc(θ: f64le) -> f64le { return #force_inline f64le(sin_f64(f64(θ))) }
+sin_f64be :: proc(θ: f64be) -> f64be { return #force_inline f64be(sin_f64(f64(θ))) }
 sin       :: proc{
 	sin_f16, sin_f16le, sin_f16be,
 	sin_f32, sin_f32le, sin_f32be,
 	sin_f64, sin_f64le, sin_f64be,
 }
 
-cos_f16le :: proc(θ: f16le) -> f16le { return #force_inline f16le(cos_f16(f16(θ))); }
-cos_f16be :: proc(θ: f16be) -> f16be { return #force_inline f16be(cos_f16(f16(θ))); }
-cos_f32le :: proc(θ: f32le) -> f32le { return #force_inline f32le(cos_f32(f32(θ))); }
-cos_f32be :: proc(θ: f32be) -> f32be { return #force_inline f32be(cos_f32(f32(θ))); }
-cos_f64le :: proc(θ: f64le) -> f64le { return #force_inline f64le(cos_f64(f64(θ))); }
-cos_f64be :: proc(θ: f64be) -> f64be { return #force_inline f64be(cos_f64(f64(θ))); }
+cos_f16le :: proc(θ: f16le) -> f16le { return #force_inline f16le(cos_f16(f16(θ))) }
+cos_f16be :: proc(θ: f16be) -> f16be { return #force_inline f16be(cos_f16(f16(θ))) }
+cos_f32le :: proc(θ: f32le) -> f32le { return #force_inline f32le(cos_f32(f32(θ))) }
+cos_f32be :: proc(θ: f32be) -> f32be { return #force_inline f32be(cos_f32(f32(θ))) }
+cos_f64le :: proc(θ: f64le) -> f64le { return #force_inline f64le(cos_f64(f64(θ))) }
+cos_f64be :: proc(θ: f64be) -> f64be { return #force_inline f64be(cos_f64(f64(θ))) }
 cos       :: proc{
 	cos_f16, cos_f16le, cos_f16be,
 	cos_f32, cos_f32le, cos_f32be,
 	cos_f64, cos_f64le, cos_f64be,
 }
 
-pow_f16le :: proc(x, power: f16le) -> f16le { return #force_inline f16le(pow_f16(f16(x), f16(power))); }
-pow_f16be :: proc(x, power: f16be) -> f16be { return #force_inline f16be(pow_f16(f16(x), f16(power))); }
-pow_f32le :: proc(x, power: f32le) -> f32le { return #force_inline f32le(pow_f32(f32(x), f32(power))); }
-pow_f32be :: proc(x, power: f32be) -> f32be { return #force_inline f32be(pow_f32(f32(x), f32(power))); }
-pow_f64le :: proc(x, power: f64le) -> f64le { return #force_inline f64le(pow_f64(f64(x), f64(power))); }
-pow_f64be :: proc(x, power: f64be) -> f64be { return #force_inline f64be(pow_f64(f64(x), f64(power))); }
+pow_f16le :: proc(x, power: f16le) -> f16le { return #force_inline f16le(pow_f16(f16(x), f16(power))) }
+pow_f16be :: proc(x, power: f16be) -> f16be { return #force_inline f16be(pow_f16(f16(x), f16(power))) }
+pow_f32le :: proc(x, power: f32le) -> f32le { return #force_inline f32le(pow_f32(f32(x), f32(power))) }
+pow_f32be :: proc(x, power: f32be) -> f32be { return #force_inline f32be(pow_f32(f32(x), f32(power))) }
+pow_f64le :: proc(x, power: f64le) -> f64le { return #force_inline f64le(pow_f64(f64(x), f64(power))) }
+pow_f64be :: proc(x, power: f64be) -> f64be { return #force_inline f64be(pow_f64(f64(x), f64(power))) }
 pow       :: proc{
 	pow_f16, pow_f16le, pow_f16be,
 	pow_f32, pow_f32le, pow_f32be,
 	pow_f64, pow_f64le, pow_f64be,
 }
 
-fmuladd_f16le :: proc(a, b, c: f16le) -> f16le { return #force_inline f16le(fmuladd_f16(f16(a), f16(b), f16(c))); }
-fmuladd_f16be :: proc(a, b, c: f16be) -> f16be { return #force_inline f16be(fmuladd_f16(f16(a), f16(b), f16(c))); }
-fmuladd_f32le :: proc(a, b, c: f32le) -> f32le { return #force_inline f32le(fmuladd_f32(f32(a), f32(b), f32(c))); }
-fmuladd_f32be :: proc(a, b, c: f32be) -> f32be { return #force_inline f32be(fmuladd_f32(f32(a), f32(b), f32(c))); }
-fmuladd_f64le :: proc(a, b, c: f64le) -> f64le { return #force_inline f64le(fmuladd_f64(f64(a), f64(b), f64(c))); }
-fmuladd_f64be :: proc(a, b, c: f64be) -> f64be { return #force_inline f64be(fmuladd_f64(f64(a), f64(b), f64(c))); }
+fmuladd_f16le :: proc(a, b, c: f16le) -> f16le { return #force_inline f16le(fmuladd_f16(f16(a), f16(b), f16(c))) }
+fmuladd_f16be :: proc(a, b, c: f16be) -> f16be { return #force_inline f16be(fmuladd_f16(f16(a), f16(b), f16(c))) }
+fmuladd_f32le :: proc(a, b, c: f32le) -> f32le { return #force_inline f32le(fmuladd_f32(f32(a), f32(b), f32(c))) }
+fmuladd_f32be :: proc(a, b, c: f32be) -> f32be { return #force_inline f32be(fmuladd_f32(f32(a), f32(b), f32(c))) }
+fmuladd_f64le :: proc(a, b, c: f64le) -> f64le { return #force_inline f64le(fmuladd_f64(f64(a), f64(b), f64(c))) }
+fmuladd_f64be :: proc(a, b, c: f64be) -> f64be { return #force_inline f64be(fmuladd_f64(f64(a), f64(b), f64(c))) }
 fmuladd       :: proc{
 	fmuladd_f16, fmuladd_f16le, fmuladd_f16be,
 	fmuladd_f32, fmuladd_f32le, fmuladd_f32be,
 	fmuladd_f64, fmuladd_f64le, fmuladd_f64be,
 }
 
-ln_f16le :: proc(x: f16le) -> f16le { return #force_inline f16le(ln_f16(f16(x))); }
-ln_f16be :: proc(x: f16be) -> f16be { return #force_inline f16be(ln_f16(f16(x))); }
-ln_f32le :: proc(x: f32le) -> f32le { return #force_inline f32le(ln_f32(f32(x))); }
-ln_f32be :: proc(x: f32be) -> f32be { return #force_inline f32be(ln_f32(f32(x))); }
-ln_f64le :: proc(x: f64le) -> f64le { return #force_inline f64le(ln_f64(f64(x))); }
-ln_f64be :: proc(x: f64be) -> f64be { return #force_inline f64be(ln_f64(f64(x))); }
+ln_f16le :: proc(x: f16le) -> f16le { return #force_inline f16le(ln_f16(f16(x))) }
+ln_f16be :: proc(x: f16be) -> f16be { return #force_inline f16be(ln_f16(f16(x))) }
+ln_f32le :: proc(x: f32le) -> f32le { return #force_inline f32le(ln_f32(f32(x))) }
+ln_f32be :: proc(x: f32be) -> f32be { return #force_inline f32be(ln_f32(f32(x))) }
+ln_f64le :: proc(x: f64le) -> f64le { return #force_inline f64le(ln_f64(f64(x))) }
+ln_f64be :: proc(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(x: f16le) -> f16le { return #force_inline f16le(exp_f16(f16(x))); }
-exp_f16be :: proc(x: f16be) -> f16be { return #force_inline f16be(exp_f16(f16(x))); }
-exp_f32le :: proc(x: f32le) -> f32le { return #force_inline f32le(exp_f32(f32(x))); }
-exp_f32be :: proc(x: f32be) -> f32be { return #force_inline f32be(exp_f32(f32(x))); }
-exp_f64le :: proc(x: f64le) -> f64le { return #force_inline f64le(exp_f64(f64(x))); }
-exp_f64be :: proc(x: f64be) -> f64be { return #force_inline f64be(exp_f64(f64(x))); }
+exp_f16le :: proc(x: f16le) -> f16le { return #force_inline f16le(exp_f16(f16(x))) }
+exp_f16be :: proc(x: f16be) -> f16be { return #force_inline f16be(exp_f16(f16(x))) }
+exp_f32le :: proc(x: f32le) -> f32le { return #force_inline f32le(exp_f32(f32(x))) }
+exp_f32be :: proc(x: f32be) -> f32be { return #force_inline f32be(exp_f32(f32(x))) }
+exp_f64le :: proc(x: f64le) -> f64le { return #force_inline f64le(exp_f64(f64(x))) }
+exp_f64be :: proc(x: f64be) -> f64be { return #force_inline f64be(exp_f64(f64(x))) }
 exp       :: proc{
 	exp_f16, exp_f16le, exp_f16be,
 	exp_f32, exp_f32le, exp_f32be,
 	exp_f64, exp_f64le, exp_f64be,
 }
 
-ldexp_f16le :: proc(val: f16le, exp: i32) -> f16le { return #force_inline f16le(ldexp_f16(f16(val), exp)); }
-ldexp_f16be :: proc(val: f16be, exp: i32) -> f16be { return #force_inline f16be(ldexp_f16(f16(val), exp)); }
-ldexp_f32le :: proc(val: f32le, exp: i32) -> f32le { return #force_inline f32le(ldexp_f32(f32(val), exp)); }
-ldexp_f32be :: proc(val: f32be, exp: i32) -> f32be { return #force_inline f32be(ldexp_f32(f32(val), exp)); }
-ldexp_f64le :: proc(val: f64le, exp: i32) -> f64le { return #force_inline f64le(ldexp_f64(f64(val), exp)); }
-ldexp_f64be :: proc(val: f64be, exp: i32) -> f64be { return #force_inline f64be(ldexp_f64(f64(val), exp)); }
+ldexp_f16le :: proc(val: f16le, exp: i32) -> f16le { return #force_inline f16le(ldexp_f16(f16(val), exp)) }
+ldexp_f16be :: proc(val: f16be, exp: i32) -> f16be { return #force_inline f16be(ldexp_f16(f16(val), exp)) }
+ldexp_f32le :: proc(val: f32le, exp: i32) -> f32le { return #force_inline f32le(ldexp_f32(f32(val), exp)) }
+ldexp_f32be :: proc(val: f32be, exp: i32) -> f32be { return #force_inline f32be(ldexp_f32(f32(val), exp)) }
+ldexp_f64le :: proc(val: f64le, exp: i32) -> f64le { return #force_inline f64le(ldexp_f64(f64(val), exp)) }
+ldexp_f64be :: proc(val: f64be, exp: i32) -> f64be { return #force_inline f64be(ldexp_f64(f64(val), exp)) }
 ldexp       :: proc{
 	ldexp_f16, ldexp_f16le, ldexp_f16be,
 	ldexp_f32, ldexp_f32le, ldexp_f32be,
@@ -193,76 +193,76 @@ ldexp       :: proc{
 }
 
 
-log_f16   :: proc(x, base: f16)   -> f16   { return ln(x) / ln(base); }
-log_f16le :: proc(x, base: f16le) -> f16le { return f16le(log_f16(f16(x), f16(base))); }
-log_f16be :: proc(x, base: f16be) -> f16be { return f16be(log_f16(f16(x), f16(base))); }
+log_f16   :: proc(x, base: f16)   -> f16   { return ln(x) / ln(base) }
+log_f16le :: proc(x, base: f16le) -> f16le { return f16le(log_f16(f16(x), f16(base))) }
+log_f16be :: proc(x, base: f16be) -> f16be { return f16be(log_f16(f16(x), f16(base))) }
 
-log_f32   :: proc(x, base: f32)   -> f32   { return ln(x) / ln(base); }
-log_f32le :: proc(x, base: f32le) -> f32le { return f32le(log_f32(f32(x), f32(base))); }
-log_f32be :: proc(x, base: f32be) -> f32be { return f32be(log_f32(f32(x), f32(base))); }
+log_f32   :: proc(x, base: f32)   -> f32   { return ln(x) / ln(base) }
+log_f32le :: proc(x, base: f32le) -> f32le { return f32le(log_f32(f32(x), f32(base))) }
+log_f32be :: proc(x, base: f32be) -> f32be { return f32be(log_f32(f32(x), f32(base))) }
 
-log_f64   :: proc(x, base: f64)   -> f64   { return ln(x) / ln(base); }
-log_f64le :: proc(x, base: f64le) -> f64le { return f64le(log_f64(f64(x), f64(base))); }
-log_f64be :: proc(x, base: f64be) -> f64be { return f64be(log_f64(f64(x), f64(base))); }
+log_f64   :: proc(x, base: f64)   -> f64   { return ln(x) / ln(base) }
+log_f64le :: proc(x, base: f64le) -> f64le { return f64le(log_f64(f64(x), f64(base))) }
+log_f64be :: proc(x, base: f64be) -> f64be { return f64be(log_f64(f64(x), f64(base))) }
 log       :: proc{
 	log_f16, log_f16le, log_f16be,
 	log_f32, log_f32le, log_f32be,
 	log_f64, log_f64le, log_f64be,
 }
 
-log2_f16   :: proc(x: f16)   -> f16   { return ln(x)/LN2; }
-log2_f16le :: proc(x: f16le) -> f16le { return f16le(log2_f16(f16(x))); }
-log2_f16be :: proc(x: f16be) -> f16be { return f16be(log2_f16(f16(x))); }
+log2_f16   :: proc(x: f16)   -> f16   { return ln(x)/LN2 }
+log2_f16le :: proc(x: f16le) -> f16le { return f16le(log2_f16(f16(x))) }
+log2_f16be :: proc(x: f16be) -> f16be { return f16be(log2_f16(f16(x))) }
 
-log2_f32   :: proc(x: f32)   -> f32   { return ln(x)/LN2; }
-log2_f32le :: proc(x: f32le) -> f32le { return f32le(log2_f32(f32(x))); }
-log2_f32be :: proc(x: f32be) -> f32be { return f32be(log2_f32(f32(x))); }
+log2_f32   :: proc(x: f32)   -> f32   { return ln(x)/LN2 }
+log2_f32le :: proc(x: f32le) -> f32le { return f32le(log2_f32(f32(x))) }
+log2_f32be :: proc(x: f32be) -> f32be { return f32be(log2_f32(f32(x))) }
 
-log2_f64   :: proc(x: f64)   -> f64   { return ln(x)/LN2; }
-log2_f64le :: proc(x: f64le) -> f64le { return f64le(log2_f64(f64(x))); }
-log2_f64be :: proc(x: f64be) -> f64be { return f64be(log2_f64(f64(x))); }
+log2_f64   :: proc(x: f64)   -> f64   { return ln(x)/LN2 }
+log2_f64le :: proc(x: f64le) -> f64le { return f64le(log2_f64(f64(x))) }
+log2_f64be :: proc(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,
 }
 
-log10_f16   :: proc(x: f16)   -> f16   { return ln(x)/LN10; }
-log10_f16le :: proc(x: f16le) -> f16le { return f16le(log10_f16(f16(x))); }
-log10_f16be :: proc(x: f16be) -> f16be { return f16be(log10_f16(f16(x))); }
+log10_f16   :: proc(x: f16)   -> f16   { return ln(x)/LN10 }
+log10_f16le :: proc(x: f16le) -> f16le { return f16le(log10_f16(f16(x))) }
+log10_f16be :: proc(x: f16be) -> f16be { return f16be(log10_f16(f16(x))) }
 
-log10_f32   :: proc(x: f32)   -> f32   { return ln(x)/LN10; }
-log10_f32le :: proc(x: f32le) -> f32le { return f32le(log10_f32(f32(x))); }
-log10_f32be :: proc(x: f32be) -> f32be { return f32be(log10_f32(f32(x))); }
+log10_f32   :: proc(x: f32)   -> f32   { return ln(x)/LN10 }
+log10_f32le :: proc(x: f32le) -> f32le { return f32le(log10_f32(f32(x))) }
+log10_f32be :: proc(x: f32be) -> f32be { return f32be(log10_f32(f32(x))) }
 
-log10_f64   :: proc(x: f64)   -> f64   { return ln(x)/LN10; }
-log10_f64le :: proc(x: f64le) -> f64le { return f64le(log10_f64(f64(x))); }
-log10_f64be :: proc(x: f64be) -> f64be { return f64be(log10_f64(f64(x))); }
+log10_f64   :: proc(x: f64)   -> f64   { return ln(x)/LN10 }
+log10_f64le :: proc(x: f64le) -> f64le { return f64le(log10_f64(f64(x))) }
+log10_f64be :: proc(x: f64be) -> f64be { return f64be(log10_f64(f64(x))) }
 log10       :: proc{
 	log10_f16, log10_f16le, log10_f16be,
 	log10_f32, log10_f32le, log10_f32be,
 	log10_f64, log10_f64le, log10_f64be,
 }
 
-tan_f16   :: proc(θ: f16)   -> f16   { return sin(θ)/cos(θ); }
-tan_f16le :: proc(θ: f16le) -> f16le { return f16le(tan_f16(f16(θ))); }
-tan_f16be :: proc(θ: f16be) -> f16be { return f16be(tan_f16(f16(θ))); }
+tan_f16   :: proc(θ: f16)   -> f16   { return sin(θ)/cos(θ) }
+tan_f16le :: proc(θ: f16le) -> f16le { return f16le(tan_f16(f16(θ))) }
+tan_f16be :: proc(θ: f16be) -> f16be { return f16be(tan_f16(f16(θ))) }
 
-tan_f32   :: proc(θ: f32)   -> f32   { return sin(θ)/cos(θ); }
-tan_f32le :: proc(θ: f32le) -> f32le { return f32le(tan_f32(f32(θ))); }
-tan_f32be :: proc(θ: f32be) -> f32be { return f32be(tan_f32(f32(θ))); }
+tan_f32   :: proc(θ: f32)   -> f32   { return sin(θ)/cos(θ) }
+tan_f32le :: proc(θ: f32le) -> f32le { return f32le(tan_f32(f32(θ))) }
+tan_f32be :: proc(θ: f32be) -> f32be { return f32be(tan_f32(f32(θ))) }
 
-tan_f64   :: proc(θ: f64)   -> f64   { return sin(θ)/cos(θ); }
-tan_f64le :: proc(θ: f64le) -> f64le { return f64le(tan_f64(f64(θ))); }
-tan_f64be :: proc(θ: f64be) -> f64be { return f64be(tan_f64(f64(θ))); }
+tan_f64   :: proc(θ: f64)   -> f64   { return sin(θ)/cos(θ) }
+tan_f64le :: proc(θ: f64le) -> f64le { return f64le(tan_f64(f64(θ))) }
+tan_f64be :: proc(θ: f64be) -> f64be { return f64be(tan_f64(f64(θ))) }
 tan       :: proc{
 	tan_f16, tan_f16le, tan_f16be,
 	tan_f32, tan_f32le, tan_f32be,
 	tan_f64, tan_f64le, tan_f64be,
 }
 
-lerp :: proc(a, b: $T, t: $E) -> (x: T) { return a*(1-t) + b*t; }
-saturate :: proc(a: $T) -> (x: T) { return clamp(a, 0, 1); }
+lerp :: proc(a, b: $T, t: $E) -> (x: T) { return a*(1-t) + b*t }
+saturate :: proc(a: $T) -> (x: T) { return clamp(a, 0, 1) }
 
 unlerp :: proc(a, b, x: $T) -> (t: T)  where intrinsics.type_is_float(T), !intrinsics.type_is_array(T) {
 	return (x-a)/(b-a)
@@ -311,15 +311,15 @@ gain :: proc(t, g: $T) -> T where intrinsics.type_is_numeric(T) {
 }
 
 
-sign_f16   :: proc(x: f16)   -> f16   { return f16(int(0 < x) - int(x < 0)); }
-sign_f16le :: proc(x: f16le) -> f16le { return f16le(int(0 < x) - int(x < 0)); }
-sign_f16be :: proc(x: f16be) -> f16be { return f16be(int(0 < x) - int(x < 0)); }
-sign_f32   :: proc(x: f32)   -> f32   { return f32(int(0 < x) - int(x < 0)); }
-sign_f32le :: proc(x: f32le) -> f32le { return f32le(int(0 < x) - int(x < 0)); }
-sign_f32be :: proc(x: f32be) -> f32be { return f32be(int(0 < x) - int(x < 0)); }
-sign_f64   :: proc(x: f64)   -> f64   { return f64(int(0 < x) - int(x < 0)); }
-sign_f64le :: proc(x: f64le) -> f64le { return f64le(int(0 < x) - int(x < 0)); }
-sign_f64be :: proc(x: f64be) -> f64be { return f64be(int(0 < x) - int(x < 0)); }
+sign_f16   :: proc(x: f16)   -> f16   { return f16(int(0 < x) - int(x < 0)) }
+sign_f16le :: proc(x: f16le) -> f16le { return f16le(int(0 < x) - int(x < 0)) }
+sign_f16be :: proc(x: f16be) -> f16be { return f16be(int(0 < x) - int(x < 0)) }
+sign_f32   :: proc(x: f32)   -> f32   { return f32(int(0 < x) - int(x < 0)) }
+sign_f32le :: proc(x: f32le) -> f32le { return f32le(int(0 < x) - int(x < 0)) }
+sign_f32be :: proc(x: f32be) -> f32be { return f32be(int(0 < x) - int(x < 0)) }
+sign_f64   :: proc(x: f64)   -> f64   { return f64(int(0 < x) - int(x < 0)) }
+sign_f64le :: proc(x: f64le) -> f64le { return f64le(int(0 < x) - int(x < 0)) }
+sign_f64be :: proc(x: f64be) -> f64be { return f64be(int(0 < x) - int(x < 0)) }
 sign       :: proc{
 	sign_f16, sign_f16le, sign_f16be,
 	sign_f32, sign_f32le, sign_f32be,
@@ -329,18 +329,18 @@ sign       :: proc{
 sign_bit_f16 :: proc(x: f16)     -> bool {
 	return (transmute(u16)x) & (1<<15) != 0
 }
-sign_bit_f16le :: proc(x: f16le) -> bool { return #force_inline sign_bit_f16(f16(x)); }
-sign_bit_f16be :: proc(x: f16be) -> bool { return #force_inline sign_bit_f16(f16(x)); }
+sign_bit_f16le :: proc(x: f16le) -> bool { return #force_inline sign_bit_f16(f16(x)) }
+sign_bit_f16be :: proc(x: f16be) -> bool { return #force_inline sign_bit_f16(f16(x)) }
 sign_bit_f32   :: proc(x: f32)   -> bool {
 	return (transmute(u32)x) & (1<<31) != 0
 }
-sign_bit_f32le :: proc(x: f32le) -> bool { return #force_inline sign_bit_f32(f32(x)); }
-sign_bit_f32be :: proc(x: f32be) -> bool { return #force_inline sign_bit_f32(f32(x)); }
+sign_bit_f32le :: proc(x: f32le) -> bool { return #force_inline sign_bit_f32(f32(x)) }
+sign_bit_f32be :: proc(x: f32be) -> bool { return #force_inline sign_bit_f32(f32(x)) }
 sign_bit_f64   :: proc(x: f64)   -> bool {
 	return (transmute(u64)x) & (1<<63) != 0
 }
-sign_bit_f64le :: proc(x: f64le) -> bool { return #force_inline sign_bit_f64(f64(x)); }
-sign_bit_f64be :: proc(x: f64be) -> bool { return #force_inline sign_bit_f64(f64(x)); }
+sign_bit_f64le :: proc(x: f64le) -> bool { return #force_inline sign_bit_f64(f64(x)) }
+sign_bit_f64be :: proc(x: f64be) -> bool { return #force_inline sign_bit_f64(f64(x)) }
 sign_bit       :: proc{
 	sign_bit_f16, sign_bit_f16le, sign_bit_f16be,
 	sign_bit_f32, sign_bit_f32le, sign_bit_f32be,
@@ -354,8 +354,8 @@ copy_sign_f16   :: proc(x, y: f16) -> f16 {
 	ix |= iy & 0x8000
 	return transmute(f16)ix
 }
-copy_sign_f16le :: proc(x, y: f16le) -> f16le { return #force_inline f16le(copy_sign_f16(f16(x), f16(y))); }
-copy_sign_f16be :: proc(x, y: f16be) -> f16be { return #force_inline f16be(copy_sign_f16(f16(x), f16(y))); }
+copy_sign_f16le :: proc(x, y: f16le) -> f16le { return #force_inline f16le(copy_sign_f16(f16(x), f16(y))) }
+copy_sign_f16be :: proc(x, y: f16be) -> f16be { return #force_inline f16be(copy_sign_f16(f16(x), f16(y))) }
 copy_sign_f32   :: proc(x, y: f32) -> f32 {
 	ix := transmute(u32)x
 	iy := transmute(u32)y
@@ -363,8 +363,8 @@ copy_sign_f32   :: proc(x, y: f32) -> f32 {
 	ix |= iy & 0x8000_0000
 	return transmute(f32)ix
 }
-copy_sign_f32le :: proc(x, y: f32le) -> f32le { return #force_inline f32le(copy_sign_f32(f32(x), f32(y))); }
-copy_sign_f32be :: proc(x, y: f32be) -> f32be { return #force_inline f32be(copy_sign_f32(f32(x), f32(y))); }
+copy_sign_f32le :: proc(x, y: f32le) -> f32le { return #force_inline f32le(copy_sign_f32(f32(x), f32(y))) }
+copy_sign_f32be :: proc(x, y: f32be) -> f32be { return #force_inline f32be(copy_sign_f32(f32(x), f32(y))) }
 copy_sign_f64   :: proc(x, y: f64) -> f64 {
 	ix := transmute(u64)x
 	iy := transmute(u64)y
@@ -372,32 +372,32 @@ copy_sign_f64   :: proc(x, y: f64) -> f64 {
 	ix |= iy & 0x8000_0000_0000_0000
 	return transmute(f64)ix
 }
-copy_sign_f64le :: proc(x, y: f64le) -> f64le { return #force_inline f64le(copy_sign_f64(f64(x), f64(y))); }
-copy_sign_f64be :: proc(x, y: f64be) -> f64be { return #force_inline f64be(copy_sign_f64(f64(x), f64(y))); }
+copy_sign_f64le :: proc(x, y: f64le) -> f64le { return #force_inline f64le(copy_sign_f64(f64(x), f64(y))) }
+copy_sign_f64be :: proc(x, y: f64be) -> f64be { return #force_inline f64be(copy_sign_f64(f64(x), f64(y))) }
 copy_sign       :: proc{
 	copy_sign_f16, copy_sign_f16le, copy_sign_f16be,
 	copy_sign_f32, copy_sign_f32le, copy_sign_f32be,
 	copy_sign_f64, copy_sign_f64le, copy_sign_f64be,
 }
 
-to_radians_f16   :: proc(degrees: f16)   -> f16   { return degrees * RAD_PER_DEG; }
-to_radians_f16le :: proc(degrees: f16le) -> f16le { return degrees * RAD_PER_DEG; }
-to_radians_f16be :: proc(degrees: f16be) -> f16be { return degrees * RAD_PER_DEG; }
-to_radians_f32   :: proc(degrees: f32)   -> f32   { return degrees * RAD_PER_DEG; }
-to_radians_f32le :: proc(degrees: f32le) -> f32le { return degrees * RAD_PER_DEG; }
-to_radians_f32be :: proc(degrees: f32be) -> f32be { return degrees * RAD_PER_DEG; }
-to_radians_f64   :: proc(degrees: f64)   -> f64   { return degrees * RAD_PER_DEG; }
-to_radians_f64le :: proc(degrees: f64le) -> f64le { return degrees * RAD_PER_DEG; }
-to_radians_f64be :: proc(degrees: f64be) -> f64be { return degrees * RAD_PER_DEG; }
-to_degrees_f16   :: proc(radians: f16)   -> f16   { return radians * DEG_PER_RAD; }
-to_degrees_f16le :: proc(radians: f16le) -> f16le { return radians * DEG_PER_RAD; }
-to_degrees_f16be :: proc(radians: f16be) -> f16be { return radians * DEG_PER_RAD; }
-to_degrees_f32   :: proc(radians: f32)   -> f32   { return radians * DEG_PER_RAD; }
-to_degrees_f32le :: proc(radians: f32le) -> f32le { return radians * DEG_PER_RAD; }
-to_degrees_f32be :: proc(radians: f32be) -> f32be { return radians * DEG_PER_RAD; }
-to_degrees_f64   :: proc(radians: f64)   -> f64   { return radians * DEG_PER_RAD; }
-to_degrees_f64le :: proc(radians: f64le) -> f64le { return radians * DEG_PER_RAD; }
-to_degrees_f64be :: proc(radians: f64be) -> f64be { return radians * DEG_PER_RAD; }
+to_radians_f16   :: proc(degrees: f16)   -> f16   { return degrees * RAD_PER_DEG }
+to_radians_f16le :: proc(degrees: f16le) -> f16le { return degrees * RAD_PER_DEG }
+to_radians_f16be :: proc(degrees: f16be) -> f16be { return degrees * RAD_PER_DEG }
+to_radians_f32   :: proc(degrees: f32)   -> f32   { return degrees * RAD_PER_DEG }
+to_radians_f32le :: proc(degrees: f32le) -> f32le { return degrees * RAD_PER_DEG }
+to_radians_f32be :: proc(degrees: f32be) -> f32be { return degrees * RAD_PER_DEG }
+to_radians_f64   :: proc(degrees: f64)   -> f64   { return degrees * RAD_PER_DEG }
+to_radians_f64le :: proc(degrees: f64le) -> f64le { return degrees * RAD_PER_DEG }
+to_radians_f64be :: proc(degrees: f64be) -> f64be { return degrees * RAD_PER_DEG }
+to_degrees_f16   :: proc(radians: f16)   -> f16   { return radians * DEG_PER_RAD }
+to_degrees_f16le :: proc(radians: f16le) -> f16le { return radians * DEG_PER_RAD }
+to_degrees_f16be :: proc(radians: f16be) -> f16be { return radians * DEG_PER_RAD }
+to_degrees_f32   :: proc(radians: f32)   -> f32   { return radians * DEG_PER_RAD }
+to_degrees_f32le :: proc(radians: f32le) -> f32le { return radians * DEG_PER_RAD }
+to_degrees_f32be :: proc(radians: f32be) -> f32be { return radians * DEG_PER_RAD }
+to_degrees_f64   :: proc(radians: f64)   -> f64   { return radians * DEG_PER_RAD }
+to_degrees_f64le :: proc(radians: f64le) -> f64le { return radians * DEG_PER_RAD }
+to_degrees_f64be :: proc(radians: f64be) -> f64be { return radians * DEG_PER_RAD }
 to_radians       :: proc{
 	to_radians_f16, to_radians_f16le, to_radians_f16be,
 	to_radians_f32, to_radians_f32le, to_radians_f32be,
@@ -438,8 +438,8 @@ trunc_f16   :: proc(x: f16) -> f16 {
 	}
 	return trunc_internal(x)
 }
-trunc_f16le :: proc(x: f16le) -> f16le { return #force_inline f16le(trunc_f16(f16(x))); }
-trunc_f16be :: proc(x: f16be) -> f16be { return #force_inline f16be(trunc_f16(f16(x))); }
+trunc_f16le :: proc(x: f16le) -> f16le { return #force_inline f16le(trunc_f16(f16(x))) }
+trunc_f16be :: proc(x: f16be) -> f16be { return #force_inline f16be(trunc_f16(f16(x))) }
 
 trunc_f32   :: proc(x: f32) -> f32 {
 	trunc_internal :: proc(f: f32) -> f32 {
@@ -470,8 +470,8 @@ trunc_f32   :: proc(x: f32) -> f32 {
 	}
 	return trunc_internal(x)
 }
-trunc_f32le :: proc(x: f32le) -> f32le { return #force_inline f32le(trunc_f32(f32(x))); }
-trunc_f32be :: proc(x: f32be) -> f32be { return #force_inline f32be(trunc_f32(f32(x))); }
+trunc_f32le :: proc(x: f32le) -> f32le { return #force_inline f32le(trunc_f32(f32(x))) }
+trunc_f32be :: proc(x: f32be) -> f32be { return #force_inline f32be(trunc_f32(f32(x))) }
 
 trunc_f64   :: proc(x: f64) -> f64 {
 	trunc_internal :: proc(f: f64) -> f64 {
@@ -502,8 +502,8 @@ trunc_f64   :: proc(x: f64) -> f64 {
 	}
 	return trunc_internal(x)
 }
-trunc_f64le :: proc(x: f64le) -> f64le { return #force_inline f64le(trunc_f64(f64(x))); }
-trunc_f64be :: proc(x: f64be) -> f64be { return #force_inline f64be(trunc_f64(f64(x))); }
+trunc_f64le :: proc(x: f64le) -> f64le { return #force_inline f64le(trunc_f64(f64(x))) }
+trunc_f64be :: proc(x: f64be) -> f64be { return #force_inline f64be(trunc_f64(f64(x))) }
 trunc       :: proc{
 	trunc_f16, trunc_f16le, trunc_f16be,
 	trunc_f32, trunc_f32le, trunc_f32be, 
@@ -545,17 +545,17 @@ round       :: proc{
 }
 
 
-ceil_f16   :: proc(x: f16)   -> f16   { return -floor(-x); }
-ceil_f16le :: proc(x: f16le) -> f16le { return -floor(-x); }
-ceil_f16be :: proc(x: f16be) -> f16be { return -floor(-x); }
+ceil_f16   :: proc(x: f16)   -> f16   { return -floor(-x) }
+ceil_f16le :: proc(x: f16le) -> f16le { return -floor(-x) }
+ceil_f16be :: proc(x: f16be) -> f16be { return -floor(-x) }
 
-ceil_f32   :: proc(x: f32)   -> f32   { return -floor(-x); }
-ceil_f32le :: proc(x: f32le) -> f32le { return -floor(-x); }
-ceil_f32be :: proc(x: f32be) -> f32be { return -floor(-x); }
+ceil_f32   :: proc(x: f32)   -> f32   { return -floor(-x) }
+ceil_f32le :: proc(x: f32le) -> f32le { return -floor(-x) }
+ceil_f32be :: proc(x: f32be) -> f32be { return -floor(-x) }
 
-ceil_f64   :: proc(x: f64)   -> f64   { return -floor(-x); }
-ceil_f64le :: proc(x: f64le) -> f64le { return -floor(-x); }
-ceil_f64be :: proc(x: f64be) -> f64be { return -floor(-x); }
+ceil_f64   :: proc(x: f64)   -> f64   { return -floor(-x) }
+ceil_f64le :: proc(x: f64le) -> f64le { return -floor(-x) }
+ceil_f64be :: proc(x: f64be) -> f64be { return -floor(-x) }
 
 ceil       :: proc{
 	ceil_f16, ceil_f16le, ceil_f16be,
@@ -577,8 +577,8 @@ floor_f16   :: proc(x: f16)   -> f16 {
 	d, _ := modf(x)
 	return d
 }
-floor_f16le :: proc(x: f16le) -> f16le { return #force_inline f16le(floor_f16(f16(x))); }
-floor_f16be :: proc(x: f16be) -> f16be { return #force_inline f16be(floor_f16(f16(x))); }
+floor_f16le :: proc(x: f16le) -> f16le { return #force_inline f16le(floor_f16(f16(x))) }
+floor_f16be :: proc(x: f16be) -> f16be { return #force_inline f16be(floor_f16(f16(x))) }
 floor_f32   :: proc(x: f32)   -> f32 {
 	if x == 0 || is_nan(x) || is_inf(x) {
 		return x
@@ -593,8 +593,8 @@ floor_f32   :: proc(x: f32)   -> f32 {
 	d, _ := modf(x)
 	return d
 }
-floor_f32le :: proc(x: f32le) -> f32le { return #force_inline f32le(floor_f32(f32(x))); }
-floor_f32be :: proc(x: f32be) -> f32be { return #force_inline f32be(floor_f32(f32(x))); }
+floor_f32le :: proc(x: f32le) -> f32le { return #force_inline f32le(floor_f32(f32(x))) }
+floor_f32be :: proc(x: f32be) -> f32be { return #force_inline f32be(floor_f32(f32(x))) }
 floor_f64   :: proc(x: f64)   -> f64 {
 	if x == 0 || is_nan(x) || is_inf(x) {
 		return x
@@ -609,8 +609,8 @@ floor_f64   :: proc(x: f64)   -> f64 {
 	d, _ := modf(x)
 	return d
 }
-floor_f64le :: proc(x: f64le) -> f64le { return #force_inline f64le(floor_f64(f64(x))); }
-floor_f64be :: proc(x: f64be) -> f64be { return #force_inline f64be(floor_f64(f64(x))); }
+floor_f64le :: proc(x: f64le) -> f64le { return #force_inline f64le(floor_f64(f64(x))) }
+floor_f64be :: proc(x: f64be) -> f64be { return #force_inline f64be(floor_f64(f64(x))) }
 floor       :: proc{
 	floor_f16, floor_f16le, floor_f16be,
 	floor_f32, floor_f32le, floor_f32be,
@@ -754,8 +754,8 @@ mod_f16   :: proc(x, y: f16) -> (n: f16) {
 	}
 	return copy_sign(n, x)
 }
-mod_f16le :: proc(x, y: f16le) -> (n: f16le) { return #force_inline f16le(mod_f16(f16(x), f16(y))); }
-mod_f16be :: proc(x, y: f16be) -> (n: f16be) { return #force_inline f16be(mod_f16(f16(x), f16(y))); }
+mod_f16le :: proc(x, y: f16le) -> (n: f16le) { return #force_inline f16le(mod_f16(f16(x), f16(y))) }
+mod_f16be :: proc(x, y: f16be) -> (n: f16be) { return #force_inline f16be(mod_f16(f16(x), f16(y))) }
 mod_f32   :: proc(x, y: f32)   -> (n: f32) {
 	z := abs(y)
 	n = remainder(abs(x), z)
@@ -764,8 +764,8 @@ mod_f32   :: proc(x, y: f32)   -> (n: f32) {
 	}
 	return copy_sign(n, x)
 }
-mod_f32le :: proc(x, y: f32le) -> (n: f32le) { return #force_inline f32le(mod_f32(f32(x), f32(y))); }
-mod_f32be :: proc(x, y: f32be) -> (n: f32be) { return #force_inline f32be(mod_f32(f32(x), f32(y))); }
+mod_f32le :: proc(x, y: f32le) -> (n: f32le) { return #force_inline f32le(mod_f32(f32(x), f32(y))) }
+mod_f32be :: proc(x, y: f32be) -> (n: f32be) { return #force_inline f32be(mod_f32(f32(x), f32(y))) }
 mod_f64   :: proc(x, y: f64)   -> (n: f64) {
 	z := abs(y)
 	n = remainder(abs(x), z)
@@ -774,23 +774,23 @@ mod_f64   :: proc(x, y: f64)   -> (n: f64) {
 	}
 	return copy_sign(n, x)
 }
-mod_f64le :: proc(x, y: f64le) -> (n: f64le) { return #force_inline f64le(mod_f64(f64(x), f64(y))); }
-mod_f64be :: proc(x, y: f64be) -> (n: f64be) { return #force_inline f64be(mod_f64(f64(x), f64(y))); }
+mod_f64le :: proc(x, y: f64le) -> (n: f64le) { return #force_inline f64le(mod_f64(f64(x), f64(y))) }
+mod_f64be :: proc(x, y: f64be) -> (n: f64be) { return #force_inline f64be(mod_f64(f64(x), f64(y))) }
 mod       :: proc{
 	mod_f16, mod_f16le, mod_f16be,
 	mod_f32, mod_f32le, mod_f32be,
 	mod_f64, mod_f64le, mod_f64be,
 }
 
-remainder_f16   :: proc(x, y: f16  ) -> f16   { return x - round(x/y) * y; }
-remainder_f16le :: proc(x, y: f16le) -> f16le { return x - round(x/y) * y; }
-remainder_f16be :: proc(x, y: f16be) -> f16be { return x - round(x/y) * y; }
-remainder_f32   :: proc(x, y: f32  ) -> f32   { return x - round(x/y) * y; }
-remainder_f32le :: proc(x, y: f32le) -> f32le { return x - round(x/y) * y; }
-remainder_f32be :: proc(x, y: f32be) -> f32be { return x - round(x/y) * y; }
-remainder_f64   :: proc(x, y: f64  ) -> f64   { return x - round(x/y) * y; }
-remainder_f64le :: proc(x, y: f64le) -> f64le { return x - round(x/y) * y; }
-remainder_f64be :: proc(x, y: f64be) -> f64be { return x - round(x/y) * y; }
+remainder_f16   :: proc(x, y: f16  ) -> f16   { return x - round(x/y) * y }
+remainder_f16le :: proc(x, y: f16le) -> f16le { return x - round(x/y) * y }
+remainder_f16be :: proc(x, y: f16be) -> f16be { return x - round(x/y) * y }
+remainder_f32   :: proc(x, y: f32  ) -> f32   { return x - round(x/y) * y }
+remainder_f32le :: proc(x, y: f32le) -> f32le { return x - round(x/y) * y }
+remainder_f32be :: proc(x, y: f32be) -> f32be { return x - round(x/y) * y }
+remainder_f64   :: proc(x, y: f64  ) -> f64   { return x - round(x/y) * y }
+remainder_f64le :: proc(x, y: f64le) -> f64le { return x - round(x/y) * y }
+remainder_f64be :: proc(x, y: f64be) -> f64be { return x - round(x/y) * y }
 remainder       :: proc{
 	remainder_f16, remainder_f16le, remainder_f16be,
 	remainder_f32, remainder_f32le, remainder_f32be,
@@ -958,8 +958,8 @@ classify_f16   :: proc(x: f16)   -> Float_Class {
 	}
 	return .Normal
 }
-classify_f16le :: proc(x: f16le) -> Float_Class { return #force_inline classify_f16(f16(x)); }
-classify_f16be :: proc(x: f16be) -> Float_Class { return #force_inline classify_f16(f16(x)); }
+classify_f16le :: proc(x: f16le) -> Float_Class { return #force_inline classify_f16(f16(x)) }
+classify_f16be :: proc(x: f16be) -> Float_Class { return #force_inline classify_f16(f16(x)) }
 classify_f32   :: proc(x: f32)   -> Float_Class {
 	switch {
 	case x == 0:
@@ -984,8 +984,8 @@ classify_f32   :: proc(x: f32)   -> Float_Class {
 	}
 	return .Normal
 }
-classify_f32le :: proc(x: f32le) -> Float_Class { return #force_inline classify_f32(f32(x)); }
-classify_f32be :: proc(x: f32be) -> Float_Class { return #force_inline classify_f32(f32(x)); }
+classify_f32le :: proc(x: f32le) -> Float_Class { return #force_inline classify_f32(f32(x)) }
+classify_f32be :: proc(x: f32be) -> Float_Class { return #force_inline classify_f32(f32(x)) }
 classify_f64   :: proc(x: f64)   -> Float_Class {
 	switch {
 	case x == 0:
@@ -1009,23 +1009,23 @@ classify_f64   :: proc(x: f64)   -> Float_Class {
 	}
 	return .Normal
 }
-classify_f64le :: proc(x: f64le) -> Float_Class { return #force_inline classify_f64(f64(x)); }
-classify_f64be :: proc(x: f64be) -> Float_Class { return #force_inline classify_f64(f64(x)); }
+classify_f64le :: proc(x: f64le) -> Float_Class { return #force_inline classify_f64(f64(x)) }
+classify_f64be :: proc(x: f64be) -> Float_Class { return #force_inline classify_f64(f64(x)) }
 classify       :: proc{
 	classify_f16, classify_f16le, classify_f16be,
 	classify_f32, classify_f32le, classify_f32be,
 	classify_f64, classify_f64le, classify_f64be,
 }
 
-is_nan_f16   :: proc(x: f16)   -> bool { return classify(x) == .NaN; }
-is_nan_f16le :: proc(x: f16le) -> bool { return classify(x) == .NaN; }
-is_nan_f16be :: proc(x: f16be) -> bool { return classify(x) == .NaN; }
-is_nan_f32   :: proc(x: f32)   -> bool { return classify(x) == .NaN; }
-is_nan_f32le :: proc(x: f32le) -> bool { return classify(x) == .NaN; }
-is_nan_f32be :: proc(x: f32be) -> bool { return classify(x) == .NaN; }
-is_nan_f64   :: proc(x: f64)   -> bool { return classify(x) == .NaN; }
-is_nan_f64le :: proc(x: f64le) -> bool { return classify(x) == .NaN; }
-is_nan_f64be :: proc(x: f64be) -> bool { return classify(x) == .NaN; }
+is_nan_f16   :: proc(x: f16)   -> bool { return classify(x) == .NaN }
+is_nan_f16le :: proc(x: f16le) -> bool { return classify(x) == .NaN }
+is_nan_f16be :: proc(x: f16be) -> bool { return classify(x) == .NaN }
+is_nan_f32   :: proc(x: f32)   -> bool { return classify(x) == .NaN }
+is_nan_f32le :: proc(x: f32le) -> bool { return classify(x) == .NaN }
+is_nan_f32be :: proc(x: f32be) -> bool { return classify(x) == .NaN }
+is_nan_f64   :: proc(x: f64)   -> bool { return classify(x) == .NaN }
+is_nan_f64le :: proc(x: f64le) -> bool { return classify(x) == .NaN }
+is_nan_f64be :: proc(x: f64be) -> bool { return classify(x) == .NaN }
 is_nan       :: proc{
 	is_nan_f16, is_nan_f16le, is_nan_f16be,
 	is_nan_f32, is_nan_f32le, is_nan_f32be,
diff --git a/core/math/rand/rand.odin b/core/math/rand/rand.odin
index 1a833d3ca..9bd30c216 100644
--- a/core/math/rand/rand.odin
+++ b/core/math/rand/rand.odin
@@ -43,7 +43,7 @@ _random :: proc(r: ^Rand) -> u32 {
 	return (xor_shifted >> rot) | (xor_shifted << ((-rot) & 31))
 }
 
-uint32 :: proc(r: ^Rand = nil) -> u32 { return _random(r); }
+uint32 :: proc(r: ^Rand = nil) -> u32 { return _random(r) }
 
 uint64 :: proc(r: ^Rand = nil) -> u64 {
 	a := u64(_random(r))
@@ -59,9 +59,9 @@ uint128 :: proc(r: ^Rand = nil) -> u128 {
 	return (a<<96) | (b<<64) | (c<<32) | d
 }
 
-int31  :: proc(r: ^Rand = nil) -> i32  { return i32(uint32(r) << 1 >> 1); }
-int63  :: proc(r: ^Rand = nil) -> i64  { return i64(uint64(r) << 1 >> 1); }
-int127 :: proc(r: ^Rand = nil) -> i128 { return i128(uint128(r) << 1 >> 1); }
+int31  :: proc(r: ^Rand = nil) -> i32  { return i32(uint32(r) << 1 >> 1) }
+int63  :: proc(r: ^Rand = nil) -> i64  { return i64(uint64(r) << 1 >> 1) }
+int127 :: proc(r: ^Rand = nil) -> i128 { return i128(uint128(r) << 1 >> 1) }
 
 int31_max :: proc(n: i32, r: ^Rand = nil) -> i32 {
 	if n <= 0 {
@@ -119,11 +119,11 @@ int_max :: proc(n: int, r: ^Rand = nil) -> int {
 	}
 }
 
-float64 :: proc(r: ^Rand = nil) -> f64 { return f64(int63_max(1<<53, r)) / (1 << 53); }
-float32 :: proc(r: ^Rand = nil) -> f32 { return f32(float64(r)); }
+float64 :: proc(r: ^Rand = nil) -> f64 { return f64(int63_max(1<<53, r)) / (1 << 53) }
+float32 :: proc(r: ^Rand = nil) -> f32 { return f32(float64(r)) }
 
-float64_range :: proc(lo, hi: f64, r: ^Rand = nil) -> f64 { return (hi-lo)*float64(r) + lo; }
-float32_range :: proc(lo, hi: f32, r: ^Rand = nil) -> f32 { return (hi-lo)*float32(r) + lo; }
+float64_range :: proc(lo, hi: f64, r: ^Rand = nil) -> f64 { return (hi-lo)*float64(r) + lo }
+float32_range :: proc(lo, hi: f32, r: ^Rand = nil) -> f32 { return (hi-lo)*float32(r) + lo }
 
 
 read :: proc(p: []byte, r: ^Rand = nil) -> (n: int) {
diff --git a/core/mem/mem.odin b/core/mem/mem.odin
index 57ab943c2..d7ff949e2 100644
--- a/core/mem/mem.odin
+++ b/core/mem/mem.odin
@@ -184,10 +184,10 @@ any_to_bytes :: proc(val: any) -> []byte {
 }
 
 
-kilobytes :: proc(x: int) -> int { return          (x) * 1024; }
-megabytes :: proc(x: int) -> int { return kilobytes(x) * 1024; }
-gigabytes :: proc(x: int) -> int { return megabytes(x) * 1024; }
-terabytes :: proc(x: int) -> int { return gigabytes(x) * 1024; }
+kilobytes :: proc(x: int) -> int { return          (x) * 1024 }
+megabytes :: proc(x: int) -> int { return kilobytes(x) * 1024 }
+gigabytes :: proc(x: int) -> int { return megabytes(x) * 1024 }
+terabytes :: proc(x: int) -> int { return gigabytes(x) * 1024 }
 
 is_power_of_two :: proc(x: uintptr) -> bool {
 	if x <= 0 {
diff --git a/core/odin/parser/parser.odin b/core/odin/parser/parser.odin
index 3053f2255..af81b9041 100644
--- a/core/odin/parser/parser.odin
+++ b/core/odin/parser/parser.odin
@@ -1051,13 +1051,13 @@ parse_attribute :: proc(p: ^Parser, tok: tokenizer.Token, open_kind, close_kind:
 	decl := parse_stmt(p)
 	switch d in &decl.derived {
 	case ast.Value_Decl:
-		if d.docs == nil { d.docs = docs; }
+		if d.docs == nil { d.docs = docs }
 		append(&d.attributes, attribute)
 	case ast.Foreign_Block_Decl:
-		if d.docs == nil { d.docs = docs; }
+		if d.docs == nil { d.docs = docs }
 		append(&d.attributes, attribute)
 	case ast.Foreign_Import_Decl:
-		if d.docs == nil { d.docs = docs; }
+		if d.docs == nil { d.docs = docs }
 		append(&d.attributes, attribute)
 	case:
 		error(p, decl.pos, "expected a value or foreign declaration after an attribute")
@@ -1693,20 +1693,20 @@ parse_field_prefixes :: proc(p: ^Parser) -> ast.Field_Flags {
 		switch kind {
 		case .Invalid, .Unknown: // Ignore
 		case .Using:
-			if count > 1 { error(p, p.curr_tok.pos, "multiple 'using' in this field list"); }
-			if count > 0 { flags += {.Using}; }
+			if count > 1 { error(p, p.curr_tok.pos, "multiple 'using' in this field list") }
+			if count > 0 { flags += {.Using} }
 		case .No_Alias:
-			if count > 1 { error(p, p.curr_tok.pos, "multiple '#no_alias' in this field list"); }
-			if count > 0 { flags += {.No_Alias}; }
+			if count > 1 { error(p, p.curr_tok.pos, "multiple '#no_alias' in this field list") }
+			if count > 0 { flags += {.No_Alias} }
 		case .C_Vararg:
-			if count > 1 { error(p, p.curr_tok.pos, "multiple '#c_vararg' in this field list"); }
-			if count > 0 { flags += {.C_Vararg}; }
+			if count > 1 { error(p, p.curr_tok.pos, "multiple '#c_vararg' in this field list") }
+			if count > 0 { flags += {.C_Vararg} }
 		case .Auto_Cast:
-			if count > 1 { error(p, p.curr_tok.pos, "multiple 'auto_cast' in this field list"); }
-			if count > 0 { flags += {.Auto_Cast}; }
+			if count > 1 { error(p, p.curr_tok.pos, "multiple 'auto_cast' in this field list") }
+			if count > 0 { flags += {.Auto_Cast} }
 		case .Any_Int:
-			if count > 1 { error(p, p.curr_tok.pos, "multiple '#any_int' in this field list"); }
-			if count > 0 { flags += {.Any_Int}; }
+			if count > 1 { error(p, p.curr_tok.pos, "multiple '#any_int' in this field list") }
+			if count > 0 { flags += {.Any_Int} }
 		}
 	}
 
diff --git a/core/os/stat_windows.odin b/core/os/stat_windows.odin
index d7181f089..48f193cdb 100644
--- a/core/os/stat_windows.odin
+++ b/core/os/stat_windows.odin
@@ -108,7 +108,7 @@ cleanpath_strip_prefix :: proc(buf: []u16) -> []u16 {
 	buf := buf
 	N := 0
 	for c, i in buf {
-		if c == 0 { break; }
+		if c == 0 { break }
 		N = i+1
 	}
 	buf = buf[:N]
diff --git a/core/reflect/reflect.odin b/core/reflect/reflect.odin
index ed653b6b1..7c5d851b4 100644
--- a/core/reflect/reflect.odin
+++ b/core/reflect/reflect.odin
@@ -117,7 +117,7 @@ backing_type_kind :: proc(T: typeid) -> Type_Kind {
 
 
 type_info_base :: proc(info: ^Type_Info) -> ^Type_Info {
-	if info == nil { return nil; }
+	if info == nil { return nil }
 
 	base := info
 	loop: for {
@@ -131,7 +131,7 @@ type_info_base :: proc(info: ^Type_Info) -> ^Type_Info {
 
 
 type_info_core :: proc(info: ^Type_Info) -> ^Type_Info {
-	if info == nil { return nil; }
+	if info == nil { return nil }
 
 	base := info
 	loop: for {
@@ -159,7 +159,7 @@ typeid_base_without_enum :: typeid_core
 
 typeid_elem :: proc(id: typeid) -> typeid {
 	ti := type_info_of(id)
-	if ti == nil { return nil; }
+	if ti == nil { return nil }
 
 	bits := 8*ti.size
 
@@ -228,7 +228,7 @@ is_nil :: proc(v: any) -> bool {
 }
 
 length :: proc(val: any) -> int {
-	if val == nil { return 0; }
+	if val == nil { return 0 }
 
 	#partial switch a in type_info_of(val.id).variant {
 	case Type_Info_Named:
@@ -263,7 +263,7 @@ length :: proc(val: any) -> int {
 }
 
 capacity :: proc(val: any) -> int {
-	if val == nil { return 0; }
+	if val == nil { return 0 }
 
 	#partial switch a in type_info_of(val.id).variant {
 	case Type_Info_Named:
@@ -289,7 +289,7 @@ capacity :: proc(val: any) -> int {
 
 
 index :: proc(val: any, i: int, loc := #caller_location) -> any {
-	if val == nil { return nil; }
+	if val == nil { return nil }
 
 	#partial switch a in type_info_of(val.id).variant {
 	case Type_Info_Named:
@@ -336,7 +336,7 @@ index :: proc(val: any, i: int, loc := #caller_location) -> any {
 		return any{data, a.elem.id}
 
 	case Type_Info_String:
-		if a.is_cstring { return nil; }
+		if a.is_cstring { return nil }
 
 		raw := (^mem.Raw_String)(val.data)
 		runtime.bounds_check_error_loc(loc, i, raw.len)
@@ -395,7 +395,7 @@ struct_field_by_name :: proc(T: typeid, name: string) -> (field: Struct_Field) {
 }
 
 struct_field_value_by_name :: proc(a: any, field: string, allow_using := false) -> any {
-	if a == nil { return nil; }
+	if a == nil { return nil }
 
 	ti := runtime.type_info_base(type_info_of(a.id))
 
@@ -538,7 +538,7 @@ struct_tag_lookup :: proc(tag: Struct_Tag, key: string) -> (value: Struct_Tag, o
 
 
 enum_string :: proc(a: any) -> string {
-	if a == nil { return ""; }
+	if a == nil { return "" }
 	ti := runtime.type_info_base(type_info_of(a.id))
 	if e, ok := ti.variant.(runtime.Type_Info_Enum); ok {
 		v, _ := as_i64(a)
@@ -627,7 +627,7 @@ type_info_union_is_pure_maybe :: proc(info: runtime.Type_Info_Union) -> bool {
 }
 
 union_variant_typeid :: proc(a: any) -> typeid {
-	if a == nil { return nil; }
+	if a == nil { return nil }
 
 	ti := runtime.type_info_base(type_info_of(a.id))
 	if info, ok := ti.variant.(runtime.Type_Info_Union); ok {
@@ -666,7 +666,7 @@ union_variant_typeid :: proc(a: any) -> typeid {
 }
 
 get_union_variant_raw_tag :: proc(a: any) -> i64 {
-	if a == nil { return -1; }
+	if a == nil { return -1 }
 
 	ti := runtime.type_info_base(type_info_of(a.id))
 	if info, ok := ti.variant.(runtime.Type_Info_Union); ok {
@@ -697,7 +697,7 @@ get_union_variant_raw_tag :: proc(a: any) -> i64 {
 
 
 set_union_variant_raw_tag :: proc(a: any, tag: i64) {
-	if a == nil { return; }
+	if a == nil { return }
 
 	ti := runtime.type_info_base(type_info_of(a.id))
 	if info, ok := ti.variant.(runtime.Type_Info_Union); ok {
@@ -727,7 +727,7 @@ set_union_variant_raw_tag :: proc(a: any, tag: i64) {
 }
 
 set_union_variant_typeid :: proc(a: any, id: typeid) {
-	if a == nil { return; }
+	if a == nil { return }
 
 	ti := runtime.type_info_base(type_info_of(a.id))
 	if info, ok := ti.variant.(runtime.Type_Info_Union); ok {
@@ -757,7 +757,7 @@ set_union_variant_typeid :: proc(a: any, id: typeid) {
 }
 
 set_union_variant_type_info :: proc(a: any, tag_ti: ^Type_Info) {
-	if a == nil { return; }
+	if a == nil { return }
 
 	ti := runtime.type_info_base(type_info_of(a.id))
 	if info, ok := ti.variant.(runtime.Type_Info_Union); ok {
@@ -788,7 +788,7 @@ set_union_variant_type_info :: proc(a: any, tag_ti: ^Type_Info) {
 
 
 as_bool :: proc(a: any) -> (value: bool, valid: bool) {
-	if a == nil { return; }
+	if a == nil { return }
 	a := a
 	ti := runtime.type_info_core(type_info_of(a.id))
 	a.id = ti.id
@@ -824,7 +824,7 @@ as_uint :: proc(a: any) -> (value: uint, valid: bool) {
 }
 
 as_i64 :: proc(a: any) -> (value: i64, valid: bool) {
-	if a == nil { return; }
+	if a == nil { return }
 	a := a
 	ti := runtime.type_info_core(type_info_of(a.id))
 	a.id = ti.id
@@ -931,7 +931,7 @@ as_i64 :: proc(a: any) -> (value: i64, valid: bool) {
 }
 
 as_u64 :: proc(a: any) -> (value: u64, valid: bool) {
-	if a == nil { return; }
+	if a == nil { return }
 	a := a
 	ti := runtime.type_info_core(type_info_of(a.id))
 	a.id = ti.id
@@ -1039,7 +1039,7 @@ as_u64 :: proc(a: any) -> (value: u64, valid: bool) {
 
 
 as_f64 :: proc(a: any) -> (value: f64, valid: bool) {
-	if a == nil { return; }
+	if a == nil { return }
 	a := a
 	ti := runtime.type_info_core(type_info_of(a.id))
 	a.id = ti.id
@@ -1144,7 +1144,7 @@ as_f64 :: proc(a: any) -> (value: f64, valid: bool) {
 
 
 as_string :: proc(a: any) -> (value: string, valid: bool) {
-	if a == nil { return; }
+	if a == nil { return }
 	a := a
 	ti := runtime.type_info_core(type_info_of(a.id))
 	a.id = ti.id
@@ -1163,7 +1163,7 @@ as_string :: proc(a: any) -> (value: string, valid: bool) {
 }
 
 relative_pointer_to_absolute :: proc(a: any) -> rawptr {
-	if a == nil { return nil; }
+	if a == nil { return nil }
 	a := a
 	ti := runtime.type_info_core(type_info_of(a.id))
 	a.id = ti.id
@@ -1219,7 +1219,7 @@ relative_pointer_to_absolute_raw :: proc(data: rawptr, base_integer_id: typeid)
 
 
 as_pointer :: proc(a: any) -> (value: rawptr, valid: bool) {
-	if a == nil { return; }
+	if a == nil { return }
 	a := a
 	ti := runtime.type_info_core(type_info_of(a.id))
 	a.id = ti.id
@@ -1246,7 +1246,7 @@ as_pointer :: proc(a: any) -> (value: rawptr, valid: bool) {
 
 
 as_raw_data :: proc(a: any) -> (value: rawptr, valid: bool) {
-	if a == nil { return; }
+	if a == nil { return }
 	a := a
 	ti := runtime.type_info_core(type_info_of(a.id))
 	a.id = ti.id
diff --git a/core/reflect/types.odin b/core/reflect/types.odin
index 3c4ccadf8..56e9db021 100644
--- a/core/reflect/types.odin
+++ b/core/reflect/types.odin
@@ -80,12 +80,12 @@ are_types_identical :: proc(a, b: ^Type_Info) -> bool {
 
 	case Type_Info_Array:
 		y := b.variant.(Type_Info_Array) or_return
-		if x.count != y.count { return false; }
+		if x.count != y.count { return false }
 		return are_types_identical(x.elem, y.elem)
 
 	case Type_Info_Enumerated_Array:
 		y := b.variant.(Type_Info_Enumerated_Array) or_return
-		if x.count != y.count { return false; }
+		if x.count != y.count { return false }
 		return are_types_identical(x.index, y.index) &&
 		       are_types_identical(x.elem, y.elem)
 
@@ -99,7 +99,7 @@ are_types_identical :: proc(a, b: ^Type_Info) -> bool {
 
 	case Type_Info_Tuple:
 		y := b.variant.(Type_Info_Tuple) or_return
-		if len(x.types) != len(y.types) { return false; }
+		if len(x.types) != len(y.types) { return false }
 		for _, i in x.types {
 			xt, yt := x.types[i], y.types[i]
 			if !are_types_identical(xt, yt) {
@@ -125,19 +125,19 @@ are_types_identical :: proc(a, b: ^Type_Info) -> bool {
 			xt, yt := x.types[i], y.types[i]
 			xl, yl := x.tags[i],  y.tags[i]
 
-			if xn != yn { return false; }
-			if !are_types_identical(xt, yt) { return false; }
-			if xl != yl { return false; }
+			if xn != yn { return false }
+			if !are_types_identical(xt, yt) { return false }
+			if xl != yl { return false }
 		}
 		return true
 
 	case Type_Info_Union:
 		y := b.variant.(Type_Info_Union) or_return
-		if len(x.variants) != len(y.variants) { return false; }
+		if len(x.variants) != len(y.variants) { return false }
 
 		for _, i in x.variants {
 			xv, yv := x.variants[i], y.variants[i]
-			if !are_types_identical(xv, yv) { return false; }
+			if !are_types_identical(xv, yv) { return false }
 		}
 		return true
 
@@ -170,7 +170,7 @@ are_types_identical :: proc(a, b: ^Type_Info) -> bool {
 }
 
 is_signed :: proc(info: ^Type_Info) -> bool {
-	if info == nil { return false; }
+	if info == nil { return false }
 	#partial switch i in type_info_base(info).variant {
 	case Type_Info_Integer: return i.signed
 	case Type_Info_Float:   return true
@@ -178,7 +178,7 @@ is_signed :: proc(info: ^Type_Info) -> bool {
 	return false
 }
 is_unsigned :: proc(info: ^Type_Info) -> bool {
-	if info == nil { return false; }
+	if info == nil { return false }
 	#partial switch i in type_info_base(info).variant {
 	case Type_Info_Integer: return !i.signed
 	case Type_Info_Float:   return false
@@ -187,7 +187,7 @@ is_unsigned :: proc(info: ^Type_Info) -> bool {
 }
 
 is_byte :: proc(info: ^Type_Info) -> bool {
-	if info == nil { return false; }
+	if info == nil { return false }
 	#partial switch i in type_info_base(info).variant {
 	case Type_Info_Integer: return info.size == 1
 	}
@@ -196,127 +196,127 @@ is_byte :: proc(info: ^Type_Info) -> bool {
 
 
 is_integer :: proc(info: ^Type_Info) -> bool {
-	if info == nil { return false; }
+	if info == nil { return false }
 	_, ok := type_info_base(info).variant.(Type_Info_Integer)
 	return ok
 }
 is_rune :: proc(info: ^Type_Info) -> bool {
-	if info == nil { return false; }
+	if info == nil { return false }
 	_, ok := type_info_base(info).variant.(Type_Info_Rune)
 	return ok
 }
 is_float :: proc(info: ^Type_Info) -> bool {
-	if info == nil { return false; }
+	if info == nil { return false }
 	_, ok := type_info_base(info).variant.(Type_Info_Float)
 	return ok
 }
 is_complex :: proc(info: ^Type_Info) -> bool {
-	if info == nil { return false; }
+	if info == nil { return false }
 	_, ok := type_info_base(info).variant.(Type_Info_Complex)
 	return ok
 }
 is_quaternion :: proc(info: ^Type_Info) -> bool {
-	if info == nil { return false; }
+	if info == nil { return false }
 	_, ok := type_info_base(info).variant.(Type_Info_Quaternion)
 	return ok
 }
 is_any :: proc(info: ^Type_Info) -> bool {
-	if info == nil { return false; }
+	if info == nil { return false }
 	_, ok := type_info_base(info).variant.(Type_Info_Any)
 	return ok
 }
 is_string :: proc(info: ^Type_Info) -> bool {
-	if info == nil { return false; }
+	if info == nil { return false }
 	_, ok := type_info_base(info).variant.(Type_Info_String)
 	return ok
 }
 is_cstring :: proc(info: ^Type_Info) -> bool {
-	if info == nil { return false; }
+	if info == nil { return false }
 	v, ok := type_info_base(info).variant.(Type_Info_String)
 	return ok && v.is_cstring
 }
 is_boolean :: proc(info: ^Type_Info) -> bool {
-	if info == nil { return false; }
+	if info == nil { return false }
 	_, ok := type_info_base(info).variant.(Type_Info_Boolean)
 	return ok
 }
 is_pointer :: proc(info: ^Type_Info) -> bool {
-	if info == nil { return false; }
+	if info == nil { return false }
 	_, ok := type_info_base(info).variant.(Type_Info_Pointer)
 	return ok
 }
 is_multi_pointer :: proc(info: ^Type_Info) -> bool {
-	if info == nil { return false; }
+	if info == nil { return false }
 	_, ok := type_info_base(info).variant.(Type_Info_Multi_Pointer)
 	return ok
 }
 is_procedure :: proc(info: ^Type_Info) -> bool {
-	if info == nil { return false; }
+	if info == nil { return false }
 	_, ok := type_info_base(info).variant.(Type_Info_Procedure)
 	return ok
 }
 is_array :: proc(info: ^Type_Info) -> bool {
-	if info == nil { return false; }
+	if info == nil { return false }
 	_, ok := type_info_base(info).variant.(Type_Info_Array)
 	return ok
 }
 is_enumerated_array :: proc(info: ^Type_Info) -> bool {
-	if info == nil { return false; }
+	if info == nil { return false }
 	_, ok := type_info_base(info).variant.(Type_Info_Enumerated_Array)
 	return ok
 }
 is_dynamic_array :: proc(info: ^Type_Info) -> bool {
-	if info == nil { return false; }
+	if info == nil { return false }
 	_, ok := type_info_base(info).variant.(Type_Info_Dynamic_Array)
 	return ok
 }
 is_dynamic_map :: proc(info: ^Type_Info) -> bool {
-	if info == nil { return false; }
+	if info == nil { return false }
 	_, ok := type_info_base(info).variant.(Type_Info_Map)
 	return ok
 }
 is_slice :: proc(info: ^Type_Info) -> bool {
-	if info == nil { return false; }
+	if info == nil { return false }
 	_, ok := type_info_base(info).variant.(Type_Info_Slice)
 	return ok
 }
 is_tuple :: proc(info: ^Type_Info) -> bool {
-	if info == nil { return false; }
+	if info == nil { return false }
 	_, ok := type_info_base(info).variant.(Type_Info_Tuple)
 	return ok
 }
 is_struct :: proc(info: ^Type_Info) -> bool {
-	if info == nil { return false; }
+	if info == nil { return false }
 	s, ok := type_info_base(info).variant.(Type_Info_Struct)
 	return ok && !s.is_raw_union
 }
 is_raw_union :: proc(info: ^Type_Info) -> bool {
-	if info == nil { return false; }
+	if info == nil { return false }
 	s, ok := type_info_base(info).variant.(Type_Info_Struct)
 	return ok && s.is_raw_union
 }
 is_union :: proc(info: ^Type_Info) -> bool {
-	if info == nil { return false; }
+	if info == nil { return false }
 	_, ok := type_info_base(info).variant.(Type_Info_Union)
 	return ok
 }
 is_enum :: proc(info: ^Type_Info) -> bool {
-	if info == nil { return false; }
+	if info == nil { return false }
 	_, ok := type_info_base(info).variant.(Type_Info_Enum)
 	return ok
 }
 is_simd_vector :: proc(info: ^Type_Info) -> bool {
-	if info == nil { return false; }
+	if info == nil { return false }
 	_, ok := type_info_base(info).variant.(Type_Info_Simd_Vector)
 	return ok
 }
 is_relative_pointer :: proc(info: ^Type_Info) -> bool {
-	if info == nil { return false; }
+	if info == nil { return false }
 	_, ok := type_info_base(info).variant.(Type_Info_Relative_Pointer)
 	return ok
 }
 is_relative_slice :: proc(info: ^Type_Info) -> bool {
-	if info == nil { return false; }
+	if info == nil { return false }
 	_, ok := type_info_base(info).variant.(Type_Info_Relative_Slice)
 	return ok
 }
@@ -354,8 +354,8 @@ write_type_writer :: proc(w: io.Writer, ti: ^Type_Info) -> (n: int) {
 		return write_string(w, "nil")
 	}
 
-	_n1 :: proc(err: io.Error) -> int { return 1 if err == nil else 0; }
-	_n2 :: proc(n: int, _: io.Error) -> int { return n; }
+	_n1 :: proc(err: io.Error) -> int { return 1 if err == nil else 0 }
+	_n2 :: proc(n: int, _: io.Error) -> int { return n }
 	_n :: proc{_n1, _n2}
 
 	switch info in ti.variant {
@@ -441,9 +441,9 @@ write_type_writer :: proc(w: io.Writer, ti: ^Type_Info) -> (n: int) {
 		}
 	case Type_Info_Tuple:
 		count := len(info.names)
-		if count != 1 { n += write_string(w, "("); }
+		if count != 1 { n += write_string(w, "(") }
 		for name, i in info.names {
-			if i > 0 { n += write_string(w, ", "); }
+			if i > 0 { n += write_string(w, ", ") }
 
 			t := info.types[i]
 
@@ -453,7 +453,7 @@ write_type_writer :: proc(w: io.Writer, ti: ^Type_Info) -> (n: int) {
 			}
 			n += write_type(w, t)
 		}
-		if count != 1 { n += write_string(w, ")"); }
+		if count != 1 { n += write_string(w, ")") }
 
 	case Type_Info_Array:
 		n += _n(io.write_string(w, "["))
@@ -500,8 +500,8 @@ write_type_writer :: proc(w: io.Writer, ti: ^Type_Info) -> (n: int) {
 		}
 
 		n += write_string(w, "struct ")
-		if info.is_packed    { n += write_string(w, "#packed "); }
-		if info.is_raw_union { n += write_string(w, "#raw_union "); }
+		if info.is_packed    { n += write_string(w, "#packed ") }
+		if info.is_raw_union { n += write_string(w, "#raw_union ") }
 		if info.custom_align {
 			n += _n(io.write_string(w, "#align "))
 			n += _n(io.write_i64(w, i64(ti.align), 10))
@@ -509,7 +509,7 @@ write_type_writer :: proc(w: io.Writer, ti: ^Type_Info) -> (n: int) {
 		}
 		n += _n(io.write_byte(w, '{'))
 		for name, i in info.names {
-			if i > 0 { n += write_string(w, ", "); }
+			if i > 0 { n += write_string(w, ", ") }
 			n += _n(io.write_string(w, name))
 			n += _n(io.write_string(w, ": "))
 			n += write_type(w, info.types[i])
@@ -525,7 +525,7 @@ write_type_writer :: proc(w: io.Writer, ti: ^Type_Info) -> (n: int) {
 		}
 		n += _n(io.write_byte(w, '{'))
 		for variant, i in info.variants {
-			if i > 0 { n += write_string(w, ", "); }
+			if i > 0 { n += write_string(w, ", ") }
 			n += write_type(w, variant)
 		}
 		n += _n(io.write_byte(w, '}'))
@@ -535,7 +535,7 @@ write_type_writer :: proc(w: io.Writer, ti: ^Type_Info) -> (n: int) {
 		n += write_type(w, info.base)
 		n += write_string(w, " {")
 		for name, i in info.names {
-			if i > 0 { n += write_string(w, ", "); }
+			if i > 0 { n += write_string(w, ", ") }
 			n += write_string(w, name)
 		}
 		n += _n(io.write_byte(w, '}'))
diff --git a/core/runtime/dynamic_map_internal.odin b/core/runtime/dynamic_map_internal.odin
index 9d8604bc0..36265c03e 100644
--- a/core/runtime/dynamic_map_internal.odin
+++ b/core/runtime/dynamic_map_internal.odin
@@ -101,22 +101,22 @@ default_hasher_n :: #force_inline proc "contextless" (data: rawptr, seed: uintpt
 
 // NOTE(bill): There are loads of predefined ones to improve optimizations for small types
 
-default_hasher1  :: proc "contextless" (data: rawptr, seed: uintptr) -> uintptr { return #force_inline _default_hasher_const(data, seed,  1); }
-default_hasher2  :: proc "contextless" (data: rawptr, seed: uintptr) -> uintptr { return #force_inline _default_hasher_const(data, seed,  2); }
-default_hasher3  :: proc "contextless" (data: rawptr, seed: uintptr) -> uintptr { return #force_inline _default_hasher_const(data, seed,  3); }
-default_hasher4  :: proc "contextless" (data: rawptr, seed: uintptr) -> uintptr { return #force_inline _default_hasher_const(data, seed,  4); }
-default_hasher5  :: proc "contextless" (data: rawptr, seed: uintptr) -> uintptr { return #force_inline _default_hasher_const(data, seed,  5); }
-default_hasher6  :: proc "contextless" (data: rawptr, seed: uintptr) -> uintptr { return #force_inline _default_hasher_const(data, seed,  6); }
-default_hasher7  :: proc "contextless" (data: rawptr, seed: uintptr) -> uintptr { return #force_inline _default_hasher_const(data, seed,  7); }
-default_hasher8  :: proc "contextless" (data: rawptr, seed: uintptr) -> uintptr { return #force_inline _default_hasher_const(data, seed,  8); }
-default_hasher9  :: proc "contextless" (data: rawptr, seed: uintptr) -> uintptr { return #force_inline _default_hasher_const(data, seed,  9); }
-default_hasher10 :: proc "contextless" (data: rawptr, seed: uintptr) -> uintptr { return #force_inline _default_hasher_const(data, seed, 10); }
-default_hasher11 :: proc "contextless" (data: rawptr, seed: uintptr) -> uintptr { return #force_inline _default_hasher_const(data, seed, 11); }
-default_hasher12 :: proc "contextless" (data: rawptr, seed: uintptr) -> uintptr { return #force_inline _default_hasher_const(data, seed, 12); }
-default_hasher13 :: proc "contextless" (data: rawptr, seed: uintptr) -> uintptr { return #force_inline _default_hasher_const(data, seed, 13); }
-default_hasher14 :: proc "contextless" (data: rawptr, seed: uintptr) -> uintptr { return #force_inline _default_hasher_const(data, seed, 14); }
-default_hasher15 :: proc "contextless" (data: rawptr, seed: uintptr) -> uintptr { return #force_inline _default_hasher_const(data, seed, 15); }
-default_hasher16 :: proc "contextless" (data: rawptr, seed: uintptr) -> uintptr { return #force_inline _default_hasher_const(data, seed, 16); }
+default_hasher1  :: proc "contextless" (data: rawptr, seed: uintptr) -> uintptr { return #force_inline _default_hasher_const(data, seed,  1) }
+default_hasher2  :: proc "contextless" (data: rawptr, seed: uintptr) -> uintptr { return #force_inline _default_hasher_const(data, seed,  2) }
+default_hasher3  :: proc "contextless" (data: rawptr, seed: uintptr) -> uintptr { return #force_inline _default_hasher_const(data, seed,  3) }
+default_hasher4  :: proc "contextless" (data: rawptr, seed: uintptr) -> uintptr { return #force_inline _default_hasher_const(data, seed,  4) }
+default_hasher5  :: proc "contextless" (data: rawptr, seed: uintptr) -> uintptr { return #force_inline _default_hasher_const(data, seed,  5) }
+default_hasher6  :: proc "contextless" (data: rawptr, seed: uintptr) -> uintptr { return #force_inline _default_hasher_const(data, seed,  6) }
+default_hasher7  :: proc "contextless" (data: rawptr, seed: uintptr) -> uintptr { return #force_inline _default_hasher_const(data, seed,  7) }
+default_hasher8  :: proc "contextless" (data: rawptr, seed: uintptr) -> uintptr { return #force_inline _default_hasher_const(data, seed,  8) }
+default_hasher9  :: proc "contextless" (data: rawptr, seed: uintptr) -> uintptr { return #force_inline _default_hasher_const(data, seed,  9) }
+default_hasher10 :: proc "contextless" (data: rawptr, seed: uintptr) -> uintptr { return #force_inline _default_hasher_const(data, seed, 10) }
+default_hasher11 :: proc "contextless" (data: rawptr, seed: uintptr) -> uintptr { return #force_inline _default_hasher_const(data, seed, 11) }
+default_hasher12 :: proc "contextless" (data: rawptr, seed: uintptr) -> uintptr { return #force_inline _default_hasher_const(data, seed, 12) }
+default_hasher13 :: proc "contextless" (data: rawptr, seed: uintptr) -> uintptr { return #force_inline _default_hasher_const(data, seed, 13) }
+default_hasher14 :: proc "contextless" (data: rawptr, seed: uintptr) -> uintptr { return #force_inline _default_hasher_const(data, seed, 14) }
+default_hasher15 :: proc "contextless" (data: rawptr, seed: uintptr) -> uintptr { return #force_inline _default_hasher_const(data, seed, 15) }
+default_hasher16 :: proc "contextless" (data: rawptr, seed: uintptr) -> uintptr { return #force_inline _default_hasher_const(data, seed, 16) }
 
 default_hasher_string :: proc "contextless" (data: rawptr, seed: uintptr) -> uintptr {
 	h := u64(seed) + 0xcbf29ce484222325
diff --git a/core/runtime/internal.odin b/core/runtime/internal.odin
index 912ca9d84..139d8d666 100644
--- a/core/runtime/internal.odin
+++ b/core/runtime/internal.odin
@@ -275,11 +275,11 @@ string_cmp :: proc "contextless" (a, b: string) -> int {
 	return memory_compare(x.data, y.data, min(x.len, y.len))
 }
 
-string_ne :: #force_inline proc "contextless" (a, b: string) -> bool { return !string_eq(a, b); }
-string_lt :: #force_inline proc "contextless" (a, b: string) -> bool { return string_cmp(a, b) < 0; }
-string_gt :: #force_inline proc "contextless" (a, b: string) -> bool { return string_cmp(a, b) > 0; }
-string_le :: #force_inline proc "contextless" (a, b: string) -> bool { return string_cmp(a, b) <= 0; }
-string_ge :: #force_inline proc "contextless" (a, b: string) -> bool { return string_cmp(a, b) >= 0; }
+string_ne :: #force_inline proc "contextless" (a, b: string) -> bool { return !string_eq(a, b) }
+string_lt :: #force_inline proc "contextless" (a, b: string) -> bool { return string_cmp(a, b) < 0 }
+string_gt :: #force_inline proc "contextless" (a, b: string) -> bool { return string_cmp(a, b) > 0 }
+string_le :: #force_inline proc "contextless" (a, b: string) -> bool { return string_cmp(a, b) <= 0 }
+string_ge :: #force_inline proc "contextless" (a, b: string) -> bool { return string_cmp(a, b) >= 0 }
 
 cstring_len :: proc "contextless" (s: cstring) -> int {
 	p0 := uintptr((^byte)(s))
@@ -300,24 +300,24 @@ cstring_to_string :: proc "contextless" (s: cstring) -> string {
 }
 
 
-complex32_eq :: #force_inline proc "contextless"  (a, b: complex32)  -> bool { return real(a) == real(b) && imag(a) == imag(b); }
-complex32_ne :: #force_inline proc "contextless"  (a, b: complex32)  -> bool { return real(a) != real(b) || imag(a) != imag(b); }
+complex32_eq :: #force_inline proc "contextless"  (a, b: complex32)  -> bool { return real(a) == real(b) && imag(a) == imag(b) }
+complex32_ne :: #force_inline proc "contextless"  (a, b: complex32)  -> bool { return real(a) != real(b) || imag(a) != imag(b) }
 
-complex64_eq :: #force_inline proc "contextless"  (a, b: complex64)  -> bool { return real(a) == real(b) && imag(a) == imag(b); }
-complex64_ne :: #force_inline proc "contextless"  (a, b: complex64)  -> bool { return real(a) != real(b) || imag(a) != imag(b); }
+complex64_eq :: #force_inline proc "contextless"  (a, b: complex64)  -> bool { return real(a) == real(b) && imag(a) == imag(b) }
+complex64_ne :: #force_inline proc "contextless"  (a, b: complex64)  -> bool { return real(a) != real(b) || imag(a) != imag(b) }
 
-complex128_eq :: #force_inline proc "contextless" (a, b: complex128) -> bool { return real(a) == real(b) && imag(a) == imag(b); }
-complex128_ne :: #force_inline proc "contextless" (a, b: complex128) -> bool { return real(a) != real(b) || imag(a) != imag(b); }
+complex128_eq :: #force_inline proc "contextless" (a, b: complex128) -> bool { return real(a) == real(b) && imag(a) == imag(b) }
+complex128_ne :: #force_inline proc "contextless" (a, b: complex128) -> bool { return real(a) != real(b) || imag(a) != imag(b) }
 
 
-quaternion64_eq :: #force_inline proc "contextless"  (a, b: quaternion64)  -> bool { return real(a) == real(b) && imag(a) == imag(b) && jmag(a) == jmag(b) && kmag(a) == kmag(b); }
-quaternion64_ne :: #force_inline proc "contextless"  (a, b: quaternion64)  -> bool { return real(a) != real(b) || imag(a) != imag(b) || jmag(a) != jmag(b) || kmag(a) != kmag(b); }
+quaternion64_eq :: #force_inline proc "contextless"  (a, b: quaternion64)  -> bool { return real(a) == real(b) && imag(a) == imag(b) && jmag(a) == jmag(b) && kmag(a) == kmag(b) }
+quaternion64_ne :: #force_inline proc "contextless"  (a, b: quaternion64)  -> bool { return real(a) != real(b) || imag(a) != imag(b) || jmag(a) != jmag(b) || kmag(a) != kmag(b) }
 
-quaternion128_eq :: #force_inline proc "contextless"  (a, b: quaternion128)  -> bool { return real(a) == real(b) && imag(a) == imag(b) && jmag(a) == jmag(b) && kmag(a) == kmag(b); }
-quaternion128_ne :: #force_inline proc "contextless"  (a, b: quaternion128)  -> bool { return real(a) != real(b) || imag(a) != imag(b) || jmag(a) != jmag(b) || kmag(a) != kmag(b); }
+quaternion128_eq :: #force_inline proc "contextless"  (a, b: quaternion128)  -> bool { return real(a) == real(b) && imag(a) == imag(b) && jmag(a) == jmag(b) && kmag(a) == kmag(b) }
+quaternion128_ne :: #force_inline proc "contextless"  (a, b: quaternion128)  -> bool { return real(a) != real(b) || imag(a) != imag(b) || jmag(a) != jmag(b) || kmag(a) != kmag(b) }
 
-quaternion256_eq :: #force_inline proc "contextless" (a, b: quaternion256) -> bool { return real(a) == real(b) && imag(a) == imag(b) && jmag(a) == jmag(b) && kmag(a) == kmag(b); }
-quaternion256_ne :: #force_inline proc "contextless" (a, b: quaternion256) -> bool { return real(a) != real(b) || imag(a) != imag(b) || jmag(a) != jmag(b) || kmag(a) != kmag(b); }
+quaternion256_eq :: #force_inline proc "contextless" (a, b: quaternion256) -> bool { return real(a) == real(b) && imag(a) == imag(b) && jmag(a) == jmag(b) && kmag(a) == kmag(b) }
+quaternion256_ne :: #force_inline proc "contextless" (a, b: quaternion256) -> bool { return real(a) != real(b) || imag(a) != imag(b) || jmag(a) != jmag(b) || kmag(a) != kmag(b) }
 
 
 string_decode_rune :: #force_inline proc "contextless" (s: string) -> (rune, int) {
diff --git a/core/runtime/print.odin b/core/runtime/print.odin
index 717a3018d..07fc87fe6 100644
--- a/core/runtime/print.odin
+++ b/core/runtime/print.odin
@@ -214,7 +214,7 @@ print_type :: proc "contextless" (ti: ^Type_Info) {
 			t := info.params.variant.(Type_Info_Tuple)
 			print_byte('(')
 			for t, i in t.types {
-				if i > 0 { print_string(", "); }
+				if i > 0 { print_string(", ") }
 				print_type(t)
 			}
 			print_string(")")
@@ -225,9 +225,9 @@ print_type :: proc "contextless" (ti: ^Type_Info) {
 		}
 	case Type_Info_Tuple:
 		count := len(info.names)
-		if count != 1 { print_byte('('); }
+		if count != 1 { print_byte('(') }
 		for name, i in info.names {
-			if i > 0 { print_string(", "); }
+			if i > 0 { print_string(", ") }
 
 			t := info.types[i]
 
@@ -237,7 +237,7 @@ print_type :: proc "contextless" (ti: ^Type_Info) {
 			}
 			print_type(t)
 		}
-		if count != 1 { print_string(")"); }
+		if count != 1 { print_string(")") }
 
 	case Type_Info_Array:
 		print_byte('[')
@@ -285,8 +285,8 @@ print_type :: proc "contextless" (ti: ^Type_Info) {
 		}
 
 		print_string("struct ")
-		if info.is_packed    { print_string("#packed "); }
-		if info.is_raw_union { print_string("#raw_union "); }
+		if info.is_packed    { print_string("#packed ") }
+		if info.is_raw_union { print_string("#raw_union ") }
 		if info.custom_align {
 			print_string("#align ")
 			print_u64(u64(ti.align))
@@ -294,7 +294,7 @@ print_type :: proc "contextless" (ti: ^Type_Info) {
 		}
 		print_byte('{')
 		for name, i in info.names {
-			if i > 0 { print_string(", "); }
+			if i > 0 { print_string(", ") }
 			print_string(name)
 			print_string(": ")
 			print_type(info.types[i])
@@ -312,7 +312,7 @@ print_type :: proc "contextless" (ti: ^Type_Info) {
 		}
 		print_byte('{')
 		for variant, i in info.variants {
-			if i > 0 { print_string(", "); }
+			if i > 0 { print_string(", ") }
 			print_type(variant)
 		}
 		print_string("}")
@@ -322,7 +322,7 @@ print_type :: proc "contextless" (ti: ^Type_Info) {
 		print_type(info.base)
 		print_string(" {")
 		for name, i in info.names {
-			if i > 0 { print_string(", "); }
+			if i > 0 { print_string(", ") }
 			print_string(name)
 		}
 		print_string("}")
diff --git a/core/sort/sort.odin b/core/sort/sort.odin
index 3ece4cac4..b79b2c13f 100644
--- a/core/sort/sort.odin
+++ b/core/sort/sort.odin
@@ -367,8 +367,8 @@ quick_sort_proc :: proc(array: $A/[]$T, f: proc(T, T) -> int) {
 	i, j := 0, n-1
 
 	loop: for {
-		for f(a[i], p) < 0 { i += 1; }
-		for f(p, a[j]) < 0 { j -= 1; }
+		for f(a[i], p) < 0 { i += 1 }
+		for f(p, a[j]) < 0 { j -= 1 }
 
 		if i >= j {
 			break loop
@@ -395,8 +395,8 @@ quick_sort :: proc(array: $A/[]$T) where intrinsics.type_is_ordered(T) {
 	i, j := 0, n-1
 
 	loop: for {
-		for a[i] < p { i += 1; }
-		for p < a[j] { j -= 1; }
+		for a[i] < p { i += 1 }
+		for p < a[j] { j -= 1 }
 
 		if i >= j {
 			break loop
diff --git a/core/strconv/decimal/decimal.odin b/core/strconv/decimal/decimal.odin
index eddcef001..57bb6a482 100644
--- a/core/strconv/decimal/decimal.odin
+++ b/core/strconv/decimal/decimal.odin
@@ -202,7 +202,7 @@ shift :: proc(a: ^Decimal, i: int) {
 }
 
 can_round_up :: proc(a: ^Decimal, nd: int) -> bool {
-	if nd < 0 || nd >= a.count { return false ; }
+	if nd < 0 || nd >= a.count { return false  }
 	if a.digits[nd] == '5' && nd+1 == a.count {
 		if a.trunc {
 			return true
@@ -214,7 +214,7 @@ can_round_up :: proc(a: ^Decimal, nd: int) -> bool {
 }
 
 round :: proc(a: ^Decimal, nd: int) {
-	if nd < 0 || nd >= a.count { return; }
+	if nd < 0 || nd >= a.count { return }
 	if can_round_up(a, nd) {
 		round_up(a, nd)
 	} else {
@@ -223,7 +223,7 @@ round :: proc(a: ^Decimal, nd: int) {
 }
 
 round_up :: proc(a: ^Decimal, nd: int) {
-	if nd < 0 || nd >= a.count { return; }
+	if nd < 0 || nd >= a.count { return }
 
 	for i := nd-1; i >= 0; i -= 1 {
 		if c := a.digits[i]; c < '9' {
@@ -240,7 +240,7 @@ round_up :: proc(a: ^Decimal, nd: int) {
 }
 
 round_down :: proc(a: ^Decimal, nd: int) {
-	if nd < 0 || nd >= a.count { return; }
+	if nd < 0 || nd >= a.count { return }
 	a.count = nd
 	trim(a)
 }
diff --git a/core/strconv/strconv.odin b/core/strconv/strconv.odin
index 782f9d9a3..7881f094a 100644
--- a/core/strconv/strconv.odin
+++ b/core/strconv/strconv.odin
@@ -402,11 +402,11 @@ parse_f64 :: proc(str: string) -> (value: f64, ok: bool) {
 				}
 				exp = exp * 10 + d
 			}
-			if exp > 308 { exp = 308; }
+			if exp > 308 { exp = 308 }
 
-			for exp >= 50 { scale *= 1e50; exp -= 50; }
-			for exp >=  8 { scale *=  1e8; exp -=  8; }
-			for exp >   0 { scale *=   10; exp -=  1; }
+			for exp >= 50 { scale *= 1e50; exp -= 50 }
+			for exp >=  8 { scale *=  1e8; exp -=  8 }
+			for exp >   0 { scale *=   10; exp -=  1 }
 		}
 	}
 	s = s[i:]
diff --git a/core/strings/strings.odin b/core/strings/strings.odin
index 2919a6e47..6ace03b48 100644
--- a/core/strings/strings.odin
+++ b/core/strings/strings.odin
@@ -207,11 +207,11 @@ cut :: proc(s: string, rune_offset := int(0), rune_length := int(0), allocator :
 	s := s; rune_length := rune_length
 	l := utf8.rune_count_in_string(s)
 
-	if rune_offset >= l { return ""; }
+	if rune_offset >= l { return "" }
 	if rune_offset == 0 && rune_length <= 0 {
 		return clone(s, allocator)
 	}
-	if rune_length == 0 { rune_length = l; }
+	if rune_length == 0 { rune_length = l }
 
 	bytes_needed := min(rune_length * 4, len(s))
 	buf := make([]u8, bytes_needed, allocator)
@@ -226,7 +226,7 @@ cut :: proc(s: string, rune_offset := int(0), rune_length := int(0), allocator :
 			byte_offset += w
 		}
 		if rune_length > 0 {
-			if i == rune_offset + rune_length - 1 { break; }
+			if i == rune_offset + rune_length - 1 { break }
 		}
 		s = s[w:]
 	}
diff --git a/core/sync/atomic.odin b/core/sync/atomic.odin
index 5996d981f..21dcea178 100644
--- a/core/sync/atomic.odin
+++ b/core/sync/atomic.odin
@@ -23,62 +23,62 @@ strongest_failure_ordering :: #force_inline proc(order: Ordering) -> Ordering {
 }
 
 fence :: #force_inline proc($order: Ordering) {
-	     when order == .Relaxed                 { #panic("there is no such thing as a relaxed fence"); }
-	else when order == .Release                 { intrinsics.atomic_fence_rel();                       }
-	else when order == .Acquire                 { intrinsics.atomic_fence_acq();                       }
-	else when order == .Acquire_Release         { intrinsics.atomic_fence_acqrel();                    }
-	else when order == .Sequentially_Consistent { intrinsics.atomic_fence();                           }
-	else { #panic("unknown order"); }
+	     when order == .Relaxed                 { #panic("there is no such thing as a relaxed fence") }
+	else when order == .Release                 { intrinsics.atomic_fence_rel()                       }
+	else when order == .Acquire                 { intrinsics.atomic_fence_acq()                       }
+	else when order == .Acquire_Release         { intrinsics.atomic_fence_acqrel()                    }
+	else when order == .Sequentially_Consistent { intrinsics.atomic_fence()                           }
+	else { #panic("unknown order") }
 }
 
 
 atomic_store :: #force_inline proc(dst: ^$T, val: T, $order: Ordering) {
-	     when order == .Relaxed                 { intrinsics.atomic_store_relaxed(dst, val); }
-	else when order == .Release                 { intrinsics.atomic_store_rel(dst, val); }
-	else when order == .Sequentially_Consistent { intrinsics.atomic_store(dst, val); }
-	else when order == .Acquire                 { #panic("there is not such thing as an acquire store"); }
-	else when order == .Acquire_Release         { #panic("there is not such thing as an acquire/release store"); }
-	else { #panic("unknown order"); }
+	     when order == .Relaxed                 { intrinsics.atomic_store_relaxed(dst, val) }
+	else when order == .Release                 { intrinsics.atomic_store_rel(dst, val) }
+	else when order == .Sequentially_Consistent { intrinsics.atomic_store(dst, val) }
+	else when order == .Acquire                 { #panic("there is not such thing as an acquire store") }
+	else when order == .Acquire_Release         { #panic("there is not such thing as an acquire/release store") }
+	else { #panic("unknown order") }
 }
 
 atomic_load :: #force_inline proc(dst: ^$T, $order: Ordering) -> T {
-	     when order == .Relaxed                 { return intrinsics.atomic_load_relaxed(dst); }
-	else when order == .Acquire                 { return intrinsics.atomic_load_acq(dst); }
-	else when order == .Sequentially_Consistent { return intrinsics.atomic_load(dst); }
-	else when order == .Release                 { #panic("there is no such thing as a release load"); }
-	else when order == .Acquire_Release         { #panic("there is no such thing as an acquire/release load"); }
-	else { #panic("unknown order"); }
+	     when order == .Relaxed                 { return intrinsics.atomic_load_relaxed(dst) }
+	else when order == .Acquire                 { return intrinsics.atomic_load_acq(dst) }
+	else when order == .Sequentially_Consistent { return intrinsics.atomic_load(dst) }
+	else when order == .Release                 { #panic("there is no such thing as a release load") }
+	else when order == .Acquire_Release         { #panic("there is no such thing as an acquire/release load") }
+	else { #panic("unknown order") }
 }
 
 atomic_swap :: #force_inline proc(dst: ^$T, val: T, $order: Ordering) -> T {
-	     when order == .Relaxed                 { return intrinsics.atomic_xchg_relaxed(dst, val); }
-	else when order == .Release                 { return intrinsics.atomic_xchg_rel(dst, val);     }
-	else when order == .Acquire                 { return intrinsics.atomic_xchg_acq(dst, val);     }
-	else when order == .Acquire_Release         { return intrinsics.atomic_xchg_acqrel(dst, val);  }
-	else when order == .Sequentially_Consistent { return intrinsics.atomic_xchg(dst, val);         }
-	else { #panic("unknown order"); }
+	     when order == .Relaxed                 { return intrinsics.atomic_xchg_relaxed(dst, val) }
+	else when order == .Release                 { return intrinsics.atomic_xchg_rel(dst, val)     }
+	else when order == .Acquire                 { return intrinsics.atomic_xchg_acq(dst, val)     }
+	else when order == .Acquire_Release         { return intrinsics.atomic_xchg_acqrel(dst, val)  }
+	else when order == .Sequentially_Consistent { return intrinsics.atomic_xchg(dst, val)         }
+	else { #panic("unknown order") }
 }
 
 atomic_compare_exchange :: #force_inline proc(dst: ^$T, old, new: T, $success, $failure: Ordering) -> (val: T, ok: bool) {
 	when failure == .Relaxed {
-		     when success == .Relaxed                 { return intrinsics.atomic_cxchg_relaxed(dst, old, new); }
-		else when success == .Acquire                 { return intrinsics.atomic_cxchg_acq_failrelaxed(dst, old, new); }
-		else when success == .Acquire_Release         { return intrinsics.atomic_cxchg_acqrel_failrelaxed(dst, old, new); }
-		else when success == .Sequentially_Consistent { return intrinsics.atomic_cxchg_failrelaxed(dst, old, new); }
-		else when success == .Release                 { return intrinsics.atomic_cxchg_rel(dst, old, new); }
-		else { #panic("an unknown ordering combination"); }
+		     when success == .Relaxed                 { return intrinsics.atomic_cxchg_relaxed(dst, old, new) }
+		else when success == .Acquire                 { return intrinsics.atomic_cxchg_acq_failrelaxed(dst, old, new) }
+		else when success == .Acquire_Release         { return intrinsics.atomic_cxchg_acqrel_failrelaxed(dst, old, new) }
+		else when success == .Sequentially_Consistent { return intrinsics.atomic_cxchg_failrelaxed(dst, old, new) }
+		else when success == .Release                 { return intrinsics.atomic_cxchg_rel(dst, old, new) }
+		else { #panic("an unknown ordering combination") }
 	} else when failure == .Acquire {
-		     when success == .Release { return intrinsics.atomic_cxchg_acqrel(dst, old, new); }
-		else when success == .Acquire { return intrinsics.atomic_cxchg_acq(dst, old, new); }
-		else { #panic("an unknown ordering combination"); }
+		     when success == .Release { return intrinsics.atomic_cxchg_acqrel(dst, old, new) }
+		else when success == .Acquire { return intrinsics.atomic_cxchg_acq(dst, old, new) }
+		else { #panic("an unknown ordering combination") }
 	} else when failure == .Sequentially_Consistent {
-		when success == .Sequentially_Consistent { return intrinsics.atomic_cxchg(dst, old, new); }
-		else { #panic("an unknown ordering combination"); }
+		when success == .Sequentially_Consistent { return intrinsics.atomic_cxchg(dst, old, new) }
+		else { #panic("an unknown ordering combination") }
 	} else when failure == .Acquire_Release {
 		#panic("there is not such thing as an acquire/release failure ordering")
 	} else when failure == .Release {
-		when success == .Acquire { return instrinsics.atomic_cxchg_failacq(dst, old, new); }
-		else { #panic("an unknown ordering combination"); }
+		when success == .Acquire { return instrinsics.atomic_cxchg_failacq(dst, old, new) }
+		else { #panic("an unknown ordering combination") }
 	} else {
 		return T{}, false
 	}
@@ -87,24 +87,24 @@ atomic_compare_exchange :: #force_inline proc(dst: ^$T, old, new: T, $success, $
 
 atomic_compare_exchange_weak :: #force_inline proc(dst: ^$T, old, new: T, $success, $failure: Ordering) -> (val: T, ok: bool) {
 	when failure == .Relaxed {
-		     when success == .Relaxed                 { return intrinsics.atomic_cxchgweak_relaxed(dst, old, new); }
-		else when success == .Acquire                 { return intrinsics.atomic_cxchgweak_acq_failrelaxed(dst, old, new); }
-		else when success == .Acquire_Release         { return intrinsics.atomic_cxchgweak_acqrel_failrelaxed(dst, old, new); }
-		else when success == .Sequentially_Consistent { return intrinsics.atomic_cxchgweak_failrelaxed(dst, old, new); }
-		else when success == .Release                 { return intrinsics.atomic_cxchgweak_rel(dst, old, new); }
-		else { #panic("an unknown ordering combination"); }
+		     when success == .Relaxed                 { return intrinsics.atomic_cxchgweak_relaxed(dst, old, new) }
+		else when success == .Acquire                 { return intrinsics.atomic_cxchgweak_acq_failrelaxed(dst, old, new) }
+		else when success == .Acquire_Release         { return intrinsics.atomic_cxchgweak_acqrel_failrelaxed(dst, old, new) }
+		else when success == .Sequentially_Consistent { return intrinsics.atomic_cxchgweak_failrelaxed(dst, old, new) }
+		else when success == .Release                 { return intrinsics.atomic_cxchgweak_rel(dst, old, new) }
+		else { #panic("an unknown ordering combination") }
 	} else when failure == .Acquire {
-		     when success == .Release { return intrinsics.atomic_cxchgweak_acqrel(dst, old, new); }
-		else when success == .Acquire { return intrinsics.atomic_cxchgweak_acq(dst, old, new); }
-		else { #panic("an unknown ordering combination"); }
+		     when success == .Release { return intrinsics.atomic_cxchgweak_acqrel(dst, old, new) }
+		else when success == .Acquire { return intrinsics.atomic_cxchgweak_acq(dst, old, new) }
+		else { #panic("an unknown ordering combination") }
 	} else when failure == .Sequentially_Consistent {
-		when success == .Sequentially_Consistent { return intrinsics.atomic_cxchgweak(dst, old, new); }
-		else { #panic("an unknown ordering combination"); }
+		when success == .Sequentially_Consistent { return intrinsics.atomic_cxchgweak(dst, old, new) }
+		else { #panic("an unknown ordering combination") }
 	} else when failure == .Acquire_Release {
 		#panic("there is not such thing as an acquire/release failure ordering")
 	} else when failure == .Release {
-		when success == .Acquire { return intrinsics.atomic_cxchgweak_failacq(dst, old, new); }
-		else { #panic("an unknown ordering combination"); }
+		when success == .Acquire { return intrinsics.atomic_cxchgweak_failacq(dst, old, new) }
+		else { #panic("an unknown ordering combination") }
 	} else {
 		return T{}, false
 	}
@@ -113,56 +113,56 @@ atomic_compare_exchange_weak :: #force_inline proc(dst: ^$T, old, new: T, $succe
 
 
 atomic_add :: #force_inline proc(dst: ^$T, val: T, $order: Ordering) -> T {
-	     when order == .Relaxed                 { return intrinsics.atomic_add_relaxed(dst, val); }
-	else when order == .Release                 { return intrinsics.atomic_add_rel(dst, val); }
-	else when order == .Acquire                 { return intrinsics.atomic_add_acq(dst, val); }
-	else when order == .Acquire_Release         { return intrinsics.atomic_add_acqrel(dst, val); }
-	else when order == .Sequentially_Consistent { return intrinsics.atomic_add(dst, val); }
-	else { #panic("unknown order"); }
+	     when order == .Relaxed                 { return intrinsics.atomic_add_relaxed(dst, val) }
+	else when order == .Release                 { return intrinsics.atomic_add_rel(dst, val) }
+	else when order == .Acquire                 { return intrinsics.atomic_add_acq(dst, val) }
+	else when order == .Acquire_Release         { return intrinsics.atomic_add_acqrel(dst, val) }
+	else when order == .Sequentially_Consistent { return intrinsics.atomic_add(dst, val) }
+	else { #panic("unknown order") }
 }
 
 atomic_sub :: #force_inline proc(dst: ^$T, val: T, $order: Ordering) -> T {
-	     when order == .Relaxed                 { return intrinsics.atomic_sub_relaxed(dst, val); }
-	else when order == .Release                 { return intrinsics.atomic_sub_rel(dst, val); }
-	else when order == .Acquire                 { return intrinsics.atomic_sub_acq(dst, val); }
-	else when order == .Acquire_Release         { return intrinsics.atomic_sub_acqrel(dst, val); }
-	else when order == .Sequentially_Consistent { return intrinsics.atomic_sub(dst, val); }
-	else { #panic("unknown order"); }
+	     when order == .Relaxed                 { return intrinsics.atomic_sub_relaxed(dst, val) }
+	else when order == .Release                 { return intrinsics.atomic_sub_rel(dst, val) }
+	else when order == .Acquire                 { return intrinsics.atomic_sub_acq(dst, val) }
+	else when order == .Acquire_Release         { return intrinsics.atomic_sub_acqrel(dst, val) }
+	else when order == .Sequentially_Consistent { return intrinsics.atomic_sub(dst, val) }
+	else { #panic("unknown order") }
 }
 
 atomic_and :: #force_inline proc(dst: ^$T, val: T, $order: Ordering) -> T {
-	     when order == .Relaxed                 { return intrinsics.atomic_and_relaxed(dst, val); }
-	else when order == .Release                 { return intrinsics.atomic_and_rel(dst, val); }
-	else when order == .Acquire                 { return intrinsics.atomic_and_acq(dst, val); }
-	else when order == .Acquire_Release         { return intrinsics.atomic_and_acqrel(dst, val); }
-	else when order == .Sequentially_Consistent { return intrinsics.atomic_and(dst, val); }
-	else { #panic("unknown order"); }
+	     when order == .Relaxed                 { return intrinsics.atomic_and_relaxed(dst, val) }
+	else when order == .Release                 { return intrinsics.atomic_and_rel(dst, val) }
+	else when order == .Acquire                 { return intrinsics.atomic_and_acq(dst, val) }
+	else when order == .Acquire_Release         { return intrinsics.atomic_and_acqrel(dst, val) }
+	else when order == .Sequentially_Consistent { return intrinsics.atomic_and(dst, val) }
+	else { #panic("unknown order") }
 }
 
 atomic_nand :: #force_inline proc(dst: ^$T, val: T, $order: Ordering) -> T {
-	     when order == .Relaxed                 { return intrinsics.atomic_nand_relaxed(dst, val); }
-	else when order == .Release                 { return intrinsics.atomic_nand_rel(dst, val); }
-	else when order == .Acquire                 { return intrinsics.atomic_nand_acq(dst, val); }
-	else when order == .Acquire_Release         { return intrinsics.atomic_nand_acqrel(dst, val); }
-	else when order == .Sequentially_Consistent { return intrinsics.atomic_nand(dst, val); }
-	else { #panic("unknown order"); }
+	     when order == .Relaxed                 { return intrinsics.atomic_nand_relaxed(dst, val) }
+	else when order == .Release                 { return intrinsics.atomic_nand_rel(dst, val) }
+	else when order == .Acquire                 { return intrinsics.atomic_nand_acq(dst, val) }
+	else when order == .Acquire_Release         { return intrinsics.atomic_nand_acqrel(dst, val) }
+	else when order == .Sequentially_Consistent { return intrinsics.atomic_nand(dst, val) }
+	else { #panic("unknown order") }
 }
 
 atomic_or :: #force_inline proc(dst: ^$T, val: T, $order: Ordering) -> T {
-	     when order == .Relaxed                 { return intrinsics.atomic_or_relaxed(dst, val); }
-	else when order == .Release                 { return intrinsics.atomic_or_rel(dst, val); }
-	else when order == .Acquire                 { return intrinsics.atomic_or_acq(dst, val); }
-	else when order == .Acquire_Release         { return intrinsics.atomic_or_acqrel(dst, val); }
-	else when order == .Sequentially_Consistent { return intrinsics.atomic_or(dst, val); }
-	else { #panic("unknown order"); }
+	     when order == .Relaxed                 { return intrinsics.atomic_or_relaxed(dst, val) }
+	else when order == .Release                 { return intrinsics.atomic_or_rel(dst, val) }
+	else when order == .Acquire                 { return intrinsics.atomic_or_acq(dst, val) }
+	else when order == .Acquire_Release         { return intrinsics.atomic_or_acqrel(dst, val) }
+	else when order == .Sequentially_Consistent { return intrinsics.atomic_or(dst, val) }
+	else { #panic("unknown order") }
 }
 
 atomic_xor :: #force_inline proc(dst: ^$T, val: T, $order: Ordering) -> T {
-	     when order == .Relaxed                 { return intrinsics.atomic_xor_relaxed(dst, val); }
-	else when order == .Release                 { return intrinsics.atomic_xor_rel(dst, val); }
-	else when order == .Acquire                 { return intrinsics.atomic_xor_acq(dst, val); }
-	else when order == .Acquire_Release         { return intrinsics.atomic_xor_acqrel(dst, val); }
-	else when order == .Sequentially_Consistent { return intrinsics.atomic_xor(dst, val); }
-	else { #panic("unknown order"); }
+	     when order == .Relaxed                 { return intrinsics.atomic_xor_relaxed(dst, val) }
+	else when order == .Release                 { return intrinsics.atomic_xor_rel(dst, val) }
+	else when order == .Acquire                 { return intrinsics.atomic_xor_acq(dst, val) }
+	else when order == .Acquire_Release         { return intrinsics.atomic_xor_acqrel(dst, val) }
+	else when order == .Sequentially_Consistent { return intrinsics.atomic_xor(dst, val) }
+	else { #panic("unknown order") }
 }
 
diff --git a/core/sys/win32/general.odin b/core/sys/win32/general.odin
index 5131fa8d8..12e929b71 100644
--- a/core/sys/win32/general.odin
+++ b/core/sys/win32/general.odin
@@ -847,12 +847,12 @@ get_query_performance_frequency :: proc() -> i64 {
 	return r
 }
 
-HIWORD_W :: proc(wParam: Wparam) -> u16 { return u16((u32(wParam) >> 16) & 0xffff); }
-HIWORD_L :: proc(lParam: Lparam) -> u16 { return u16((u32(lParam) >> 16) & 0xffff); }
-LOWORD_W :: proc(wParam: Wparam) -> u16 { return u16(wParam); }
-LOWORD_L :: proc(lParam: Lparam) -> u16 { return u16(lParam); }
+HIWORD_W :: proc(wParam: Wparam) -> u16 { return u16((u32(wParam) >> 16) & 0xffff) }
+HIWORD_L :: proc(lParam: Lparam) -> u16 { return u16((u32(lParam) >> 16) & 0xffff) }
+LOWORD_W :: proc(wParam: Wparam) -> u16 { return u16(wParam) }
+LOWORD_L :: proc(lParam: Lparam) -> u16 { return u16(lParam) }
 
-is_key_down :: #force_inline proc(key: Key_Code) -> bool { return get_async_key_state(i32(key)) < 0; }
+is_key_down :: #force_inline proc(key: Key_Code) -> bool { return get_async_key_state(i32(key)) < 0 }
 
 
 
diff --git a/core/text/scanner/scanner.odin b/core/text/scanner/scanner.odin
index bd51b7bf5..72cdac76b 100644
--- a/core/text/scanner/scanner.odin
+++ b/core/text/scanner/scanner.odin
@@ -266,9 +266,9 @@ scan_identifier :: proc(s: ^Scanner) -> rune {
 	return ch
 }
 
-@(private) lower      :: proc(ch: rune) -> rune { return ('a' - 'A') | ch; }
-@(private) is_decimal :: proc(ch: rune) -> bool { return '0' <= ch && ch <= '9'; }
-@(private) is_hex     :: proc(ch: rune) -> bool { return '0' <= ch && ch <= '9' || 'a' <= lower(ch) && lower(ch) <= 'f'; }
+@(private) lower      :: proc(ch: rune) -> rune { return ('a' - 'A') | ch }
+@(private) is_decimal :: proc(ch: rune) -> bool { return '0' <= ch && ch <= '9' }
+@(private) is_hex     :: proc(ch: rune) -> bool { return '0' <= ch && ch <= '9' || 'a' <= lower(ch) && lower(ch) <= 'f' }
 
 
 
diff --git a/core/unicode/utf16/utf16.odin b/core/unicode/utf16/utf16.odin
index 27edf088d..380381f9a 100644
--- a/core/unicode/utf16/utf16.odin
+++ b/core/unicode/utf16/utf16.odin
@@ -35,19 +35,19 @@ encode :: proc(d: []u16, s: []rune) -> int {
 	loop: for r in s {
 		switch r {
 		case 0..<_surr1, _surr3 ..< _surr_self:
-			if m+1 < n { break loop; }
+			if m+1 < n { break loop }
 			d[n] = u16(r)
 			n += 1
 
 		case _surr_self ..= MAX_RUNE:
-			if m+2 < n { break loop; }
+			if m+2 < n { break loop }
 			r1, r2 := encode_surrogate_pair(r)
 			d[n]    = u16(r1)
 			d[n+1]  = u16(r2)
 			n += 2
 
 		case:
-			if m+1 < n { break loop; }
+			if m+1 < n { break loop }
 			d[n] = u16(REPLACEMENT_CHAR)
 			n += 1
 		}
@@ -61,19 +61,19 @@ encode_string :: proc(d: []u16, s: string) -> int {
 	loop: for r in s {
 		switch r {
 		case 0..<_surr1, _surr3 ..< _surr_self:
-			if m+1 < n { break loop; }
+			if m+1 < n { break loop }
 			d[n] = u16(r)
 			n += 1
 
 		case _surr_self ..= MAX_RUNE:
-			if m+2 < n { break loop; }
+			if m+2 < n { break loop }
 			r1, r2 := encode_surrogate_pair(r)
 			d[n]    = u16(r1)
 			d[n+1]  = u16(r2)
 			n += 2
 
 		case:
-			if m+1 < n { break loop; }
+			if m+1 < n { break loop }
 			d[n] = u16(REPLACEMENT_CHAR)
 			n += 1
 		}
diff --git a/vendor/OpenGL/wrappers.odin b/vendor/OpenGL/wrappers.odin
index ab02afeb5..e21bacc36 100644
--- a/vendor/OpenGL/wrappers.odin
+++ b/vendor/OpenGL/wrappers.odin
@@ -2,743 +2,743 @@ 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: u8)                                                                       {        impl_ColorMask(red, green, blue, alpha);                                                     }
-	DepthMask              :: #force_inline proc "c" (flag: u8)                                                                                          {        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               :: #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: u8)                                                                       {        impl_ColorMask(red, green, blue, alpha)                                                     }
+	DepthMask              :: #force_inline proc "c" (flag: u8)                                                                                          {        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)                                                          }
 
 	// 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        :: #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)                                                                  }
 
 	// 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 :: #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)                    }
 
 	// VERSION_1_3
-	ActiveTexture           :: #force_inline proc "c" (texture: u32)                                                                                                                                      { impl_ActiveTexture(texture);                                                                                           }
-	SampleCoverage          :: #force_inline proc "c" (value: f32, invert: u8)                                                                                                                            { 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           :: #force_inline proc "c" (texture: u32)                                                                                                                                      { impl_ActiveTexture(texture)                                                                                           }
+	SampleCoverage          :: #force_inline proc "c" (value: f32, invert: u8)                                                                                                                            { 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)                                                                        }
 
 	// 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 :: #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)                                                   }
 
 	// 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           :: #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)                 }
 
 	// 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: ^rawptr)                                                   {        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: rawptr)           {        impl_VertexAttribPointer(index, size, type, normalized, stride, pointer);             }
+	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: ^rawptr)                                                   {        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: rawptr)           {        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 :: #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) }
 
 
 	// VERSION_3_0
-	ColorMaski                          :: #force_inline proc "c" (index: u32, r: u8, g: u8, b: u8, a: u8)                                                                                 {        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: rawptr)                                                         {        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                          :: #force_inline proc "c" (index: u32, r: u8, g: u8, b: u8, a: u8)                                                                                 {        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: rawptr)                                                         {        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 }
 
 	// 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       :: #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)                                 }
 
 	// 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: u8)             {        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: u8) {        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          :: #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: u8)             {        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: u8) {        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)                                                                                  }
 
 	// 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 :: #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)                                          }
 
 	// 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               :: #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)                                                }
 
 	// 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: rawptr)               {        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     :: #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: rawptr)               {        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)                                                   }
 
 	// 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: u8, 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             :: #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: u8, 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)                                             }
 
 	// 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: u8)                                                                                                        {        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: u8)                                                                                            {        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: u8)                                                                                                                              {        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                 :: #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: u8)                                                                                                        {        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: u8)                                                                                            {        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: u8)                                                                                                                              {        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)                                                                                                              }
 
 	// 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     :: #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)                                            }
 
 	// 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: u8)                                                                 {        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: u8)                                                     {        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: u8, format: u32, type: u32, bufSize: i32, values: rawptr)                                                                                       {        impl_GetnHistogram(target, reset, format, type, bufSize, values);                                                                             }
-	GetnMinmax                               :: #force_inline proc "c" (target: u32, reset: u8, 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                              :: #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: u8)                                                                 {        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: u8)                                                     {        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: u8, format: u32, type: u32, bufSize: i32, values: rawptr)                                                                                       {        impl_GetnHistogram(target, reset, format, type, bufSize, values)                                                                             }
+	GetnMinmax                               :: #force_inline proc "c" (target: u32, reset: u8, 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)                                             }
 
 	// 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               :: #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)                                                          }
 } else {
 	import "core:runtime"
 	import "core:fmt"
@@ -803,740 +803,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: u8, loc := #caller_location)                                                                       {        impl_ColorMask(red, green, blue, alpha);                                                     debug_helper(loc, 0, red, green, blue, alpha);                                                                }
-	DepthMask              :: #force_inline proc "c" (flag: u8, 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               :: #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: u8, loc := #caller_location)                                                                       {        impl_ColorMask(red, green, blue, alpha);                                                     debug_helper(loc, 0, red, green, blue, alpha)                                                                }
+	DepthMask              :: #force_inline proc "c" (flag: u8, 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)                                                                    }
 
 	// 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        :: #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 }
 
 	// 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 :: #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)                        }
 
 	// 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: u8, 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           :: #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: u8, 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)                                                                      }
 
 	// 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 :: #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)                                               }
 
 	// 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           :: #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)                  }
 
 	// 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: ^rawptr, 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: rawptr, loc := #caller_location)          {        impl_VertexAttribPointer(index, size, type, normalized, stride, pointer); debug_helper(loc, 0, index, size, type, normalized, stride, pointer);                }
+	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: ^rawptr, 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: rawptr, 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 :: #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) }
 
 		// VERSION_3_0
-	ColorMaski                          :: #force_inline proc "c" (index: u32, r: u8, g: u8, b: u8, a: u8, 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: rawptr, 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                          :: #force_inline proc "c" (index: u32, r: u8, g: u8, b: u8, a: u8, 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: rawptr, 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 }
 
 	// 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       :: #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)            }
 
 	// 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: u8, 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: u8, 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          :: #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: u8, 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: u8, 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)                                                                        }
 
 	// 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 :: #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)                                  }
 
 	// 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               :: #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)                                   }
 
 	// 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: rawptr, 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     :: #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: rawptr, 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)                                        }
 
 	// 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: u8, 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             :: #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: u8, 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)                                      }
 
 	// 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: u8, 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: u8, 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: u8, 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                 :: #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: u8, 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: u8, 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: u8, 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)                                                                                                               }
 
 	// 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     :: #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)                                              }
 
 	// 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: u8, 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: u8, 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: u8, 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: u8, 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                              :: #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: u8, 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: u8, 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: u8, 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: u8, 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) }
 	
 	// 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               :: #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)                                                            }
 }