Merge branch 'odin-lang:master' into master

.gitignore

@@ -47,6 +47,8 @@ tests/core/test_linalg_glsl_math
 tests/core/test_noise
 tests/core/test_varint
 tests/core/test_xml
+tests/core/test_core_slice
+tests/core/test_core_thread
 tests/vendor/vendor_botan
 # Visual Studio 2015 cache/options directory
 .vs/
@@ -312,3 +314,6 @@ shared/
 examples/bug/
 build.sh
 !core/debug/
+
+# RAD debugger project file
+*.raddbg

core/builtin/builtin.odin

@@ -110,7 +110,7 @@ typeid_of    :: proc($T: typeid) -> typeid ---
 swizzle :: proc(x: [N]T, indices: ..int) -> [len(indices)]T ---
 
 complex    :: proc(real, imag: Float) -> Complex_Type ---
-quaternion :: proc(real, imag, jmag, kmag: Float) -> Quaternion_Type ---
+quaternion :: proc(imag, jmag, kmag, real: Float) -> Quaternion_Type --- // fields must be named
 real       :: proc(value: Complex_Or_Quaternion) -> Float ---
 imag       :: proc(value: Complex_Or_Quaternion) -> Float ---
 jmag       :: proc(value: Quaternion) -> Float ---

core/bytes/bytes.odin

@@ -895,7 +895,7 @@ split_multi_iterator :: proc(s: ^[]byte, substrs: [][]byte, skip_empty := false)
 
 
 
-// scrub scruvs invalid utf-8 characters and replaces them with the replacement string
+// Scrubs invalid utf-8 characters and replaces them with the replacement string
 // Adjacent invalid bytes are only replaced once
 scrub :: proc(s: []byte, replacement: []byte, allocator := context.allocator) -> []byte {
 	str := s

core/c/libc/stdio.odin

@@ -1,5 +1,7 @@
 package libc
 
+import "core:io"
+
 when ODIN_OS == .Windows {
 	foreign import libc {
 		"system:libucrt.lib",
@@ -218,3 +220,102 @@ foreign libc {
 	ferror    :: proc(stream: ^FILE) -> int ---
 	perror    :: proc(s: cstring) ---
 }
+
+to_stream :: proc(file: ^FILE) -> io.Stream {
+	stream_proc :: proc(stream_data: rawptr, mode: io.Stream_Mode, p: []byte, offset: i64, whence: io.Seek_From) -> (n: i64, err: io.Error) {
+		unknown_or_eof :: proc(f: ^FILE) -> io.Error {
+			switch {
+			case ferror(f) != 0:
+				return .Unknown
+			case feof(f) != 0:
+				return .EOF
+			case:
+				return nil
+			}
+		}
+
+		file := (^FILE)(stream_data)
+		switch mode {
+		case .Close:
+			if fclose(file) != 0 {
+				return 0, unknown_or_eof(file)
+			}
+
+		case .Flush:
+			if fflush(file) != 0 {
+				return 0, unknown_or_eof(file)
+			}
+
+		case .Read:
+			n = i64(fread(raw_data(p), size_of(byte), len(p), file))
+			if n == 0 { err = unknown_or_eof(file) }
+
+		case .Read_At:
+			curr := ftell(file)
+			if curr == -1 {
+				return 0, unknown_or_eof(file)
+			}
+
+			if fseek(file, long(offset), SEEK_SET) != 0 {
+				return 0, unknown_or_eof(file)
+			}
+
+			defer fseek(file, long(curr), SEEK_SET)
+
+			n = i64(fread(raw_data(p), size_of(byte), len(p), file))
+			if n == 0 { err = unknown_or_eof(file) }
+		
+		case .Write:
+			n = i64(fwrite(raw_data(p), size_of(byte), len(p), file))
+			if n == 0 { err = unknown_or_eof(file) }
+
+		case .Write_At:
+			curr := ftell(file)
+			if curr == -1 {
+				return 0, unknown_or_eof(file)
+			}
+
+			if fseek(file, long(offset), SEEK_SET) != 0 {
+				return 0, unknown_or_eof(file)
+			}
+
+			defer fseek(file, long(curr), SEEK_SET)
+
+			n = i64(fwrite(raw_data(p), size_of(byte), len(p), file))
+			if n == 0 { err = unknown_or_eof(file) }
+
+		case .Seek:
+			if fseek(file, long(offset), int(whence)) != 0 {
+				return 0, unknown_or_eof(file)
+			}
+		
+		case .Size:
+			curr := ftell(file)
+			if curr == -1 {
+				return 0, unknown_or_eof(file)
+			}
+			defer fseek(file, curr, SEEK_SET)
+
+			if fseek(file, 0, SEEK_END) != 0 {
+				return 0, unknown_or_eof(file)
+			}
+
+			n = i64(ftell(file))
+			if n == -1 {
+				return 0, unknown_or_eof(file)
+			}
+
+		case .Destroy:
+			return 0, .Empty
+		
+		case .Query:
+			return io.query_utility({ .Close, .Flush, .Read, .Read_At, .Write, .Write_At, .Seek, .Size })
+		}
+		return
+	}
+
+	return {
+		data      = file,
+		procedure = stream_proc,
+	}
+}

core/compress/common.odin

@@ -20,10 +20,9 @@ import "core:runtime"
 
 */
 
-/*
-	When a decompression routine doesn't stream its output, but writes to a buffer,
-	we pre-allocate an output buffer to speed up decompression. The default is 1 MiB.
-*/
+
+// When a decompression routine doesn't stream its output, but writes to a buffer,
+// we pre-allocate an output buffer to speed up decompression. The default is 1 MiB.
 COMPRESS_OUTPUT_ALLOCATE_MIN :: int(#config(COMPRESS_OUTPUT_ALLOCATE_MIN, 1 << 20))
 
 /*
@@ -34,16 +33,14 @@ COMPRESS_OUTPUT_ALLOCATE_MIN :: int(#config(COMPRESS_OUTPUT_ALLOCATE_MIN, 1 << 2
 
 */
 when size_of(uintptr) == 8 {
-	/*
-		For 64-bit platforms, we set the default max buffer size to 4 GiB,
-		which is GZIP and PKZIP's max payload size.
-	*/	
+
+        // For 64-bit platforms, we set the default max buffer size to 4 GiB,
+        // which is GZIP and PKZIP's max payload size.
 	COMPRESS_OUTPUT_ALLOCATE_MAX :: int(#config(COMPRESS_OUTPUT_ALLOCATE_MAX, 1 << 32))
 } else {
-	/*
-		For 32-bit platforms, we set the default max buffer size to 512 MiB.
-	*/
-	COMPRESS_OUTPUT_ALLOCATE_MAX :: int(#config(COMPRESS_OUTPUT_ALLOCATE_MAX, 1 << 29))
+	
+	// For 32-bit platforms, we set the default max buffer size to 512 MiB.
+        COMPRESS_OUTPUT_ALLOCATE_MAX :: int(#config(COMPRESS_OUTPUT_ALLOCATE_MAX, 1 << 29))
 }
 
 
@@ -69,9 +66,8 @@ General_Error :: enum {
 	Incompatible_Options,
 	Unimplemented,
 
-	/*
-		Memory errors
-	*/
+	// Memory errors
+
 	Allocation_Failed,
 	Resize_Failed,
 }
@@ -86,17 +82,16 @@ GZIP_Error :: enum {
 	Payload_Length_Invalid,
 	Payload_CRC_Invalid,
 
-	/*
-		GZIP's payload can be a maximum of max(u32le), or 4 GiB.
-		If you tell it you expect it to contain more, that's obviously an error.
-	*/
+	// GZIP's payload can be a maximum of max(u32le), or 4 GiB.
+	// If you tell it you expect it to contain more, that's obviously an error.
+
 	Payload_Size_Exceeds_Max_Payload,
-	/*
-		For buffered instead of streamed output, the payload size can't exceed
-		the max set by the `COMPRESS_OUTPUT_ALLOCATE_MAX` switch in compress/common.odin.
 
-		You can tweak this setting using `-define:COMPRESS_OUTPUT_ALLOCATE_MAX=size_in_bytes`
-	*/
+	// For buffered instead of streamed output, the payload size can't exceed
+	// the max set by the `COMPRESS_OUTPUT_ALLOCATE_MAX` switch in compress/common.odin.
+	//
+	// You can tweak this setting using `-define:COMPRESS_OUTPUT_ALLOCATE_MAX=size_in_bytes`
+
 	Output_Exceeds_COMPRESS_OUTPUT_ALLOCATE_MAX,
 
 }
@@ -137,9 +132,8 @@ Context_Memory_Input :: struct #packed {
 	code_buffer:       u64,
 	num_bits:          u64,
 
-	/*
-		If we know the data size, we can optimize the reads and writes.
-	*/
+	// If we know the data size, we can optimize the reads and writes.
+
 	size_packed:       i64,
 	size_unpacked:     i64,
 }
@@ -159,18 +153,16 @@ Context_Stream_Input :: struct #packed {
 	code_buffer:       u64,
 	num_bits:          u64,
 
-	/*
-		If we know the data size, we can optimize the reads and writes.
-	*/
+	// If we know the data size, we can optimize the reads and writes.
+
 	size_packed:       i64,
 	size_unpacked:     i64,
 
-	/*
-		Flags:
-			`input_fully_in_memory`
-				true  = This tells us we read input from `input_data` exclusively. [] = EOF.
-				false = Try to refill `input_data` from the `input` stream.
-	*/
+	// Flags:
+	// `input_fully_in_memory`
+	//   true  = This tells us we read input from `input_data` exclusively. [] = EOF.
+	//   false = Try to refill `input_data` from the `input` stream.
+
 	input_fully_in_memory: b8,
 
 	padding: [1]u8,
@@ -214,7 +206,7 @@ read_slice_from_memory :: #force_inline proc(z: ^Context_Memory_Input, size: int
 @(optimization_mode="speed")
 read_slice_from_stream :: #force_inline proc(z: ^Context_Stream_Input, size: int) -> (res: []u8, err: io.Error) {
 	// TODO: REMOVE ALL USE OF context.temp_allocator here
-	// the is literally no need for it
+	// there is literally no need for it
 	b := make([]u8, size, context.temp_allocator)
 	_ = io.read(z.input, b[:]) or_return
 	return b, nil
@@ -248,10 +240,8 @@ read_u8_from_stream :: #force_inline proc(z: ^Context_Stream_Input) -> (res: u8,
 
 read_u8 :: proc{read_u8_from_memory, read_u8_from_stream}
 
-/*
-	You would typically only use this at the end of Inflate, to drain bits from the code buffer
-	preferentially.
-*/
+// You would typically only use this at the end of Inflate, to drain bits from the code buffer
+// preferentially.
 @(optimization_mode="speed")
 read_u8_prefer_code_buffer_lsb :: #force_inline proc(z: ^$C) -> (res: u8, err: io.Error) {
 	if z.num_bits >= 8 {

core/container/priority_queue/priority_queue.odin

@@ -140,3 +140,18 @@ remove :: proc(pq: ^$Q/Priority_Queue($T), i: int) -> (value: T, ok: bool) {
 	return
 }
 
+peek_safe :: proc(pq: $Q/Priority_Queue($T), loc := #caller_location) -> (res: T, ok: bool) {
+	if builtin.len(pq.queue) > 0 {
+		return pq.queue[0], true
+	}
+	return
+}
+
+peek :: proc(pq: $Q/Priority_Queue($T), loc := #caller_location) -> (res: T) {
+	assert(condition=builtin.len(pq.queue)>0, loc=loc)
+
+	if builtin.len(pq.queue) > 0 {
+		return pq.queue[0]
+	}
+	return
+}

core/dynlib/doc.odin

@@ -1,7 +1,11 @@
+//+build ignore
 /*
 Package core:dynlib implements loading of shared libraries/DLLs and their symbols.
 
 The behaviour of dynamically loaded libraries is specific to the target platform of the program.
 For in depth detail on the underlying behaviour please refer to your target platform's documentation.
+
+See `example` directory for an example library exporting 3 symbols and a host program loading them automatically
+by defining a symbol table struct.
 */
-package dynlib
+package dynlib

core/dynlib/example/example.odin

@@ -0,0 +1,45 @@
+package example
+
+import "core:dynlib"
+import "core:fmt"
+
+Symbols :: struct {
+	// `foo_` is prefixed, so we look for the symbol `foo_add`.
+	add: proc "c" (int, int) -> int,
+	// We use the tag here to override the symbol to look for, namely `bar_sub`.
+	sub: proc "c" (int, int) -> int `dynlib:"bar_sub"`,
+
+	// Exported global (if exporting an i32, the type must be ^i32 because the symbol is a pointer to the export.)
+	// If it's not a pointer or procedure type, we'll skip the struct field.
+	hellope: ^i32,
+
+	// Handle to free library.
+	// We can have more than one of these so we can match symbols for more than one DLL with one struct.
+	_my_lib_handle: dynlib.Library,
+}
+
+main :: proc() {
+	sym: Symbols
+
+	// Load symbols from `lib.dll` into Symbols struct.
+	// Each struct field is prefixed with `foo_` before lookup in the DLL's symbol table.
+	// The library's Handle (to unload) will be stored in `sym._my_lib_handle`. This way you can load multiple DLLs in one struct.
+	count, ok := dynlib.initialize_symbols(&sym, "lib.dll", "foo_", "_my_lib_handle")
+	defer dynlib.unload_library(sym._my_lib_handle)
+	fmt.printf("(Initial DLL Load) ok: %v. %v symbols loaded from lib.dll (%p).\n", ok, count, sym._my_lib_handle)
+
+	if count > 0 {
+		fmt.println("42 + 42 =", sym.add(42, 42))
+		fmt.println("84 - 13 =", sym.sub(84, 13))
+		fmt.println("hellope =", sym.hellope^)
+	}
+
+	count, ok = dynlib.initialize_symbols(&sym, "lib.dll", "foo_", "_my_lib_handle")
+	fmt.printf("(DLL Reload) ok: %v. %v symbols loaded from lib.dll (%p).\n", ok, count, sym._my_lib_handle)
+
+	if count > 0 {
+		fmt.println("42 + 42 =", sym.add(42, 42))
+		fmt.println("84 - 13 =", sym.sub(84, 13))
+		fmt.println("hellope =", sym.hellope^)
+	}
+}

core/dynlib/example/lib.odin

@@ -0,0 +1,14 @@
+package library
+
+@(export)
+foo_add :: proc "c" (a, b: int) -> (res: int) {
+	return a + b
+}
+
+@(export)
+bar_sub :: proc "c" (a, b: int) -> (res: int) {
+	return a - b
+}
+
+@(export)
+foo_hellope: i32 = 42

core/dynlib/lib.odin

@@ -1,5 +1,12 @@
 package dynlib
 
+import "core:intrinsics"
+import "core:reflect"
+import "core:runtime"
+_ :: intrinsics
+_ :: reflect
+_ :: runtime
+
 /*
 A handle to a dynamically loaded library.
 */
@@ -12,11 +19,11 @@ library available to resolve references in subsequently loaded libraries.
 The paramater `global_symbols` is only used for the platforms `linux`, `darwin`, `freebsd` and `openbsd`.
 On `windows` this paramater is ignored.
 
-The underlying behaviour is platform specific.  
-On `linux`, `darwin`, `freebsd` and `openbsd` refer to `dlopen`.  
+The underlying behaviour is platform specific.
+On `linux`, `darwin`, `freebsd` and `openbsd` refer to `dlopen`.
 On `windows` refer to `LoadLibraryW`.
 
-**Implicit Allocators**  
+**Implicit Allocators**
 `context.temp_allocator`
 
 Example:
@@ -27,6 +34,7 @@ Example:
 		LIBRARY_PATH :: "my_library.dll"
 		library, ok := dynlib.load_library(LIBRARY_PATH)
 		if ! ok {
+			fmt.eprintln(dynlib.last_error())
 			return
 		}
 		fmt.println("The library %q was successfully loaded", LIBRARY_PATH)
@@ -39,8 +47,8 @@ load_library :: proc(path: string, global_symbols := false) -> (library: Library
 /*
 Unloads a dynamic library.
 
-The underlying behaviour is platform specific.  
-On `linux`, `darwin`, `freebsd` and `openbsd` refer to `dlclose`.  
+The underlying behaviour is platform specific.
+On `linux`, `darwin`, `freebsd` and `openbsd` refer to `dlclose`.
 On `windows` refer to `FreeLibrary`.
 
 Example:
@@ -51,10 +59,12 @@ Example:
 		LIBRARY_PATH :: "my_library.dll"
 		library, ok := dynlib.load_library(LIBRARY_PATH)
 		if ! ok {
+			fmt.eprintln(dynlib.last_error())
 			return
 		}
 		did_unload := dynlib.unload_library(library)
 		if ! did_unload {
+			fmt.eprintln(dynlib.last_error())
 			return
 		}
 		fmt.println("The library %q was successfully unloaded", LIBRARY_PATH)
@@ -67,11 +77,11 @@ unload_library :: proc(library: Library) -> (did_unload: bool) {
 /*
 Loads the address of a procedure/variable from a dynamic library.
 
-The underlying behaviour is platform specific.  
-On `linux`, `darwin`, `freebsd` and `openbsd` refer to `dlsym`.  
+The underlying behaviour is platform specific.
+On `linux`, `darwin`, `freebsd` and `openbsd` refer to `dlsym`.
 On `windows` refer to `GetProcAddress`.
 
-**Implicit Allocators**  
+**Implicit Allocators**
 `context.temp_allocator`
 
 Example:
@@ -82,13 +92,101 @@ Example:
 		LIBRARY_PATH :: "my_library.dll"
 		library, ok := dynlib.load_library(LIBRARY_PATH)
 		if ! ok {
+			fmt.eprintln(dynlib.last_error())
 			return
 		}
 
 		a, found_a := dynlib.symbol_address(library, "a")
-		if found_a do fmt.printf("The symbol %q was found at the address %v", "a", a)
+		if found_a {
+			fmt.printf("The symbol %q was found at the address %v", "a", a)
+		} else {
+			fmt.eprintln(dynlib.last_error())
+		}
 	}
 */
 symbol_address :: proc(library: Library, symbol: string) -> (ptr: rawptr, found: bool) #optional_ok {
 	return _symbol_address(library, symbol)
 }
+
+/*
+Scans a dynamic library for symbols matching a struct's members, assigning found procedure pointers to the corresponding entry.
+Optionally takes a symbol prefix added to the struct's member name to construct the symbol looked up in the library.
+Optionally also takes the struct member to assign the library handle to, `__handle` by default.
+
+This allows using one struct to hold library handles and symbol pointers for more than 1 dynamic library.
+
+Loading the same library twice unloads the previous incarnation, allowing for straightforward hot reload support.
+
+Returns:
+* `-1, false` if the library could not be loaded.
+* The number of symbols assigned on success. `ok` = true if `count` > 0
+
+See doc.odin for an example.
+*/
+initialize_symbols :: proc(symbol_table: ^$T, library_path: string, symbol_prefix := "", handle_field_name := "__handle") -> (count: int, ok: bool) where intrinsics.type_is_struct(T) {
+	assert(symbol_table != nil)
+	handle: Library
+
+	if handle, ok = load_library(library_path); !ok {
+		return -1, false
+	}
+
+	// `symbol_table` must be a struct because of the where clause, so this can't fail.
+	ti := runtime.type_info_base(type_info_of(T))
+	s, _ := ti.variant.(runtime.Type_Info_Struct)
+
+	// Buffer to concatenate the prefix + symbol name.
+	prefixed_symbol_buf: [2048]u8 = ---
+
+	sym_ptr: rawptr
+	for field_name, i in s.names {
+		// Calculate address of struct member
+		field_ptr := rawptr(uintptr(rawptr(symbol_table)) + uintptr(s.offsets[i]))
+
+		// If we've come across the struct member for the handle, store it and continue scanning for other symbols.
+		if field_name == handle_field_name {
+			// We appear to be hot reloading. Unload previous incarnation of the library.
+			if old_handle := (^Library)(field_ptr)^; old_handle != nil {
+				if ok = unload_library(old_handle); !ok {
+					return count, ok
+				}
+			}
+			(^Library)(field_ptr)^ = handle
+			continue
+		}
+
+		// We're not the library handle, so the field needs to be a pointer type, be it a procedure pointer or an exported global.
+		if !(reflect.is_procedure(s.types[i]) || reflect.is_pointer(s.types[i])) {
+			continue
+		}
+
+		// Let's look up or construct the symbol name to find in the library
+		prefixed_name: string
+
+		// Do we have a symbol override tag?
+		if override, tag_ok := reflect.struct_tag_lookup(reflect.Struct_Tag(s.tags[i]), "dynlib"); tag_ok {
+			prefixed_name = string(override)
+		}
+
+		// No valid symbol override tag found, fall back to `<symbol_prefix>name`.
+		if len(prefixed_name) == 0 {
+			offset := copy(prefixed_symbol_buf[:], symbol_prefix)
+			copy(prefixed_symbol_buf[offset:], field_name)
+			prefixed_name = string(prefixed_symbol_buf[:len(symbol_prefix) + len(field_name)])
+		}
+
+		// Assign procedure (or global) pointer if found.
+		if sym_ptr, ok = symbol_address(handle, prefixed_name); ok {
+			(^rawptr)(field_ptr)^ = sym_ptr
+			count += 1
+		}
+	}
+	return count, count > 0
+}
+
+/*
+Returns an error message for the last failed procedure call.
+*/
+last_error :: proc() -> string {
+	return _last_error()
+}

core/dynlib/lib_js.odin

@@ -13,3 +13,7 @@ _unload_library :: proc(library: Library) -> bool {
 _symbol_address :: proc(library: Library, symbol: string) -> (ptr: rawptr, found: bool) {
 	return nil, false
 }
+
+_last_error :: proc() -> string {
+	return ""
+}

core/dynlib/lib_unix.odin

@@ -22,3 +22,8 @@ _symbol_address :: proc(library: Library, symbol: string) -> (ptr: rawptr, found
 	found = ptr != nil
 	return
 }
+
+_last_error :: proc() -> string {
+	err := os.dlerror()
+	return "unknown" if err == "" else err
+}

core/dynlib/lib_windows.odin

@@ -5,6 +5,7 @@ package dynlib
 import win32 "core:sys/windows"
 import "core:strings"
 import "core:runtime"
+import "core:reflect"
 
 _load_library :: proc(path: string, global_symbols := false) -> (Library, bool) {
 	// NOTE(bill): 'global_symbols' is here only for consistency with POSIX which has RTLD_GLOBAL
@@ -27,3 +28,9 @@ _symbol_address :: proc(library: Library, symbol: string) -> (ptr: rawptr, found
 	found = ptr != nil
 	return
 }
+
+_last_error :: proc() -> string {
+	err := win32.System_Error(win32.GetLastError())
+	err_msg := reflect.enum_string(err)
+	return "unknown" if err_msg == "" else err_msg
+}

core/encoding/json/marshal.odin

@@ -7,6 +7,7 @@ import "core:strconv"
 import "core:strings"
 import "core:reflect"
 import "core:io"
+import "core:slice"
 
 Marshal_Data_Error :: enum {
 	None,
@@ -18,29 +19,40 @@ Marshal_Error :: union #shared_nil {
 	io.Error,
 }
 
-// careful with MJSON maps & non quotes usage as keys without whitespace will lead to bad results
+// careful with MJSON maps & non quotes usage as keys with whitespace will lead to bad results
 Marshal_Options :: struct {
 	// output based on spec
 	spec: Specification,
 
-	// use line breaks & tab|spaces
+	// Use line breaks & tabs/spaces
 	pretty: bool, 
 
-	// spacing
+	// Use spaces for indentation instead of tabs
 	use_spaces: bool,
-	spaces: int,
 
-	// state
-	indentation: int,
+	// Given use_spaces true, use this many spaces per indent level. 0 means 4 spaces.
+	spaces: int,
 
-	// option to output uint in JSON5 & MJSON
+	// Output uint as hex in JSON5 & MJSON
 	write_uint_as_hex: bool, 
 
-	// mjson output options
+	// If spec is MJSON and this is true, then keys will be quoted.
+	//
+	// WARNING: If your keys contain whitespace and this is false, then the
+	// output will be bad.
 	mjson_keys_use_quotes: bool,
+
+	// If spec is MJSON and this is true, then use '=' as delimiter between
+	// keys and values, otherwise ':' is used.
 	mjson_keys_use_equal_sign: bool,
 
-	// mjson state
+	// When outputting a map, sort the output by key.
+	//
+	// NOTE: This will temp allocate and sort a list for each map.
+	sort_maps_by_key: bool,
+
+	// Internal state
+	indentation: int,
 	mjson_skipped_first_braces_start: bool,
 	mjson_skipped_first_braces_end: bool,
 }
@@ -50,6 +62,9 @@ marshal :: proc(v: any, opt: Marshal_Options = {}, allocator := context.allocato
 	defer if err != nil {
 		strings.builder_destroy(&b)
 	}
+	
+	// temp guard in case we are sorting map keys, which will use temp allocations
+	runtime.DEFAULT_TEMP_ALLOCATOR_TEMP_GUARD(ignore = allocator == context.temp_allocator)
 
 	opt := opt
 	marshal_to_builder(&b, v, &opt) or_return
@@ -263,36 +278,81 @@ marshal_to_writer :: proc(w: io.Writer, v: any, opt: ^Marshal_Options) -> (err:
 			map_cap := uintptr(runtime.map_cap(m^))
 			ks, vs, hs, _, _ := runtime.map_kvh_data_dynamic(m^, info.map_info)
 
-			i := 0
-			for bucket_index in 0..<map_cap {
-				runtime.map_hash_is_valid(hs[bucket_index]) or_continue
+			if !opt.sort_maps_by_key {
+				i := 0
+				for bucket_index in 0..<map_cap {
+					runtime.map_hash_is_valid(hs[bucket_index]) or_continue
+
+					opt_write_iteration(w, opt, i) or_return
+					i += 1
+
+					key   := rawptr(runtime.map_cell_index_dynamic(ks, info.map_info.ks, bucket_index))
+					value := rawptr(runtime.map_cell_index_dynamic(vs, info.map_info.vs, bucket_index))
+
+					// check for string type
+					{
+						v := any{key, info.key.id}
+						ti := runtime.type_info_base(type_info_of(v.id))
+						a := any{v.data, ti.id}
+						name: string
+
+						#partial switch info in ti.variant {
+						case runtime.Type_Info_String:
+							switch s in a {
+							case string: name = s
+							case cstring: name = string(s)
+							}
+							opt_write_key(w, opt, name) or_return
+
+						case: return .Unsupported_Type
+						}
+					}
 
-				opt_write_iteration(w, opt, i) or_return
-				i += 1
+					marshal_to_writer(w, any{value, info.value.id}, opt) or_return
+				}
+			} else {
+				Entry :: struct {
+					key: string,
+					value: any,
+				}
 
-				key   := rawptr(runtime.map_cell_index_dynamic(ks, info.map_info.ks, bucket_index))
-				value := rawptr(runtime.map_cell_index_dynamic(vs, info.map_info.vs, bucket_index))
+				// If we are sorting the map by key, then we temp alloc an array
+				// and sort it, then output the result.
+				sorted := make([dynamic]Entry, 0, map_cap, context.temp_allocator)
+				for bucket_index in 0..<map_cap {
+					runtime.map_hash_is_valid(hs[bucket_index]) or_continue
 
-				// check for string type
-				{
-					v := any{key, info.key.id}
-					ti := runtime.type_info_base(type_info_of(v.id))
-					a := any{v.data, ti.id}
+					key   := rawptr(runtime.map_cell_index_dynamic(ks, info.map_info.ks, bucket_index))
+					value := rawptr(runtime.map_cell_index_dynamic(vs, info.map_info.vs, bucket_index))
 					name: string
 
-					#partial switch info in ti.variant {
-					case runtime.Type_Info_String:
-						switch s in a {
-						case string: name = s
-						case cstring: name = string(s)
-						}
-						opt_write_key(w, opt, name) or_return
+					// check for string type
+					{
+						v := any{key, info.key.id}
+						ti := runtime.type_info_base(type_info_of(v.id))
+						a := any{v.data, ti.id}
 
-					case: return .Unsupported_Type
+						#partial switch info in ti.variant {
+						case runtime.Type_Info_String:
+							switch s in a {
+							case string: name = s
+							case cstring: name = string(s)
+							}
+
+						case: return .Unsupported_Type
+						}
 					}
+
+					append(&sorted, Entry { key = name, value = any{value, info.value.id}})
 				}
 
-				marshal_to_writer(w, any{value, info.value.id}, opt) or_return
+				slice.sort_by(sorted[:], proc(i, j: Entry) -> bool { return i.key < j.key })
+
+				for s, i in sorted {
+					opt_write_iteration(w, opt, i) or_return
+					opt_write_key(w, opt, s.key) or_return
+					marshal_to_writer(w, s.value, opt) or_return
+				}
 			}
 		}
 
@@ -424,8 +484,9 @@ opt_write_key :: proc(w: io.Writer, opt: ^Marshal_Options, name: string) -> (err
 
 // insert start byte and increase indentation on pretty
 opt_write_start :: proc(w: io.Writer, opt: ^Marshal_Options, c: byte) -> (err: io.Error)  {
-	// skip mjson starting braces
-	if opt.spec == .MJSON && !opt.mjson_skipped_first_braces_start {
+	// Skip MJSON starting braces. We make sure to only do this for c == '{',
+	// skipping a starting '[' is not allowed.
+	if opt.spec == .MJSON && !opt.mjson_skipped_first_braces_start && opt.indentation == 0 && c == '{' {
 		opt.mjson_skipped_first_braces_start = true
 		return
 	}
@@ -473,11 +534,9 @@ opt_write_iteration :: proc(w: io.Writer, opt: ^Marshal_Options, iteration: int)
 
 // decrease indent, write spacing and insert end byte
 opt_write_end :: proc(w: io.Writer, opt: ^Marshal_Options, c: byte) -> (err: io.Error)  {
-	if opt.spec == .MJSON && opt.mjson_skipped_first_braces_start && !opt.mjson_skipped_first_braces_end {
-		if opt.indentation == 0 {
-			opt.mjson_skipped_first_braces_end = true
-			return
-		}
+	if opt.spec == .MJSON && opt.mjson_skipped_first_braces_start && !opt.mjson_skipped_first_braces_end && opt.indentation == 0 && c == '}' {
+		opt.mjson_skipped_first_braces_end = true
+		return
 	}
 
 	opt.indentation -= 1

core/encoding/json/types.odin

@@ -1,5 +1,7 @@
 package json
 
+import "core:strings"
+
 /*
 	JSON 
 		strict JSON
@@ -104,4 +106,27 @@ destroy_value :: proc(value: Value, allocator := context.allocator) {
 	case String:
 		delete(v)
 	}
+}
+
+clone_value :: proc(value: Value, allocator := context.allocator) -> Value {
+	context.allocator = allocator
+
+	#partial switch &v in value {
+	case Object:
+		new_o := make(Object, len(v))
+		for key, elem in v {
+			new_o[strings.clone(key)] = clone_value(elem)
+		}
+		return new_o
+	case Array:
+		new_a := make(Array, len(v))
+		for elem, idx in v {
+			new_a[idx] = clone_value(elem)
+		}
+		return new_a
+	case String:
+		return strings.clone(v)
+	}
+
+	return value
 }

core/encoding/json/unmarshal.odin

@@ -137,9 +137,9 @@ assign_float :: proc(val: any, f: $T) -> bool {
 	case complex64:  dst = complex(f32(f), 0)
 	case complex128: dst = complex(f64(f), 0)
 	
-	case quaternion64:  dst = quaternion(f16(f), 0, 0, 0)
-	case quaternion128: dst = quaternion(f32(f), 0, 0, 0)
-	case quaternion256: dst = quaternion(f64(f), 0, 0, 0)
+	case quaternion64:  dst = quaternion(w=f16(f), x=0, y=0, z=0)
+	case quaternion128: dst = quaternion(w=f32(f), x=0, y=0, z=0)
+	case quaternion256: dst = quaternion(w=f64(f), x=0, y=0, z=0)
 	
 	case: return false
 	}

core/encoding/xml/debug_print.odin

@@ -1,3 +1,5 @@
+package xml
+
 /*
 	An XML 1.0 / 1.1 parser
 
@@ -9,7 +11,7 @@
 	List of contributors:
 		Jeroen van Rijn: Initial implementation.
 */
-package xml
+
 
 import "core:io"
 import "core:fmt"
@@ -81,4 +83,4 @@ print_element :: proc(writer: io.Writer, doc: ^Document, element_id: Element_ID,
 	}
 
 	return written, .None
-}
+}

core/encoding/xml/example/xml_example.odin

@@ -20,7 +20,7 @@ example :: proc() {
 		xml.destroy(docs[round])
 	}
 
-	DOC :: #load("../../../../tests/core/assets/XML/unicode.xml")
+	DOC :: #load("../../../../tests/core/assets/XML/utf8.xml")
 	input := DOC
 
 	for round in 0..<N {
@@ -109,4 +109,4 @@ main :: proc() {
 		}
 	}
 	println("Done and cleaned up!")
-}
+}

core/encoding/xml/helpers.odin

@@ -1,3 +1,5 @@
+package xml
+
 /*
 	An XML 1.0 / 1.1 parser
 
@@ -6,7 +8,7 @@
 
 	This file contains helper functions.
 */
-package xml
+
 
 // Find parent's nth child with a given ident.
 find_child_by_ident :: proc(doc: ^Document, parent_id: Element_ID, ident: string, nth := 0) -> (res: Element_ID, found: bool) {
@@ -47,4 +49,4 @@ find_attribute_val_by_key :: proc(doc: ^Document, parent_id: Element_ID, key: st
 		if attr.key == key { return attr.val, true }
 	}
 	return "", false
-}
+}

core/encoding/xml/tokenizer.odin

@@ -1,3 +1,5 @@
+package xml
+
 /*
 	An XML 1.0 / 1.1 parser
 
@@ -9,7 +11,7 @@
 	List of contributors:
 		Jeroen van Rijn: Initial implementation.
 */
-package xml
+
 
 import "core:fmt"
 import "core:unicode"
@@ -433,4 +435,4 @@ scan :: proc(t: ^Tokenizer) -> Token {
 		lit = string(t.src[offset : t.offset])
 	}
 	return Token{kind, lit, pos}
-}
+}

core/encoding/xml/xml_reader.odin

@@ -1,28 +1,28 @@
 /*
-	An XML 1.0 / 1.1 parser
+ XML 1.0 / 1.1 parser
 
-	Copyright 2021-2022 Jeroen van Rijn <[email protected]>.
-	Made available under Odin's BSD-3 license.
+ 2021-2022 Jeroen van Rijn <[email protected]>.
+ available under Odin's BSD-3 license.
 
-	A from-scratch XML implementation, loosely modelled on the [spec](https://www.w3.org/TR/2006/REC-xml11-20060816).
+ from-scratch XML implementation, loosely modelled on the [spec](https://www.w3.org/TR/2006/REC-xml11-20060816).
 
-	Features:
-		- Supports enough of the XML 1.0/1.1 spec to handle the 99.9% of XML documents in common current usage.
-		- Simple to understand and use. Small.
+Features:
+- Supports enough of the XML 1.0/1.1 spec to handle the 99.9% of XML documents in common current usage.
+- Simple to understand and use. Small.
 
-	Caveats:
-		- We do NOT support HTML in this package, as that may or may not be valid XML.
-		  If it works, great. If it doesn't, that's not considered a bug.
+Caveats:
+- We do NOT support HTML in this package, as that may or may not be valid XML.
+  If it works, great. If it doesn't, that's not considered a bug.
 
-		- We do NOT support UTF-16. If you have a UTF-16 XML file, please convert it to UTF-8 first. Also, our condolences.
-		- <[!ELEMENT and <[!ATTLIST are not supported, and will be either ignored or return an error depending on the parser options.
+- We do NOT support UTF-16. If you have a UTF-16 XML file, please convert it to UTF-8 first. Also, our condolences.
+- <[!ELEMENT and <[!ATTLIST are not supported, and will be either ignored or return an error depending on the parser options.
 
-	MAYBE:
-	- XML writer?
-	- Serialize/deserialize Odin types?
+MAYBE:
+- XML writer?
+- Serialize/deserialize Odin types?
 
-	List of contributors:
-		Jeroen van Rijn: Initial implementation.
+List of contributors:
+- Jeroen van Rijn: Initial implementation.
 */
 package xml
 // An XML 1.0 / 1.1 parser
@@ -43,48 +43,32 @@ DEFAULT_OPTIONS :: Options{
 }
 
 Option_Flag :: enum {
-	/*
-		If the caller says that input may be modified, we can perform in-situ parsing.
-		If this flag isn't provided, the XML parser first duplicates the input so that it can.
-	*/
+	// If the caller says that input may be modified, we can perform in-situ parsing.
+	// If this flag isn't provided, the XML parser first duplicates the input so that it can.
 	Input_May_Be_Modified,
 
-	/*
-		Document MUST start with `<?xml` prologue.
-	*/
+	// Document MUST start with `<?xml` prologue.
 	Must_Have_Prolog,
 
-	/*
-		Document MUST have a `<!DOCTYPE`.
-	*/
+	// Document MUST have a `<!DOCTYPE`.
 	Must_Have_DocType,
 
-	/*
-		By default we skip comments. Use this option to intern a comment on a parented Element.
-	*/
+	// By default we skip comments. Use this option to intern a comment on a parented Element.
 	Intern_Comments,
 
-	/*
-		How to handle unsupported parts of the specification, like <! other than <!DOCTYPE and <![CDATA[
-	*/
+	// How to handle unsupported parts of the specification, like <! other than <!DOCTYPE and <![CDATA[
 	Error_on_Unsupported,
 	Ignore_Unsupported,
 
-	/*
-		By default CDATA tags are passed-through as-is.
-		This option unwraps them when encountered.
-	*/
+	// By default CDATA tags are passed-through as-is.
+	// This option unwraps them when encountered.
 	Unbox_CDATA,
 
-	/*
-		By default SGML entities like `&gt;`, `&#32;` and `&#x20;` are passed-through as-is.
-		This option decodes them when encountered.
-	*/
+	// By default SGML entities like `&gt;`, `&#32;` and `&#x20;` are passed-through as-is.
+	// This option decodes them when encountered.
 	Decode_SGML_Entities,
 
-	/*
-		If a tag body has a comment, it will be stripped unless this option is given.
-	*/
+	// If a tag body has a comment, it will be stripped unless this option is given.
 	Keep_Tag_Body_Comments,
 }
 Option_Flags :: bit_set[Option_Flag; u16]
@@ -97,28 +81,20 @@ Document :: struct {
 	encoding: Encoding,
 
 	doctype: struct {
-		/*
-			We only scan the <!DOCTYPE IDENT part and skip the rest.
-		*/
+		// We only scan the <!DOCTYPE IDENT part and skip the rest.
 		ident:   string,
 		rest:    string,
 	},
 
-	/*
-		If we encounter comments before the root node, and the option to intern comments is given, this is where they'll live.
-		Otherwise they'll be in the element tree.
-	*/
+	// If we encounter comments before the root node, and the option to intern comments is given, this is where they'll live.
+	// Otherwise they'll be in the element tree.
 	comments: [dynamic]string,
 
-	/*
-		Internal
-	*/
+	// Internal
 	tokenizer: ^Tokenizer,
 	allocator: mem.Allocator,
 
-	/*
-		Input. Either the original buffer, or a copy if `.Input_May_Be_Modified` isn't specified.
-	*/
+	// Input. Either the original buffer, or a copy if `.Input_May_Be_Modified` isn't specified.
 	input:           []u8,
 	strings_to_free: [dynamic]string,
 }
@@ -158,34 +134,24 @@ Encoding :: enum {
 	UTF_8,
 	ISO_8859_1,
 
-	/*
-		Aliases
-	*/
+	// Aliases
 	LATIN_1 = ISO_8859_1,
 }
 
 Error :: enum {
-	/*
-		General return values.
-	*/
+	// General return values.
 	None = 0,
 	General_Error,
 	Unexpected_Token,
 	Invalid_Token,
 
-	/*
-		Couldn't find, open or read file.
-	*/
+	// Couldn't find, open or read file.
 	File_Error,
 
-	/*
-		File too short.
-	*/
+	// File too short.
 	Premature_EOF,
 
-	/*
-		XML-specific errors.
-	*/
+	// XML-specific errors.
 	No_Prolog,
 	Invalid_Prolog,
 	Too_Many_Prologs,
@@ -194,11 +160,9 @@ Error :: enum {
 	Too_Many_DocTypes,
 	DocType_Must_Preceed_Elements,
 
-	/*
-		If a DOCTYPE is present _or_ the caller
-		asked for a specific DOCTYPE and the DOCTYPE
-		and root tag don't match, we return `.Invalid_DocType`.
-	*/
+	// If a DOCTYPE is present _or_ the caller
+	// asked for a specific DOCTYPE and the DOCTYPE
+	// and root tag don't match, we return `.Invalid_DocType`.
 	Invalid_DocType,
 
 	Invalid_Tag_Value,
@@ -211,27 +175,20 @@ Error :: enum {
 	Unsupported_Version,
 	Unsupported_Encoding,
 
-	/*
-		<!FOO are usually skipped.
-	*/
+	// <!FOO are usually skipped.
 	Unhandled_Bang,
 
 	Duplicate_Attribute,
 	Conflicting_Options,
 }
 
-/*
-	Implementation starts here.
-*/
 parse_bytes :: proc(data: []u8, options := DEFAULT_OPTIONS, path := "", error_handler := default_error_handler, allocator := context.allocator) -> (doc: ^Document, err: Error) {
 	data := data
 	context.allocator = allocator
 
 	opts := validate_options(options) or_return
 
-	/*
-		If `.Input_May_Be_Modified` is not specified, we duplicate the input so that we can modify it in-place.
-	*/
+	// If `.Input_May_Be_Modified` is not specified, we duplicate the input so that we can modify it in-place.
 	if .Input_May_Be_Modified not_in opts.flags {
 		data = bytes.clone(data)
 	}
@@ -252,10 +209,8 @@ parse_bytes :: proc(data: []u8, options := DEFAULT_OPTIONS, path := "", error_ha
 	element, parent: Element_ID
 	open: Token
 
-	/*
-		If a DOCTYPE is present, the root tag has to match.
-		If an expected DOCTYPE is given in options (i.e. it's non-empty), the DOCTYPE (if present) and root tag have to match.
-	*/
+	// If a DOCTYPE is present, the root tag has to match.
+	// If an expected DOCTYPE is given in options (i.e. it's non-empty), the DOCTYPE (if present) and root tag have to match.
 	expected_doctype := options.expected_doctype
 
 	loop: for {
@@ -263,17 +218,13 @@ parse_bytes :: proc(data: []u8, options := DEFAULT_OPTIONS, path := "", error_ha
 		// NOTE(Jeroen): This is faster as a switch.
 		switch t.ch {
 		case '<':
-			/*
-				Consume peeked `<`
-			*/
+			// Consume peeked `<`
 			advance_rune(t)
 
 			open = scan(t)
 			// NOTE(Jeroen): We're not using a switch because this if-else chain ordered by likelihood is 2.5% faster at -o:size and -o:speed.
 			if likely(open.kind, Token_Kind.Ident) == .Ident {
-				/*
-					e.g. <odin - Start of new element.
-				*/
+				// e.g. <odin - Start of new element.
 				element = new_element(doc)
 				if element == 0 { // First Element
 					parent = element
@@ -286,11 +237,9 @@ parse_bytes :: proc(data: []u8, options := DEFAULT_OPTIONS, path := "", error_ha
 
 				parse_attributes(doc, &doc.elements[element].attribs) or_return
 
-				/*
-					If a DOCTYPE is present _or_ the caller
-					asked for a specific DOCTYPE and the DOCTYPE
-					and root tag don't match, we return .Invalid_Root_Tag.
-				*/
+				// If a DOCTYPE is present _or_ the caller
+				// asked for a specific DOCTYPE and the DOCTYPE
+				// and root tag don't match, we return .Invalid_Root_Tag.
 				if element == 0 { // Root tag?
 					if len(expected_doctype) > 0 && expected_doctype != open.text {
 						error(t, t.offset, "Root Tag doesn't match DOCTYPE. Expected: %v, got: %v\n", expected_doctype, open.text)
@@ -298,23 +247,17 @@ parse_bytes :: proc(data: []u8, options := DEFAULT_OPTIONS, path := "", error_ha
 					}
 				}
 
-				/*
-					One of these should follow:
-					- `>`,  which means we've just opened this tag and expect a later element to close it.
-					- `/>`, which means this is an 'empty' or self-closing tag.
-				*/
+				// One of these should follow:
+				// - `>`,  which means we've just opened this tag and expect a later element to close it.
+				// - `/>`, which means this is an 'empty' or self-closing tag.
 				end_token := scan(t)
 				#partial switch end_token.kind {
 				case .Gt:
-					/*
-						We're now the new parent.
-					*/
+					// We're now the new parent.
 					parent = element
 
 				case .Slash:
-					/*
-						Empty tag. Close it.
-					*/
+					// Empty tag. Close it.
 					expect(t, .Gt) or_return
 					parent      = doc.elements[element].parent
 					element     = parent
@@ -325,9 +268,7 @@ parse_bytes :: proc(data: []u8, options := DEFAULT_OPTIONS, path := "", error_ha
 				}
 
 			} else if open.kind == .Slash {
-				/*
-					Close tag.
-				*/
+				// Close tag.
 				ident := expect(t, .Ident) or_return
 				_      = expect(t, .Gt)    or_return
 
@@ -339,9 +280,7 @@ parse_bytes :: proc(data: []u8, options := DEFAULT_OPTIONS, path := "", error_ha
 				element     = parent
 
 			} else if open.kind == .Exclaim {
-				/*
-					<!
-				*/
+				// <!
 				next := scan(t)
 				#partial switch next.kind {
 				case .Ident:
@@ -370,10 +309,8 @@ parse_bytes :: proc(data: []u8, options := DEFAULT_OPTIONS, path := "", error_ha
 					}
 
 				case .Dash:
-					/*
-						Comment: <!-- -->.
-						The grammar does not allow a comment to end in --->
-					*/
+					// Comment: <!-- -->.
+					// The grammar does not allow a comment to end in --->
 					expect(t, .Dash)
 					comment := scan_comment(t) or_return
 
@@ -395,23 +332,17 @@ parse_bytes :: proc(data: []u8, options := DEFAULT_OPTIONS, path := "", error_ha
 				}
 
 			} else if open.kind == .Question {
-				/*
-					<?xml
-				*/
+				// <?xml
 				next := scan(t)
 				#partial switch next.kind {
 				case .Ident:
 					if len(next.text) == 3 && strings.equal_fold(next.text, "xml") {
 						parse_prologue(doc) or_return
 					} else if len(doc.prologue) > 0 {
-						/*
-							We've already seen a prologue.
-						*/
+						// We've already seen a prologue.
 						return doc, .Too_Many_Prologs
 					} else {
-						/*
-							Could be `<?xml-stylesheet`, etc. Ignore it.
-						*/
+						// Could be `<?xml-stylesheet`, etc. Ignore it.
 						skip_element(t) or_return
 					}
 				case:
@@ -425,15 +356,11 @@ parse_bytes :: proc(data: []u8, options := DEFAULT_OPTIONS, path := "", error_ha
 			}
 
 		case -1:
-			/*
-				End of file.
-			*/
+			// End of file.
 			break loop
 
 		case:
-			/*
-				This should be a tag's body text.
-			*/
+			// This should be a tag's body text.
 			body_text        := scan_string(t, t.offset) or_return
 			needs_processing := .Unbox_CDATA          in opts.flags
 			needs_processing |= .Decode_SGML_Entities in opts.flags
@@ -613,9 +540,7 @@ parse_prologue :: proc(doc: ^Document) -> (err: Error) {
 				doc.encoding = .LATIN_1
 
 			case:
-				/*
-					Unrecognized encoding, assume UTF-8.
-				*/
+				// Unrecognized encoding, assume UTF-8.
 				error(t, offset, "[parse_prologue] Warning: Unrecognized encoding: %v\n", attr.val)
 			}
 
@@ -658,11 +583,11 @@ skip_element :: proc(t: ^Tokenizer) -> (err: Error) {
 
 parse_doctype :: proc(doc: ^Document) -> (err: Error) {
 	/*
-		<!DOCTYPE greeting SYSTEM "hello.dtd">
+	<!DOCTYPE greeting SYSTEM "hello.dtd">
 
-		<!DOCTYPE greeting [
-			<!ELEMENT greeting (#PCDATA)>
-		]>
+	<!DOCTYPE greeting [
+		<!ELEMENT greeting (#PCDATA)>
+	]>
 	*/
 	assert(doc != nil)
 	context.allocator = doc.allocator
@@ -675,9 +600,7 @@ parse_doctype :: proc(doc: ^Document) -> (err: Error) {
 	offset := t.offset
 	skip_element(t) or_return
 
-	/*
-		-1 because the current offset is that of the closing tag, so the rest of the DOCTYPE tag ends just before it.
-	*/
+	// 	-1 because the current offset is that of the closing tag, so the rest of the DOCTYPE tag ends just before it.
 	doc.doctype.rest = string(t.src[offset : t.offset - 1])
 	return .None
 }
@@ -700,4 +623,4 @@ new_element :: proc(doc: ^Document) -> (id: Element_ID) {
 	cur := doc.element_count
 	doc.element_count += 1
 	return cur
-}
+}

core/fmt/fmt.odin

@@ -253,18 +253,24 @@ bprintf :: proc(buf: []byte, fmt: string, args: ..any) -> string {
 // - args: A variadic list of arguments to be formatted
 // - loc: The location of the caller
 //
-// Returns: True if the condition is met, otherwise triggers a runtime assertion with a formatted message
-//
-assertf :: proc(condition: bool, fmt: string, args: ..any, loc := #caller_location) -> bool {
+@(disabled=ODIN_DISABLE_ASSERT)
+assertf :: proc(condition: bool, fmt: string, args: ..any, loc := #caller_location) {
 	if !condition {
-		p := context.assertion_failure_proc
-		if p == nil {
-			p = runtime.default_assertion_failure_proc
+		// NOTE(dragos): We are using the same trick as in builtin.assert
+		// to improve performance to make the CPU not
+		// execute speculatively, making it about an order of
+		// magnitude faster
+		@(cold)
+		internal :: proc(loc: runtime.Source_Code_Location, fmt: string, args: ..any) {
+			p := context.assertion_failure_proc
+			if p == nil {
+				p = runtime.default_assertion_failure_proc
+			}
+			message := tprintf(fmt, ..args)
+			p("Runtime assertion", message, loc)
 		}
-		message := tprintf(fmt, ..args)
-		p("Runtime assertion", message, loc)
+		internal(loc, fmt, ..args)
 	}
-	return condition
 }
 // Runtime panic with a formatted message
 //
@@ -948,24 +954,10 @@ _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.hash { flags |= {.Prefix} }
+	if fi.plus { flags |= {.Plus}   }
 	s := strconv.append_bits(buf[start:], u, base, is_signed, bit_size, digits, flags)
 
-	if fi.hash && fi.zero && fi.indent == 0 {
-		c: byte = 0
-		switch base {
-		case 2:  c = 'b'
-		case 8:  c = 'o'
-		case 12: c = 'z'
-		case 16: c = 'x'
-		}
-		if c != 0 {
-			io.write_byte(fi.writer, '0', &fi.n)
-			io.write_byte(fi.writer, c, &fi.n)
-		}
-	}
-
 	prev_zero := fi.zero
 	defer fi.zero = prev_zero
 	fi.zero = false

core/log/log.odin

@@ -116,6 +116,42 @@ panicf :: proc(fmt_str: string, args: ..any, location := #caller_location) -> !
 	runtime.panic("log.panicf", location)
 }
 
+@(disabled=ODIN_DISABLE_ASSERT)
+assert :: proc(condition: bool, message := "", loc := #caller_location) {
+	if !condition {
+		@(cold)
+		internal :: proc(message: string, loc: runtime.Source_Code_Location) {
+			p := context.assertion_failure_proc
+			if p == nil {
+				p = runtime.default_assertion_failure_proc
+			}
+			log(.Fatal, message, location=loc)
+			p("runtime assertion", message, loc)
+		}
+		internal(message, loc)
+	}
+}
+
+@(disabled=ODIN_DISABLE_ASSERT)
+assertf :: proc(condition: bool, fmt_str: string, args: ..any, loc := #caller_location) {
+	if !condition {
+		// NOTE(dragos): We are using the same trick as in builtin.assert
+		// to improve performance to make the CPU not
+		// execute speculatively, making it about an order of
+		// magnitude faster
+		@(cold)
+		internal :: proc(loc: runtime.Source_Code_Location, fmt_str: string, args: ..any) {
+			p := context.assertion_failure_proc
+			if p == nil {
+				p = runtime.default_assertion_failure_proc
+			}
+			message := fmt.tprintf(fmt_str, ..args)
+			log(.Fatal, message, location=loc)
+			p("Runtime assertion", message, loc)
+		}
+		internal(loc, fmt_str, ..args)
+	}
+}
 
 
 

core/log/log_allocator.odin

@@ -96,6 +96,15 @@ log_allocator_proc :: proc(allocator_data: rawptr, mode: runtime.Allocator_Mode,
 			str := fmt.bprintf(buf[:], format, la.prefix, padding, old_memory, old_size, size, alignment)
 			context.logger.procedure(context.logger.data, la.level, str, context.logger.options, location)
 
+		case .Resize_Non_Zeroed:
+			format: string
+			switch la.size_fmt {
+			case .Bytes: format = "%s%s>>> ALLOCATOR(mode=.Resize_Non_Zeroed, ptr=%p, old_size=%d, size=%d, alignment=%d)"
+			case .Human: format = "%s%s>>> ALLOCATOR(mode=.Resize_Non_Zeroed, ptr=%p, old_size=%m, size=%m, alignment=%d)"
+			}
+			str := fmt.bprintf(buf[:], format, la.prefix, padding, old_memory, old_size, size, alignment)
+			context.logger.procedure(context.logger.data, la.level, str, context.logger.options, location)
+
 		case .Query_Features:
 			str := fmt.bprintf(buf[:], "%s%sALLOCATOR(mode=.Query_Features)", la.prefix, padding)
 			context.logger.procedure(context.logger.data, la.level, str, context.logger.options, location)

core/math/fixed/fixed.odin

@@ -88,17 +88,19 @@ div_sat :: proc(x, y: $T/Fixed($Backing, $Fraction_Width)) -> (z: T) {
 
 @(require_results)
 floor :: proc(x: $T/Fixed($Backing, $Fraction_Width)) -> Backing {
-	return x.i >> Fraction_Width
+	if x.i >= 0 {
+		return x.i >> Fraction_Width
+	} else {
+		return (x.i - (1 << (Fraction_Width - 1)) + (1 << (Fraction_Width - 2))) >> Fraction_Width
+	}
 }
 @(require_results)
 ceil :: proc(x: $T/Fixed($Backing, $Fraction_Width)) -> Backing {
-	Integer :: 8*size_of(Backing) - Fraction_Width
-	return (x.i + (1 << Integer-1)) >> Fraction_Width
+	return (x.i + (1 << Fraction_Width - 1)) >> Fraction_Width
 }
 @(require_results)
 round :: proc(x: $T/Fixed($Backing, $Fraction_Width)) -> Backing {
-	Integer :: 8*size_of(Backing) - Fraction_Width
-	return (x.i + (1 << (Integer - 1))) >> Fraction_Width
+	return (x.i + (1 << (Fraction_Width - 1))) >> Fraction_Width
 }
 
 

core/math/linalg/general.odin

@@ -70,7 +70,7 @@ outer_product :: builtin.outer_product
 
 @(require_results)
 quaternion_inverse :: proc "contextless" (q: $Q) -> Q where IS_QUATERNION(Q) {
-	return conj(q) * quaternion(1.0/dot(q, q), 0, 0, 0)
+	return conj(q) * quaternion(w=1.0/dot(q, q), x=0, y=0, z=0)
 }
 
 
@@ -217,7 +217,7 @@ quaternion64_mul_vector3 :: proc "contextless" (q: $Q/quaternion64, v: $V/[3]$F/
 	Raw_Quaternion :: struct {xyz: [3]f16, r: f16}
 
 	q := transmute(Raw_Quaternion)q
-	v := transmute([3]f16)v
+	v := v
 
 	t := cross(2*q.xyz, v)
 	return V(v + q.r*t + cross(q.xyz, t))
@@ -227,7 +227,7 @@ quaternion128_mul_vector3 :: proc "contextless" (q: $Q/quaternion128, v: $V/[3]$
 	Raw_Quaternion :: struct {xyz: [3]f32, r: f32}
 
 	q := transmute(Raw_Quaternion)q
-	v := transmute([3]f32)v
+	v := v
 
 	t := cross(2*q.xyz, v)
 	return V(v + q.r*t + cross(q.xyz, t))
@@ -237,7 +237,7 @@ quaternion256_mul_vector3 :: proc "contextless" (q: $Q/quaternion256, v: $V/[3]$
 	Raw_Quaternion :: struct {xyz: [3]f64, r: f64}
 
 	q := transmute(Raw_Quaternion)q
-	v := transmute([3]f64)v
+	v := v
 
 	t := cross(2*q.xyz, v)
 	return V(v + q.r*t + cross(q.xyz, t))

core/math/linalg/specific.odin

@@ -7,96 +7,96 @@ F16_EPSILON :: 1e-3
 F32_EPSILON :: 1e-7
 F64_EPSILON :: 1e-15
 
-Vector2f16 :: distinct [2]f16
-Vector3f16 :: distinct [3]f16
-Vector4f16 :: distinct [4]f16
-
-Matrix1x1f16 :: distinct matrix[1, 1]f16
-Matrix1x2f16 :: distinct matrix[1, 2]f16
-Matrix1x3f16 :: distinct matrix[1, 3]f16
-Matrix1x4f16 :: distinct matrix[1, 4]f16
-
-Matrix2x1f16 :: distinct matrix[2, 1]f16
-Matrix2x2f16 :: distinct matrix[2, 2]f16
-Matrix2x3f16 :: distinct matrix[2, 3]f16
-Matrix2x4f16 :: distinct matrix[2, 4]f16
-
-Matrix3x1f16 :: distinct matrix[3, 1]f16
-Matrix3x2f16 :: distinct matrix[3, 2]f16
-Matrix3x3f16 :: distinct matrix[3, 3]f16
-Matrix3x4f16 :: distinct matrix[3, 4]f16
-
-Matrix4x1f16 :: distinct matrix[4, 1]f16
-Matrix4x2f16 :: distinct matrix[4, 2]f16
-Matrix4x3f16 :: distinct matrix[4, 3]f16
-Matrix4x4f16 :: distinct matrix[4, 4]f16
+Vector2f16 :: [2]f16
+Vector3f16 :: [3]f16
+Vector4f16 :: [4]f16
+
+Matrix1x1f16 :: matrix[1, 1]f16
+Matrix1x2f16 :: matrix[1, 2]f16
+Matrix1x3f16 :: matrix[1, 3]f16
+Matrix1x4f16 :: matrix[1, 4]f16
+
+Matrix2x1f16 :: matrix[2, 1]f16
+Matrix2x2f16 :: matrix[2, 2]f16
+Matrix2x3f16 :: matrix[2, 3]f16
+Matrix2x4f16 :: matrix[2, 4]f16
+
+Matrix3x1f16 :: matrix[3, 1]f16
+Matrix3x2f16 :: matrix[3, 2]f16
+Matrix3x3f16 :: matrix[3, 3]f16
+Matrix3x4f16 :: matrix[3, 4]f16
+
+Matrix4x1f16 :: matrix[4, 1]f16
+Matrix4x2f16 :: matrix[4, 2]f16
+Matrix4x3f16 :: matrix[4, 3]f16
+Matrix4x4f16 :: matrix[4, 4]f16
 
 Matrix1f16 :: Matrix1x1f16
 Matrix2f16 :: Matrix2x2f16
 Matrix3f16 :: Matrix3x3f16
 Matrix4f16 :: Matrix4x4f16
 
-Vector2f32 :: distinct [2]f32
-Vector3f32 :: distinct [3]f32
-Vector4f32 :: distinct [4]f32
+Vector2f32 :: [2]f32
+Vector3f32 :: [3]f32
+Vector4f32 :: [4]f32
 
-Matrix1x1f32 :: distinct matrix[1, 1]f32
-Matrix1x2f32 :: distinct matrix[1, 2]f32
-Matrix1x3f32 :: distinct matrix[1, 3]f32
-Matrix1x4f32 :: distinct matrix[1, 4]f32
+Matrix1x1f32 :: matrix[1, 1]f32
+Matrix1x2f32 :: matrix[1, 2]f32
+Matrix1x3f32 :: matrix[1, 3]f32
+Matrix1x4f32 :: matrix[1, 4]f32
 
-Matrix2x1f32 :: distinct matrix[2, 1]f32
-Matrix2x2f32 :: distinct matrix[2, 2]f32
-Matrix2x3f32 :: distinct matrix[2, 3]f32
-Matrix2x4f32 :: distinct matrix[2, 4]f32
+Matrix2x1f32 :: matrix[2, 1]f32
+Matrix2x2f32 :: matrix[2, 2]f32
+Matrix2x3f32 :: matrix[2, 3]f32
+Matrix2x4f32 :: matrix[2, 4]f32
 
-Matrix3x1f32 :: distinct matrix[3, 1]f32
-Matrix3x2f32 :: distinct matrix[3, 2]f32
-Matrix3x3f32 :: distinct matrix[3, 3]f32
-Matrix3x4f32 :: distinct matrix[3, 4]f32
+Matrix3x1f32 :: matrix[3, 1]f32
+Matrix3x2f32 :: matrix[3, 2]f32
+Matrix3x3f32 :: matrix[3, 3]f32
+Matrix3x4f32 :: matrix[3, 4]f32
 
-Matrix4x1f32 :: distinct matrix[4, 1]f32
-Matrix4x2f32 :: distinct matrix[4, 2]f32
-Matrix4x3f32 :: distinct matrix[4, 3]f32
-Matrix4x4f32 :: distinct matrix[4, 4]f32
+Matrix4x1f32 :: matrix[4, 1]f32
+Matrix4x2f32 :: matrix[4, 2]f32
+Matrix4x3f32 :: matrix[4, 3]f32
+Matrix4x4f32 :: matrix[4, 4]f32
 
 Matrix1f32 :: Matrix1x1f32
 Matrix2f32 :: Matrix2x2f32
 Matrix3f32 :: Matrix3x3f32
 Matrix4f32 :: Matrix4x4f32
 
-Vector2f64 :: distinct [2]f64
-Vector3f64 :: distinct [3]f64
-Vector4f64 :: distinct [4]f64
+Vector2f64 :: [2]f64
+Vector3f64 :: [3]f64
+Vector4f64 :: [4]f64
 
-Matrix1x1f64 :: distinct matrix[1, 1]f64
-Matrix1x2f64 :: distinct matrix[1, 2]f64
-Matrix1x3f64 :: distinct matrix[1, 3]f64
-Matrix1x4f64 :: distinct matrix[1, 4]f64
+Matrix1x1f64 :: matrix[1, 1]f64
+Matrix1x2f64 :: matrix[1, 2]f64
+Matrix1x3f64 :: matrix[1, 3]f64
+Matrix1x4f64 :: matrix[1, 4]f64
 
-Matrix2x1f64 :: distinct matrix[2, 1]f64
-Matrix2x2f64 :: distinct matrix[2, 2]f64
-Matrix2x3f64 :: distinct matrix[2, 3]f64
-Matrix2x4f64 :: distinct matrix[2, 4]f64
+Matrix2x1f64 :: matrix[2, 1]f64
+Matrix2x2f64 :: matrix[2, 2]f64
+Matrix2x3f64 :: matrix[2, 3]f64
+Matrix2x4f64 :: matrix[2, 4]f64
 
-Matrix3x1f64 :: distinct matrix[3, 1]f64
-Matrix3x2f64 :: distinct matrix[3, 2]f64
-Matrix3x3f64 :: distinct matrix[3, 3]f64
-Matrix3x4f64 :: distinct matrix[3, 4]f64
+Matrix3x1f64 :: matrix[3, 1]f64
+Matrix3x2f64 :: matrix[3, 2]f64
+Matrix3x3f64 :: matrix[3, 3]f64
+Matrix3x4f64 :: matrix[3, 4]f64
 
-Matrix4x1f64 :: distinct matrix[4, 1]f64
-Matrix4x2f64 :: distinct matrix[4, 2]f64
-Matrix4x3f64 :: distinct matrix[4, 3]f64
-Matrix4x4f64 :: distinct matrix[4, 4]f64
+Matrix4x1f64 :: matrix[4, 1]f64
+Matrix4x2f64 :: matrix[4, 2]f64
+Matrix4x3f64 :: matrix[4, 3]f64
+Matrix4x4f64 :: matrix[4, 4]f64
 
 Matrix1f64 :: Matrix1x1f64
 Matrix2f64 :: Matrix2x2f64
 Matrix3f64 :: Matrix3x3f64
 Matrix4f64 :: Matrix4x4f64
 
-Quaternionf16 :: distinct quaternion64
-Quaternionf32 :: distinct quaternion128
-Quaternionf64 :: distinct quaternion256
+Quaternionf16 :: quaternion64
+Quaternionf32 :: quaternion128
+Quaternionf64 :: quaternion256
 
 MATRIX1F16_IDENTITY :: Matrix1f16(1)
 MATRIX2F16_IDENTITY :: Matrix2f16(1)

core/mem/alloc.odin

@@ -11,6 +11,8 @@ Allocator_Mode :: enum byte {
 	Free_All,
 	Resize,
 	Query_Features,
+	Alloc_Non_Zeroed,
+	Resize_Non_Zeroed,
 }
 */
 
@@ -243,12 +245,26 @@ default_resize_align :: proc(old_memory: rawptr, old_size, new_size, alignment:
 	res = raw_data(data)
 	return
 }
+
+@(require_results)
+default_resize_bytes_align_non_zeroed :: proc(old_data: []byte, new_size, alignment: int, allocator := context.allocator, loc := #caller_location) -> ([]byte, Allocator_Error) {
+	return _default_resize_bytes_align(old_data, new_size, alignment, false, allocator, loc)
+}
 @(require_results)
 default_resize_bytes_align :: proc(old_data: []byte, new_size, alignment: int, allocator := context.allocator, loc := #caller_location) -> ([]byte, Allocator_Error) {
+	return _default_resize_bytes_align(old_data, new_size, alignment, true, allocator, loc)
+}
+
+@(require_results)
+_default_resize_bytes_align :: #force_inline proc(old_data: []byte, new_size, alignment: int, should_zero: bool, allocator := context.allocator, loc := #caller_location) -> ([]byte, Allocator_Error) {
 	old_memory := raw_data(old_data)
 	old_size := len(old_data)
 	if old_memory == nil {
-		return alloc_bytes(new_size, alignment, allocator, loc)
+		if should_zero {
+			return alloc_bytes(new_size, alignment, allocator, loc)
+		} else {
+			return alloc_bytes_non_zeroed(new_size, alignment, allocator, loc)
+		}
 	}
 
 	if new_size == 0 {
@@ -260,7 +276,13 @@ default_resize_bytes_align :: proc(old_data: []byte, new_size, alignment: int, a
 		return old_data, .None
 	}
 
-	new_memory, err := alloc_bytes(new_size, alignment, allocator, loc)
+	new_memory : []byte
+	err : Allocator_Error
+	if should_zero {
+		new_memory, err = alloc_bytes(new_size, alignment, allocator, loc)
+	} else {
+		new_memory, err = alloc_bytes_non_zeroed(new_size, alignment, allocator, loc)
+	}
 	if new_memory == nil || err != nil {
 		return nil, err
 	}

core/mem/allocators.odin

@@ -85,13 +85,16 @@ arena_allocator_proc :: proc(allocator_data: rawptr, mode: Allocator_Mode,
 	case .Free_All:
 		arena.offset = 0
 
-	case .Resize:
-		return default_resize_bytes_align(byte_slice(old_memory, old_size), size, alignment, arena_allocator(arena))
+    case .Resize:
+        return default_resize_bytes_align(byte_slice(old_memory, old_size), size, alignment, arena_allocator(arena))
+
+    case .Resize_Non_Zeroed:
+        return default_resize_bytes_align_non_zeroed(byte_slice(old_memory, old_size), size, alignment, arena_allocator(arena))
 
 	case .Query_Features:
 		set := (^Allocator_Mode_Set)(old_memory)
 		if set != nil {
-			set^ = {.Alloc, .Alloc_Non_Zeroed, .Free_All, .Resize, .Query_Features}
+			set^ = {.Alloc, .Alloc_Non_Zeroed, .Free_All, .Resize, .Resize_Non_Zeroed, .Query_Features}
 		}
 		return nil, nil
 
@@ -259,7 +262,7 @@ scratch_allocator_proc :: proc(allocator_data: rawptr, mode: Allocator_Mode,
 		}
 		clear(&s.leaked_allocations)
 
-	case .Resize:
+	case .Resize, .Resize_Non_Zeroed:
 		begin := uintptr(raw_data(s.data))
 		end := begin + uintptr(len(s.data))
 		old_ptr := uintptr(old_memory)
@@ -278,7 +281,7 @@ scratch_allocator_proc :: proc(allocator_data: rawptr, mode: Allocator_Mode,
 	case .Query_Features:
 		set := (^Allocator_Mode_Set)(old_memory)
 		if set != nil {
-			set^ = {.Alloc, .Alloc_Non_Zeroed, .Free, .Free_All, .Resize, .Query_Features}
+			set^ = {.Alloc, .Alloc_Non_Zeroed, .Free, .Free_All, .Resize, .Resize_Non_Zeroed, .Query_Features}
 		}
 		return nil, nil
 
@@ -406,9 +409,9 @@ stack_allocator_proc :: proc(allocator_data: rawptr, mode: Allocator_Mode,
 		s.prev_offset = 0
 		s.curr_offset = 0
 
-	case .Resize:
+	case .Resize, .Resize_Non_Zeroed:
 		if old_memory == nil {
-			return raw_alloc(s, size, alignment, true)
+			return raw_alloc(s, size, alignment, mode == .Resize)
 		}
 		if size == 0 {
 			return nil, nil
@@ -434,7 +437,7 @@ stack_allocator_proc :: proc(allocator_data: rawptr, mode: Allocator_Mode,
 		old_offset := int(curr_addr - uintptr(header.padding) - uintptr(raw_data(s.data)))
 
 		if old_offset != header.prev_offset {
-			data, err := raw_alloc(s, size, alignment, true)
+			data, err := raw_alloc(s, size, alignment, mode == .Resize)
 			if err == nil {
 				runtime.copy(data, byte_slice(old_memory, old_size))
 			}
@@ -455,7 +458,7 @@ stack_allocator_proc :: proc(allocator_data: rawptr, mode: Allocator_Mode,
 	case .Query_Features:
 		set := (^Allocator_Mode_Set)(old_memory)
 		if set != nil {
-			set^ = {.Alloc, .Alloc_Non_Zeroed, .Free, .Free_All, .Resize, .Query_Features}
+			set^ = {.Alloc, .Alloc_Non_Zeroed, .Free, .Free_All, .Resize, .Resize_Non_Zeroed, .Query_Features}
 		}
 		return nil, nil
 	case .Query_Info:
@@ -565,9 +568,9 @@ small_stack_allocator_proc :: proc(allocator_data: rawptr, mode: Allocator_Mode,
 	case .Free_All:
 		s.offset = 0
 
-	case .Resize:
+	case .Resize, .Resize_Non_Zeroed:
 		if old_memory == nil {
-			return raw_alloc(s, size, align, true)
+			return raw_alloc(s, size, align, mode == .Resize)
 		}
 		if size == 0 {
 			return nil, nil
@@ -590,7 +593,7 @@ small_stack_allocator_proc :: proc(allocator_data: rawptr, mode: Allocator_Mode,
 			return byte_slice(old_memory, size), nil
 		}
 
-		data, err := raw_alloc(s, size, align, true)
+		data, err := raw_alloc(s, size, align, mode == .Resize)
 		if err == nil {
 			runtime.copy(data, byte_slice(old_memory, old_size))
 		}
@@ -599,7 +602,7 @@ small_stack_allocator_proc :: proc(allocator_data: rawptr, mode: Allocator_Mode,
 	case .Query_Features:
 		set := (^Allocator_Mode_Set)(old_memory)
 		if set != nil {
-			set^ = {.Alloc, .Alloc_Non_Zeroed, .Free, .Free_All, .Resize, .Query_Features}
+			set^ = {.Alloc, .Alloc_Non_Zeroed, .Free, .Free_All, .Resize, .Resize_Non_Zeroed, .Query_Features}
 		}
 		return nil, nil
 
@@ -649,7 +652,7 @@ dynamic_pool_allocator_proc :: proc(allocator_data: rawptr, mode: Allocator_Mode
 	case .Free_All:
 		dynamic_pool_free_all(pool)
 		return nil, nil
-	case .Resize:
+	case .Resize, .Resize_Non_Zeroed:
 		if old_size >= size {
 			return byte_slice(old_memory, size), nil
 		}
@@ -662,7 +665,7 @@ dynamic_pool_allocator_proc :: proc(allocator_data: rawptr, mode: Allocator_Mode
 	case .Query_Features:
 		set := (^Allocator_Mode_Set)(old_memory)
 		if set != nil {
-			set^ = {.Alloc, .Alloc_Non_Zeroed, .Free_All, .Resize, .Query_Features, .Query_Info}
+			set^ = {.Alloc, .Alloc_Non_Zeroed, .Free_All, .Resize, .Resize_Non_Zeroed, .Query_Features, .Query_Info}
 		}
 		return nil, nil
 
@@ -826,6 +829,10 @@ panic_allocator_proc :: proc(allocator_data: rawptr, mode: Allocator_Mode,
 		if size > 0 {
 			panic("mem: panic allocator, .Resize called", loc=loc)
 		}
+	case .Resize_Non_Zeroed:
+		if size > 0 {
+			panic("mem: panic allocator, .Resize_Non_Zeroed called", loc=loc)
+		}
 	case .Free:
 		if old_memory != nil {
 			panic("mem: panic allocator, .Free called", loc=loc)
@@ -958,7 +965,7 @@ tracking_allocator_proc :: proc(allocator_data: rawptr, mode: Allocator_Mode,
 		if data.clear_on_free_all {
 			clear_map(&data.allocation_map)
 		}	
-	case .Resize:
+	case .Resize, .Resize_Non_Zeroed:
 		if old_memory != result_ptr {
 			delete_key(&data.allocation_map, old_memory)
 		}

core/mem/virtual/arena.odin

@@ -288,7 +288,7 @@ arena_allocator_proc :: proc(allocator_data: rawptr, mode: mem.Allocator_Mode,
 		err = .Mode_Not_Implemented
 	case .Free_All:
 		arena_free_all(arena, location)
-	case .Resize:
+	case .Resize, .Resize_Non_Zeroed:
 		old_data := ([^]byte)(old_memory)
 
 		switch {

core/mem/virtual/file.odin

@@ -0,0 +1,47 @@
+package mem_virtual
+
+import "core:os"
+
+Map_File_Error :: enum {
+	None,
+	Open_Failure,
+	Stat_Failure,
+	Negative_Size,
+	Too_Large_Size,
+	Map_Failure,
+}
+
+Map_File_Flag :: enum u32 {
+	Read,
+	Write,
+}
+Map_File_Flags :: distinct bit_set[Map_File_Flag; u32]
+
+map_file :: proc{
+	map_file_from_path,
+	map_file_from_file_descriptor,
+}
+
+map_file_from_path :: proc(filename: string, flags: Map_File_Flags) -> (data: []byte, error: Map_File_Error) {
+	fd, err := os.open(filename, os.O_RDWR)
+	if err != 0 {
+		return nil, .Open_Failure
+	}
+	defer os.close(fd)
+
+	return map_file_from_file_descriptor(uintptr(fd), flags)
+}
+
+map_file_from_file_descriptor :: proc(fd: uintptr, flags: Map_File_Flags) -> (data: []byte, error: Map_File_Error) {
+	size, os_err := os.file_size(os.Handle(fd))
+	if os_err != 0 {
+		return nil, .Stat_Failure
+	}
+	if size < 0 {
+		return nil, .Negative_Size
+	}
+	if size != i64(int(size)) {
+		return nil, .Too_Large_Size
+	}
+	return _map_file(fd, size, flags)
+}

core/mem/virtual/virtual_bsd.odin

@@ -22,3 +22,7 @@ _protect :: proc "contextless" (data: rawptr, size: uint, flags: Protect_Flags)
 _platform_memory_init :: proc() {
 
 }
+
+_map_file :: proc "contextless" (fd: uintptr, size: i64, flags: Map_File_Flags) -> (data: []byte, error: Map_File_Error) {
+	return nil, .Map_Failure
+}

core/mem/virtual/virtual_darwin.odin

@@ -136,7 +136,7 @@ _protect :: proc "contextless" (data: rawptr, size: uint, flags: Protect_Flags)
 	if .Write   in flags { pflags |= PROT_WRITE }
 	if .Execute in flags { pflags |= PROT_EXEC  }
 	err := _mprotect(data, size, pflags)
-	return err != 0
+	return err == 0
 }
 
 
@@ -146,3 +146,20 @@ _platform_memory_init :: proc() {
 	// is power of two
 	assert(DEFAULT_PAGE_SIZE != 0 && (DEFAULT_PAGE_SIZE & (DEFAULT_PAGE_SIZE-1)) == 0)
 }
+
+
+_map_file :: proc "contextless" (fd: uintptr, size: i64, flags: Map_File_Flags) -> (data: []byte, error: Map_File_Error) {
+	prot, mflags: c.int
+	if .Read in flags {
+		prot |= PROT_READ
+	}
+	if .Write in flags {
+		prot |= PROT_WRITE
+	}
+	mflags |= MAP_SHARED
+	addr := _mmap(nil, c.size_t(size), prot, mflags, i32(fd), 0)
+	if addr == nil {
+		return nil, .Map_Failure
+	}
+	return ([^]byte)(addr)[:size], nil
+}

core/mem/virtual/virtual_linux.odin

@@ -40,7 +40,7 @@ _protect :: proc "contextless" (data: rawptr, size: uint, flags: Protect_Flags)
 	if .Write   in flags { pflags |= {.WRITE} }
 	if .Execute in flags { pflags |= {.EXEC}  }
 	errno := linux.mprotect(data, size, pflags)
-	return errno != .NONE
+	return errno == .NONE
 }
 
 _platform_memory_init :: proc() {
@@ -48,3 +48,21 @@ _platform_memory_init :: proc() {
 	// is power of two
 	assert(DEFAULT_PAGE_SIZE != 0 && (DEFAULT_PAGE_SIZE & (DEFAULT_PAGE_SIZE-1)) == 0)
 }
+
+
+_map_file :: proc "contextless" (fd: uintptr, size: i64, flags: Map_File_Flags) -> (data: []byte, error: Map_File_Error) {
+	prot: linux.Mem_Protection
+	if .Read in flags {
+		prot += {.READ}
+	}
+	if .Write in flags {
+		prot += {.WRITE}
+	}
+
+	flags := linux.Map_Flags{.SHARED}
+	addr, errno := linux.mmap(0, uint(size), prot, flags, linux.Fd(fd), offset=0)
+	if addr == nil || errno != nil {
+		return nil, .Map_Failure
+	}
+	return ([^]byte)(addr)[:size], nil
+}

core/mem/virtual/virtual_windows.odin

@@ -50,19 +50,39 @@ PAGE_WRITECOPY         :: 0x08
 PAGE_TARGETS_INVALID   :: 0x40000000
 PAGE_TARGETS_NO_UPDATE :: 0x40000000
 
+SECTION_MAP_WRITE :: 0x0002
+SECTION_MAP_READ  :: 0x0004
+FILE_MAP_WRITE    :: SECTION_MAP_WRITE
+FILE_MAP_READ     :: SECTION_MAP_READ
+
 ERROR_INVALID_ADDRESS :: 487
 ERROR_COMMITMENT_LIMIT :: 1455
 
-@(default_calling_convention="stdcall")
+@(default_calling_convention="system")
 foreign Kernel32 {
 	GetSystemInfo  :: proc(lpSystemInfo: LPSYSTEM_INFO) ---
 	VirtualAlloc   :: proc(lpAddress: rawptr, dwSize: uint, flAllocationType: u32, flProtect: u32) -> rawptr ---
 	VirtualFree    :: proc(lpAddress: rawptr, dwSize: uint, dwFreeType: u32) -> b32 ---
 	VirtualProtect :: proc(lpAddress: rawptr, dwSize: uint, flNewProtect: u32, lpflOldProtect: ^u32) -> b32 ---
 	GetLastError   :: proc() -> u32 ---
-}
 
+	CreateFileMappingW :: proc(
+		hFile:                   rawptr,
+		lpFileMappingAttributes: rawptr,
+		flProtect:               u32,
+		dwMaximumSizeHigh:       u32,
+		dwMaximumSizeLow:        u32,
+		lpName:                  [^]u16,
+	) -> rawptr ---
 
+	MapViewOfFile :: proc(
+		hFileMappingObject:   rawptr,
+		dwDesiredAccess:      u32,
+		dwFileOffsetHigh:     u32,
+		dwFileOffsetLow:      u32,
+		dwNumberOfBytesToMap: uint,
+	) -> rawptr ---
+}
 _reserve :: proc "contextless" (size: uint) -> (data: []byte, err: Allocator_Error) {
 	result := VirtualAlloc(nil, size, MEM_RESERVE, PAGE_READWRITE)
 	if result == nil {
@@ -125,3 +145,33 @@ _platform_memory_init :: proc() {
 	// is power of two
 	assert(DEFAULT_PAGE_SIZE != 0 && (DEFAULT_PAGE_SIZE & (DEFAULT_PAGE_SIZE-1)) == 0)
 }
+
+
+_map_file :: proc "contextless" (fd: uintptr, size: i64, flags: Map_File_Flags) -> (data: []byte, error: Map_File_Error) {
+	page_flags: u32
+	if flags == {.Read} {
+		page_flags = PAGE_READONLY
+	} else if flags == {.Write} {
+		page_flags = PAGE_READWRITE
+	} else if flags == {.Read, .Write} {
+		page_flags = PAGE_READWRITE
+	} else {
+		page_flags = PAGE_NOACCESS
+	}
+	maximum_size := transmute([2]u32)size
+	handle := CreateFileMappingW(rawptr(fd), nil, page_flags, maximum_size[1], maximum_size[0], nil)
+	if handle == nil {
+		return nil, .Map_Failure
+	}
+
+	desired_access: u32
+	if .Read in flags {
+		desired_access |= FILE_MAP_READ
+	}
+	if .Write in flags {
+		desired_access |= FILE_MAP_WRITE
+	}
+
+	file_data := MapViewOfFile(handle, desired_access, 0, 0, uint(size))
+	return ([^]byte)(file_data)[:size], nil
+}

core/odin/parser/parser.odin

@@ -436,6 +436,24 @@ expect_closing_brace_of_field_list :: proc(p: ^Parser) -> tokenizer.Token {
 	return expect_brace
 }
 
+expect_closing_parentheses_of_field_list :: proc(p: ^Parser) -> tokenizer.Token {
+	token := p.curr_tok
+	if allow_token(p, .Close_Paren) {
+		return token
+	}
+
+	if allow_token(p, .Semicolon) && !tokenizer.is_newline(token) {
+		str := tokenizer.token_to_string(token)
+		error(p, end_of_line_pos(p, p.prev_tok), "expected a comma, got %s", str)
+	}
+
+	for p.curr_tok.kind != .Close_Paren && p.curr_tok.kind != .EOF && !is_non_inserted_semicolon(p.curr_tok) {
+		advance_token(p)
+	}
+
+	return expect_token(p, .Close_Paren)
+}
+
 is_non_inserted_semicolon :: proc(tok: tokenizer.Token) -> bool {
 	return tok.kind == .Semicolon && tok.text != "\n"
 }
@@ -2095,7 +2113,7 @@ parse_proc_type :: proc(p: ^Parser, tok: tokenizer.Token) -> ^ast.Proc_Type {
 
 	expect_token(p, .Open_Paren)
 	params, _ := parse_field_list(p, .Close_Paren, ast.Field_Flags_Signature_Params)
-	expect_token(p, .Close_Paren)
+	expect_closing_parentheses_of_field_list(p)
 	results, diverging := parse_results(p)
 
 	is_generic := false

core/os/file_windows.odin

@@ -349,7 +349,7 @@ exists :: proc(path: string) -> bool {
 	wpath := win32.utf8_to_wstring(path, context.temp_allocator)
 	attribs := win32.GetFileAttributesW(wpath)
 
-	return i32(attribs) != win32.INVALID_FILE_ATTRIBUTES
+	return attribs != win32.INVALID_FILE_ATTRIBUTES
 }
 
 is_file :: proc(path: string) -> bool {
@@ -357,7 +357,7 @@ is_file :: proc(path: string) -> bool {
 	wpath := win32.utf8_to_wstring(path, context.temp_allocator)
 	attribs := win32.GetFileAttributesW(wpath)
 
-	if i32(attribs) != win32.INVALID_FILE_ATTRIBUTES {
+	if attribs != win32.INVALID_FILE_ATTRIBUTES {
 		return attribs & win32.FILE_ATTRIBUTE_DIRECTORY == 0
 	}
 	return false
@@ -368,7 +368,7 @@ is_dir :: proc(path: string) -> bool {
 	wpath := win32.utf8_to_wstring(path, context.temp_allocator)
 	attribs := win32.GetFileAttributesW(wpath)
 
-	if i32(attribs) != win32.INVALID_FILE_ATTRIBUTES {
+	if attribs != win32.INVALID_FILE_ATTRIBUTES {
 		return attribs & win32.FILE_ATTRIBUTE_DIRECTORY != 0
 	}
 	return false

core/os/os.odin

@@ -210,15 +210,15 @@ heap_allocator_proc :: proc(allocator_data: rawptr, mode: mem.Allocator_Mode,
 		}
 	}
 
-	aligned_resize :: proc(p: rawptr, old_size: int, new_size: int, new_alignment: int) -> (new_memory: []byte, err: mem.Allocator_Error) {
+	aligned_resize :: proc(p: rawptr, old_size: int, new_size: int, new_alignment: int, zero_memory := true) -> (new_memory: []byte, err: mem.Allocator_Error) {
 		if p == nil {
 			return nil, nil
 		}
 
-		new_memory = aligned_alloc(new_size, new_alignment, p) or_return
+		new_memory = aligned_alloc(new_size, new_alignment, p, zero_memory) or_return
 
 		// NOTE: heap_resize does not zero the new memory, so we do it
-		if new_size > old_size {
+		if zero_memory && new_size > old_size {
 			new_region := mem.raw_data(new_memory[old_size:])
 			mem.zero(new_region, new_size - old_size)
 		}
@@ -235,16 +235,16 @@ heap_allocator_proc :: proc(allocator_data: rawptr, mode: mem.Allocator_Mode,
 	case .Free_All:
 		return nil, .Mode_Not_Implemented
 
-	case .Resize:
+	case .Resize, .Resize_Non_Zeroed:
 		if old_memory == nil {
-			return aligned_alloc(size, alignment)
+			return aligned_alloc(size, alignment, nil, mode == .Resize)
 		}
-		return aligned_resize(old_memory, old_size, size, alignment)
+		return aligned_resize(old_memory, old_size, size, alignment, mode == .Resize)
 
 	case .Query_Features:
 		set := (^mem.Allocator_Mode_Set)(old_memory)
 		if set != nil {
-			set^ = {.Alloc, .Alloc_Non_Zeroed, .Free, .Resize, .Query_Features}
+			set^ = {.Alloc, .Alloc_Non_Zeroed, .Free, .Resize, .Resize_Non_Zeroed, .Query_Features}
 		}
 		return nil, nil
 

core/os/os2/file_windows.odin

@@ -454,7 +454,7 @@ _remove :: proc(name: string) -> Error {
 
 	if err != err1 {
 		a := win32.GetFileAttributesW(p)
-		if a == ~u32(0) {
+		if a == win32.INVALID_FILE_ATTRIBUTES {
 			err = _get_platform_error()
 		} else {
 			if a & win32.FILE_ATTRIBUTE_DIRECTORY != 0 {
@@ -704,13 +704,13 @@ _fchtimes :: proc(f: ^File, atime, mtime: time.Time) -> Error {
 _exists :: proc(path: string) -> bool {
 	wpath := _fix_long_path(path)
 	attribs := win32.GetFileAttributesW(wpath)
-	return i32(attribs) != win32.INVALID_FILE_ATTRIBUTES
+	return attribs != win32.INVALID_FILE_ATTRIBUTES
 }
 
 _is_file :: proc(path: string) -> bool {
 	wpath := _fix_long_path(path)
 	attribs := win32.GetFileAttributesW(wpath)
-	if i32(attribs) != win32.INVALID_FILE_ATTRIBUTES {
+	if attribs != win32.INVALID_FILE_ATTRIBUTES {
 		return attribs & win32.FILE_ATTRIBUTE_DIRECTORY == 0
 	}
 	return false
@@ -719,7 +719,7 @@ _is_file :: proc(path: string) -> bool {
 _is_dir :: proc(path: string) -> bool {
 	wpath := _fix_long_path(path)
 	attribs := win32.GetFileAttributesW(wpath)
-	if i32(attribs) != win32.INVALID_FILE_ATTRIBUTES {
+	if attribs != win32.INVALID_FILE_ATTRIBUTES {
 		return attribs & win32.FILE_ATTRIBUTE_DIRECTORY != 0
 	}
 	return false

core/os/os2/heap_windows.odin

@@ -85,7 +85,7 @@ _heap_allocator_proc :: proc(allocator_data: rawptr, mode: mem.Allocator_Mode,
 	case .Free_All:
 		return nil, .Mode_Not_Implemented
 
-	case .Resize:
+	case .Resize, .Resize_Non_Zeroed:
 		if old_memory == nil {
 			return aligned_alloc(size, alignment, true)
 		}

core/runtime/core.odin

@@ -18,6 +18,7 @@
 // This could change at a later date if the all these data structures are
 // implemented within the compiler rather than in this "preload" file
 //
+//+no-instrumentation
 package runtime
 
 import "core:intrinsics"
@@ -306,6 +307,7 @@ Allocator_Mode :: enum byte {
 	Query_Features,
 	Query_Info,
 	Alloc_Non_Zeroed,
+	Resize_Non_Zeroed,
 }
 
 Allocator_Mode_Set :: distinct bit_set[Allocator_Mode]

core/runtime/core_builtin.odin

@@ -169,10 +169,16 @@ clear :: proc{clear_dynamic_array, clear_map}
 @builtin
 reserve :: proc{reserve_dynamic_array, reserve_map}
 
-// `resize` will try to resize memory of a passed dynamic array or map to the requested element count (setting the `len`, and possibly `cap`).
+@builtin
+non_zero_reserve :: proc{non_zero_reserve_dynamic_array}
+
+// `resize` will try to resize memory of a passed dynamic array to the requested element count (setting the `len`, and possibly `cap`).
 @builtin
 resize :: proc{resize_dynamic_array}
 
+@builtin
+non_zero_resize :: proc{non_zero_resize_dynamic_array}
+
 // Shrinks the capacity of a dynamic array or map down to the current length, or the given capacity.
 @builtin
 shrink :: proc{shrink_dynamic_array, shrink_map}
@@ -406,10 +412,7 @@ delete_key :: proc(m: ^$T/map[$K]$V, key: K) -> (deleted_key: K, deleted_value:
 	return
 }
 
-
-
-@builtin
-append_elem :: proc(array: ^$T/[dynamic]$E, arg: E, loc := #caller_location) -> (n: int, err: Allocator_Error) #optional_allocator_error {
+_append_elem :: #force_inline proc(array: ^$T/[dynamic]$E, arg: E, should_zero: bool, loc := #caller_location) -> (n: int, err: Allocator_Error) #optional_allocator_error {
 	if array == nil {
 		return 0, nil
 	}
@@ -420,7 +423,13 @@ append_elem :: proc(array: ^$T/[dynamic]$E, arg: E, loc := #caller_location) ->
 	} else {
 		if cap(array) < len(array)+1 {
 			cap := 2 * cap(array) + max(8, 1)
-			err = reserve(array, cap, loc) // do not 'or_return' here as it could be a partial success
+
+			// do not 'or_return' here as it could be a partial success
+			if should_zero {
+				err = reserve(array, cap, loc)
+			} else {
+				err = non_zero_reserve(array, cap, loc) 
+			}
 		}
 		if cap(array)-len(array) > 0 {
 			a := (^Raw_Dynamic_Array)(array)
@@ -437,7 +446,16 @@ append_elem :: proc(array: ^$T/[dynamic]$E, arg: E, loc := #caller_location) ->
 }
 
 @builtin
-append_elems :: proc(array: ^$T/[dynamic]$E, args: ..E, loc := #caller_location) -> (n: int, err: Allocator_Error) #optional_allocator_error {
+append_elem :: proc(array: ^$T/[dynamic]$E, arg: E, loc := #caller_location) -> (n: int, err: Allocator_Error) #optional_allocator_error {
+	return _append_elem(array, arg, true, loc=loc)
+}
+
+@builtin
+non_zero_append_elem :: proc(array: ^$T/[dynamic]$E, arg: E, loc := #caller_location) -> (n: int, err: Allocator_Error) #optional_allocator_error {
+	return _append_elem(array, arg, false, loc=loc)
+}
+
+_append_elems :: #force_inline proc(array: ^$T/[dynamic]$E, should_zero: bool, loc := #caller_location, args: ..E) -> (n: int, err: Allocator_Error) #optional_allocator_error {
 	if array == nil {
 		return 0, nil
 	}
@@ -454,7 +472,13 @@ append_elems :: proc(array: ^$T/[dynamic]$E, args: ..E, loc := #caller_location)
 	} else {
 		if cap(array) < len(array)+arg_len {
 			cap := 2 * cap(array) + max(8, arg_len)
-			err = reserve(array, cap, loc)  // do not 'or_return' here as it could be a partial success
+
+			// do not 'or_return' here as it could be a partial success
+			if should_zero {
+				err = reserve(array, cap, loc)
+			} else {
+				err = non_zero_reserve(array, cap, loc)
+			}
 		}
 		arg_len = min(cap(array)-len(array), arg_len)
 		if arg_len > 0 {
@@ -470,11 +494,33 @@ append_elems :: proc(array: ^$T/[dynamic]$E, args: ..E, loc := #caller_location)
 	}
 }
 
+@builtin
+append_elems :: proc(array: ^$T/[dynamic]$E, args: ..E, loc := #caller_location) -> (n: int, err: Allocator_Error) #optional_allocator_error {
+	return _append_elems(array, true, loc, ..args)
+}
+
+@builtin
+non_zero_append_elems :: proc(array: ^$T/[dynamic]$E, args: ..E, loc := #caller_location) -> (n: int, err: Allocator_Error) #optional_allocator_error {
+	return _append_elems(array, false, loc, ..args)
+}
+
 // The append_string built-in procedure appends a string to the end of a [dynamic]u8 like type
+_append_elem_string :: proc(array: ^$T/[dynamic]$E/u8, arg: $A/string, should_zero: bool, loc := #caller_location) -> (n: int, err: Allocator_Error) #optional_allocator_error {
+	args := transmute([]E)arg
+	if should_zero { 
+		return append_elems(array, ..args, loc=loc)
+	} else {
+		return non_zero_append_elems(array, ..args, loc=loc)
+	}
+}
+
 @builtin
 append_elem_string :: proc(array: ^$T/[dynamic]$E/u8, arg: $A/string, loc := #caller_location) -> (n: int, err: Allocator_Error) #optional_allocator_error {
-	args := transmute([]E)arg
-	return append_elems(array, ..args, loc=loc)
+	return _append_elem_string(array, arg, true, loc)
+}
+@builtin
+non_zero_append_elem_string :: proc(array: ^$T/[dynamic]$E/u8, arg: $A/string, loc := #caller_location) -> (n: int, err: Allocator_Error) #optional_allocator_error {
+	return _append_elem_string(array, arg, false, loc)
 }
 
 
@@ -494,6 +540,7 @@ append_string :: proc(array: ^$T/[dynamic]$E/u8, args: ..string, loc := #caller_
 
 // The append built-in procedure appends elements to the end of a dynamic array
 @builtin append :: proc{append_elem, append_elems, append_elem_string}
+@builtin non_zero_append :: proc{non_zero_append_elem, non_zero_append_elems, non_zero_append_elem_string}
 
 
 @builtin
@@ -638,8 +685,7 @@ clear_dynamic_array :: proc "contextless" (array: ^$T/[dynamic]$E) {
 // `reserve_dynamic_array` will try to reserve memory of a passed dynamic array or map to the requested element count (setting the `cap`).
 //
 // Note: Prefer the procedure group `reserve`.
-@builtin
-reserve_dynamic_array :: proc(array: ^$T/[dynamic]$E, capacity: int, loc := #caller_location) -> Allocator_Error {
+_reserve_dynamic_array :: #force_inline proc(array: ^$T/[dynamic]$E, capacity: int, should_zero: bool, loc := #caller_location) -> Allocator_Error {
 	if array == nil {
 		return nil
 	}
@@ -658,7 +704,12 @@ reserve_dynamic_array :: proc(array: ^$T/[dynamic]$E, capacity: int, loc := #cal
 	new_size  := capacity * size_of(E)
 	allocator := a.allocator
 
-	new_data := mem_resize(a.data, old_size, new_size, align_of(E), allocator, loc) or_return
+	new_data: []byte
+	if should_zero {
+		new_data = mem_resize(a.data, old_size, new_size, align_of(E), allocator, loc) or_return
+	} else {
+		new_data = non_zero_mem_resize(a.data, old_size, new_size, align_of(E), allocator, loc) or_return
+	}
 	if new_data == nil && new_size > 0 {
 		return .Out_Of_Memory
 	}
@@ -668,11 +719,20 @@ reserve_dynamic_array :: proc(array: ^$T/[dynamic]$E, capacity: int, loc := #cal
 	return nil
 }
 
+@builtin
+reserve_dynamic_array :: proc(array: ^$T/[dynamic]$E, capacity: int, loc := #caller_location) -> Allocator_Error {
+	return _reserve_dynamic_array(array, capacity, true, loc)
+}
+
+@builtin
+non_zero_reserve_dynamic_array :: proc(array: ^$T/[dynamic]$E, capacity: int, loc := #caller_location) -> Allocator_Error {
+	return _reserve_dynamic_array(array, capacity, false, loc)
+}
+
 // `resize_dynamic_array` will try to resize memory of a passed dynamic array or map to the requested element count (setting the `len`, and possibly `cap`).
 //
 // Note: Prefer the procedure group `resize`
-@builtin
-resize_dynamic_array :: proc(array: ^$T/[dynamic]$E, length: int, loc := #caller_location) -> Allocator_Error {
+_resize_dynamic_array :: #force_inline proc(array: ^$T/[dynamic]$E, length: int, should_zero: bool, loc := #caller_location) -> Allocator_Error {
 	if array == nil {
 		return nil
 	}
@@ -692,7 +752,12 @@ resize_dynamic_array :: proc(array: ^$T/[dynamic]$E, length: int, loc := #caller
 	new_size  := length * size_of(E)
 	allocator := a.allocator
 
-	new_data := mem_resize(a.data, old_size, new_size, align_of(E), allocator, loc) or_return
+	new_data : []byte
+	if should_zero {
+		new_data = mem_resize(a.data, old_size, new_size, align_of(E), allocator, loc) or_return
+	} else {
+		new_data = non_zero_mem_resize(a.data, old_size, new_size, align_of(E), allocator, loc) or_return
+	}
 	if new_data == nil && new_size > 0 {
 		return .Out_Of_Memory
 	}
@@ -703,6 +768,16 @@ resize_dynamic_array :: proc(array: ^$T/[dynamic]$E, length: int, loc := #caller
 	return nil
 }
 
+@builtin
+resize_dynamic_array :: proc(array: ^$T/[dynamic]$E, length: int, loc := #caller_location) -> Allocator_Error {
+	return _resize_dynamic_array(array, length, true, loc=loc)
+}
+
+@builtin
+non_zero_resize_dynamic_array :: proc(array: ^$T/[dynamic]$E, length: int, loc := #caller_location) -> Allocator_Error {
+	return _resize_dynamic_array(array, length, false, loc=loc)
+}
+
 /*
 	Shrinks the capacity of a dynamic array down to the current length, or the given capacity.
 

core/runtime/default_allocators_arena.odin

@@ -195,7 +195,7 @@ arena_allocator_proc :: proc(allocator_data: rawptr, mode: Allocator_Mode,
 		err = .Mode_Not_Implemented
 	case .Free_All:
 		arena_free_all(arena, location)
-	case .Resize:
+	case .Resize, .Resize_Non_Zeroed:
 		old_data := ([^]byte)(old_memory)
 
 		switch {

core/runtime/default_allocators_nil.odin

@@ -10,7 +10,7 @@ nil_allocator_proc :: proc(allocator_data: rawptr, mode: Allocator_Mode,
 		return nil, .None
 	case .Free_All:
 		return nil, .Mode_Not_Implemented
-	case .Resize:
+	case .Resize, .Resize_Non_Zeroed:
 		if size == 0 {
 			return nil, .None
 		}
@@ -55,6 +55,10 @@ panic_allocator_proc :: proc(allocator_data: rawptr, mode: Allocator_Mode,
 		if size > 0 {
 			panic("panic allocator, .Resize called", loc=loc)
 		}
+	case .Resize_Non_Zeroed:
+		if size > 0 {
+			panic("panic allocator, .Alloc_Non_Zeroed called", loc=loc)
+		}
 	case .Free:
 		if old_memory != nil {
 			panic("panic allocator, .Free called", loc=loc)

core/runtime/default_allocators_windows.odin

@@ -19,7 +19,7 @@ when ODIN_DEFAULT_TO_NIL_ALLOCATOR {
 		case .Free_All:
 			return nil, .Mode_Not_Implemented
 
-		case .Resize:
+		case .Resize, .Resize_Non_Zeroed:
 			data, err = _windows_default_resize(old_memory, old_size, size, alignment)
 
 		case .Query_Features:
@@ -41,4 +41,4 @@ when ODIN_DEFAULT_TO_NIL_ALLOCATOR {
 			data = nil,
 		}
 	}
-}
+}

core/runtime/entry_unix.odin

@@ -1,5 +1,6 @@
 //+private
 //+build linux, darwin, freebsd, openbsd
+//+no-instrumentation
 package runtime
 
 import "core:intrinsics"

core/runtime/entry_wasm.odin

@@ -1,5 +1,6 @@
 //+private
 //+build wasm32, wasm64p32
+//+no-instrumentation
 package runtime
 
 import "core:intrinsics"

core/runtime/entry_windows.odin

@@ -1,12 +1,13 @@
 //+private
 //+build windows
+//+no-instrumentation
 package runtime
 
 import "core:intrinsics"
 
 when ODIN_BUILD_MODE == .Dynamic {
 	@(link_name="DllMain", linkage="strong", require)
-	DllMain :: proc "stdcall" (hinstDLL: rawptr, fdwReason: u32, lpReserved: rawptr) -> b32 {
+	DllMain :: proc "system" (hinstDLL: rawptr, fdwReason: u32, lpReserved: rawptr) -> b32 {
 		context = default_context()
 
 		// Populate Windows DLL-specific global
@@ -28,7 +29,7 @@ when ODIN_BUILD_MODE == .Dynamic {
 } else when !ODIN_TEST && !ODIN_NO_ENTRY_POINT {
 	when ODIN_ARCH == .i386 || ODIN_NO_CRT {
 		@(link_name="mainCRTStartup", linkage="strong", require)
-		mainCRTStartup :: proc "stdcall" () -> i32 {
+		mainCRTStartup :: proc "system" () -> i32 {
 			context = default_context()
 			#force_no_inline _startup_runtime()
 			intrinsics.__entry_point()

core/runtime/error_checks.odin

@@ -1,5 +1,6 @@
 package runtime
 
+@(no_instrumentation)
 bounds_trap :: proc "contextless" () -> ! {
 	when ODIN_OS == .Windows {
 		windows_trap_array_bounds()
@@ -8,6 +9,7 @@ bounds_trap :: proc "contextless" () -> ! {
 	}
 }
 
+@(no_instrumentation)
 type_assertion_trap :: proc "contextless" () -> ! {
 	when ODIN_OS == .Windows {
 		windows_trap_type_assertion()
@@ -21,7 +23,7 @@ bounds_check_error :: proc "contextless" (file: string, line, column: i32, index
 	if uint(index) < uint(count) {
 		return
 	}
-	@(cold)
+	@(cold, no_instrumentation)
 	handle_error :: proc "contextless" (file: string, line, column: i32, index, count: int) -> ! {
 		print_caller_location(Source_Code_Location{file, line, column, ""})
 		print_string(" Index ")
@@ -34,6 +36,7 @@ bounds_check_error :: proc "contextless" (file: string, line, column: i32, index
 	handle_error(file, line, column, index, count)
 }
 
+@(no_instrumentation)
 slice_handle_error :: proc "contextless" (file: string, line, column: i32, lo, hi: int, len: int) -> ! {
 	print_caller_location(Source_Code_Location{file, line, column, ""})
 	print_string(" Invalid slice indices ")
@@ -46,6 +49,7 @@ slice_handle_error :: proc "contextless" (file: string, line, column: i32, lo, h
 	bounds_trap()
 }
 
+@(no_instrumentation)
 multi_pointer_slice_handle_error :: proc "contextless" (file: string, line, column: i32, lo, hi: int) -> ! {
 	print_caller_location(Source_Code_Location{file, line, column, ""})
 	print_string(" Invalid slice indices ")
@@ -82,7 +86,7 @@ dynamic_array_expr_error :: proc "contextless" (file: string, line, column: i32,
 	if 0 <= low && low <= high && high <= max {
 		return
 	}
-	@(cold)
+	@(cold, no_instrumentation)
 	handle_error :: proc "contextless" (file: string, line, column: i32, low, high, max: int) -> ! {
 		print_caller_location(Source_Code_Location{file, line, column, ""})
 		print_string(" Invalid dynamic array indices ")
@@ -103,7 +107,7 @@ matrix_bounds_check_error :: proc "contextless" (file: string, line, column: i32
 	   uint(column_index) < uint(column_count) {
 		return
 	}
-	@(cold)
+	@(cold, no_instrumentation)
 	handle_error :: proc "contextless" (file: string, line, column: i32, row_index, column_index, row_count, column_count: int) -> ! {
 		print_caller_location(Source_Code_Location{file, line, column, ""})
 		print_string(" Matrix indices [")
@@ -127,7 +131,7 @@ when ODIN_NO_RTTI {
 		if ok {
 			return
 		}
-		@(cold)
+		@(cold, no_instrumentation)
 		handle_error :: proc "contextless" (file: string, line, column: i32) -> ! {
 			print_caller_location(Source_Code_Location{file, line, column, ""})
 			print_string(" Invalid type assertion\n")
@@ -140,7 +144,7 @@ when ODIN_NO_RTTI {
 		if ok {
 			return
 		}
-		@(cold)
+		@(cold, no_instrumentation)
 		handle_error :: proc "contextless" (file: string, line, column: i32) -> ! {
 			print_caller_location(Source_Code_Location{file, line, column, ""})
 			print_string(" Invalid type assertion\n")
@@ -153,7 +157,7 @@ when ODIN_NO_RTTI {
 		if ok {
 			return
 		}
-		@(cold)
+		@(cold, no_instrumentation)
 		handle_error :: proc "contextless" (file: string, line, column: i32, from, to: typeid) -> ! {
 			print_caller_location(Source_Code_Location{file, line, column, ""})
 			print_string(" Invalid type assertion from ")
@@ -198,7 +202,7 @@ when ODIN_NO_RTTI {
 			return id
 		}
 
-		@(cold)
+		@(cold, no_instrumentation)
 		handle_error :: proc "contextless" (file: string, line, column: i32, from, to: typeid, from_data: rawptr) -> ! {
 
 			actual := variant_type(from, from_data)
@@ -224,7 +228,7 @@ make_slice_error_loc :: #force_inline proc "contextless" (loc := #caller_locatio
 	if 0 <= len {
 		return
 	}
-	@(cold)
+	@(cold, no_instrumentation)
 	handle_error :: proc "contextless" (loc: Source_Code_Location, len: int) -> ! {
 		print_caller_location(loc)
 		print_string(" Invalid slice length for make: ")
@@ -239,7 +243,7 @@ make_dynamic_array_error_loc :: #force_inline proc "contextless" (loc := #caller
 	if 0 <= len && len <= cap {
 		return
 	}
-	@(cold)
+	@(cold, no_instrumentation)
 	handle_error :: proc "contextless" (loc: Source_Code_Location, len, cap: int)  -> ! {
 		print_caller_location(loc)
 		print_string(" Invalid dynamic array parameters for make: ")
@@ -256,7 +260,7 @@ make_map_expr_error_loc :: #force_inline proc "contextless" (loc := #caller_loca
 	if 0 <= cap {
 		return
 	}
-	@(cold)
+	@(cold, no_instrumentation)
 	handle_error :: proc "contextless" (loc: Source_Code_Location, cap: int)  -> ! {
 		print_caller_location(loc)
 		print_string(" Invalid map capacity for make: ")

core/runtime/internal.odin

@@ -187,7 +187,7 @@ mem_free_all :: #force_inline proc(allocator := context.allocator, loc := #calle
 	return
 }
 
-mem_resize :: proc(ptr: rawptr, old_size, new_size: int, alignment: int = DEFAULT_ALIGNMENT, allocator := context.allocator, loc := #caller_location) -> (data: []byte, err: Allocator_Error) {
+_mem_resize :: #force_inline proc(ptr: rawptr, old_size, new_size: int, alignment: int = DEFAULT_ALIGNMENT, allocator := context.allocator, should_zero: bool, loc := #caller_location) -> (data: []byte, err: Allocator_Error) {
 	if allocator.procedure == nil {
 		return nil, nil
 	}
@@ -198,15 +198,27 @@ mem_resize :: proc(ptr: rawptr, old_size, new_size: int, alignment: int = DEFAUL
 		}
 		return
 	} else if ptr == nil {
-		return allocator.procedure(allocator.data, .Alloc, new_size, alignment, nil, 0, loc)
+		if should_zero {
+			return allocator.procedure(allocator.data, .Alloc, new_size, alignment, nil, 0, loc)
+		} else {
+			return allocator.procedure(allocator.data, .Alloc_Non_Zeroed, new_size, alignment, nil, 0, loc)
+		}
 	} else if old_size == new_size && uintptr(ptr) % uintptr(alignment) == 0 {
 		data = ([^]byte)(ptr)[:old_size]
 		return
 	}
 
-	data, err = allocator.procedure(allocator.data, .Resize, new_size, alignment, ptr, old_size, loc)
+	if should_zero {
+		data, err = allocator.procedure(allocator.data, .Resize, new_size, alignment, ptr, old_size, loc)
+	} else {
+		data, err = allocator.procedure(allocator.data, .Resize_Non_Zeroed, new_size, alignment, ptr, old_size, loc)
+	}
 	if err == .Mode_Not_Implemented {
-		data, err = allocator.procedure(allocator.data, .Alloc, new_size, alignment, nil, 0, loc)
+		if should_zero {
+			data, err = allocator.procedure(allocator.data, .Alloc, new_size, alignment, nil, 0, loc)
+		} else {
+			data, err = allocator.procedure(allocator.data, .Alloc_Non_Zeroed, new_size, alignment, nil, 0, loc)
+		}
 		if err != nil {
 			return
 		}
@@ -216,6 +228,13 @@ mem_resize :: proc(ptr: rawptr, old_size, new_size: int, alignment: int = DEFAUL
 	return
 }
 
+mem_resize :: proc(ptr: rawptr, old_size, new_size: int, alignment: int = DEFAULT_ALIGNMENT, allocator := context.allocator, loc := #caller_location) -> (data: []byte, err: Allocator_Error) {
+	return _mem_resize(ptr, old_size, new_size, alignment, allocator, true, loc)
+}
+non_zero_mem_resize :: proc(ptr: rawptr, old_size, new_size: int, alignment: int = DEFAULT_ALIGNMENT, allocator := context.allocator, loc := #caller_location) -> (data: []byte, err: Allocator_Error) {
+	return _mem_resize(ptr, old_size, new_size, alignment, allocator, false, loc)
+}
+
 memory_equal :: proc "contextless" (x, y: rawptr, n: int) -> bool {
 	switch {
 	case n == 0: return true
@@ -730,7 +749,7 @@ mul_quaternion64 :: proc "contextless" (q, r: quaternion64) -> quaternion64 {
 	t2 := r0*q2 + r1*q3 + r2*q0 - r3*q1
 	t3 := r0*q3 - r1*q2 + r2*q1 + r3*q0
 
-	return quaternion(t0, t1, t2, t3)
+	return quaternion(w=t0, x=t1, y=t2, z=t3)
 }
 
 mul_quaternion128 :: proc "contextless" (q, r: quaternion128) -> quaternion128 {
@@ -742,7 +761,7 @@ mul_quaternion128 :: proc "contextless" (q, r: quaternion128) -> quaternion128 {
 	t2 := r0*q2 + r1*q3 + r2*q0 - r3*q1
 	t3 := r0*q3 - r1*q2 + r2*q1 + r3*q0
 
-	return quaternion(t0, t1, t2, t3)
+	return quaternion(w=t0, x=t1, y=t2, z=t3)
 }
 
 mul_quaternion256 :: proc "contextless" (q, r: quaternion256) -> quaternion256 {
@@ -754,7 +773,7 @@ mul_quaternion256 :: proc "contextless" (q, r: quaternion256) -> quaternion256 {
 	t2 := r0*q2 + r1*q3 + r2*q0 - r3*q1
 	t3 := r0*q3 - r1*q2 + r2*q1 + r3*q0
 
-	return quaternion(t0, t1, t2, t3)
+	return quaternion(w=t0, x=t1, y=t2, z=t3)
 }
 
 quo_quaternion64 :: proc "contextless" (q, r: quaternion64) -> quaternion64 {
@@ -768,7 +787,7 @@ quo_quaternion64 :: proc "contextless" (q, r: quaternion64) -> quaternion64 {
 	t2 := (r0*q2 - r1*q3 - r2*q0 + r3*q1) * invmag2
 	t3 := (r0*q3 + r1*q2 + r2*q1 - r3*q0) * invmag2
 
-	return quaternion(t0, t1, t2, t3)
+	return quaternion(w=t0, x=t1, y=t2, z=t3)
 }
 
 quo_quaternion128 :: proc "contextless" (q, r: quaternion128) -> quaternion128 {
@@ -782,7 +801,7 @@ quo_quaternion128 :: proc "contextless" (q, r: quaternion128) -> quaternion128 {
 	t2 := (r0*q2 - r1*q3 - r2*q0 + r3*q1) * invmag2
 	t3 := (r0*q3 + r1*q2 + r2*q1 - r3*q0) * invmag2
 
-	return quaternion(t0, t1, t2, t3)
+	return quaternion(w=t0, x=t1, y=t2, z=t3)
 }
 
 quo_quaternion256 :: proc "contextless" (q, r: quaternion256) -> quaternion256 {
@@ -796,7 +815,7 @@ quo_quaternion256 :: proc "contextless" (q, r: quaternion256) -> quaternion256 {
 	t2 := (r0*q2 - r1*q3 - r2*q0 + r3*q1) * invmag2
 	t3 := (r0*q3 + r1*q2 + r2*q1 - r3*q0) * invmag2
 
-	return quaternion(t0, t1, t2, t3)
+	return quaternion(w=t0, x=t1, y=t2, z=t3)
 }
 
 @(link_name="__truncsfhf2", linkage=RUNTIME_LINKAGE, require=RUNTIME_REQUIRE)

core/runtime/os_specific_windows.odin

@@ -4,7 +4,7 @@ package runtime
 foreign import kernel32 "system:Kernel32.lib"
 
 @(private="file")
-@(default_calling_convention="stdcall")
+@(default_calling_convention="system")
 foreign kernel32 {
 	// NOTE(bill): The types are not using the standard names (e.g. DWORD and LPVOID) to just minimizing the dependency
 

core/runtime/procs.odin

@@ -4,7 +4,7 @@ when ODIN_NO_CRT && ODIN_OS == .Windows {
 	foreign import lib "system:NtDll.lib"
 	
 	@(private="file")
-	@(default_calling_convention="stdcall")
+	@(default_calling_convention="system")
 	foreign lib {
 		RtlMoveMemory :: proc(dst, s: rawptr, length: int) ---
 		RtlFillMemory :: proc(dst: rawptr, length: int, fill: i32) ---

core/runtime/procs_windows_amd64.odin

@@ -1,11 +1,12 @@
 //+private
+//+no-instrumentation
 package runtime
 
 foreign import kernel32 "system:Kernel32.lib"
 
 @(private)
 foreign kernel32 {
-	RaiseException :: proc "stdcall" (dwExceptionCode, dwExceptionFlags, nNumberOfArguments: u32, lpArguments: ^uint) -> ! ---
+	RaiseException :: proc "system" (dwExceptionCode, dwExceptionFlags, nNumberOfArguments: u32, lpArguments: ^uint) -> ! ---
 }
 
 windows_trap_array_bounds :: proc "contextless" () -> ! {

core/runtime/procs_windows_i386.odin

@@ -1,4 +1,5 @@
 //+private
+//+no-instrumentation
 package runtime
 
 @require foreign import "system:int64.lib"
@@ -12,7 +13,7 @@ windows_trap_array_bounds :: proc "contextless" () -> ! {
 	EXCEPTION_ARRAY_BOUNDS_EXCEEDED :: 0xC000008C
 
 	foreign kernel32 {
-		RaiseException :: proc "stdcall" (dwExceptionCode, dwExceptionFlags, nNumberOfArguments: DWORD, lpArguments: ^ULONG_PTR) -> ! ---
+		RaiseException :: proc "system" (dwExceptionCode, dwExceptionFlags, nNumberOfArguments: DWORD, lpArguments: ^ULONG_PTR) -> ! ---
 	}
 
 	RaiseException(EXCEPTION_ARRAY_BOUNDS_EXCEEDED, 0, 0, nil)

core/simd/x86/adx.odin

@@ -37,7 +37,7 @@ when ODIN_ARCH == .amd64 {
 	}
 }
 
-@(private, default_calling_convention="c")
+@(private, default_calling_convention="none")
 foreign _ {
 	@(link_name="llvm.x86.addcarry.32")
 	llvm_addcarry_u32  :: proc(a: u8, b: u32, c: u32) -> (u8, u32) ---

core/simd/x86/fxsr.odin

@@ -21,7 +21,7 @@ when ODIN_ARCH == .amd64 {
 	}
 }
 
-@(private, default_calling_convention="c")
+@(private, default_calling_convention="none")
 foreign _ {
 	@(link_name="llvm.x86.fxsave")
 	fxsave    :: proc(p: rawptr) ---

core/simd/x86/pclmulqdq.odin

@@ -1,12 +1,12 @@
 //+build i386, amd64
 package simd_x86
 
-@(require_results, enable_target_feature="pclmulqdq")
+@(require_results, enable_target_feature="pclmul")
 _mm_clmulepi64_si128 :: #force_inline proc "c" (a, b: __m128i, $IMM8: u8) -> __m128i {
 	return pclmulqdq(a, b, u8(IMM8))
 }
 
-@(private, default_calling_convention="c")
+@(private, default_calling_convention="none")
 foreign _ {
 	@(link_name="llvm.x86.pclmulqdq")
 	pclmulqdq :: proc(a, round_key: __m128i, #const imm8: u8) -> __m128i ---

core/simd/x86/rdtsc.odin

@@ -11,7 +11,7 @@ __rdtscp :: #force_inline proc "c" (aux: ^u32) -> u64 {
 	return rdtscp(aux)
 }
 
-@(private, default_calling_convention="c")
+@(private, default_calling_convention="none")
 foreign _ {
 	@(link_name="llvm.x86.rdtsc")
 	rdtsc  :: proc() -> u64 ---

core/simd/x86/sha.odin

@@ -30,7 +30,7 @@ _mm_sha256rnds2_epu32 :: #force_inline proc "c" (a, b, k: __m128i) -> __m128i {
 	return transmute(__m128i)sha256rnds2(transmute(i32x4)a, transmute(i32x4)b, transmute(i32x4)k)
 }
 
-@(private, default_calling_convention="c")
+@(private, default_calling_convention="none")
 foreign _ {
 	@(link_name="llvm.x86.sha1msg1")
 	sha1msg1    :: proc(a, b: i32x4) -> i32x4 ---

core/simd/x86/sse.odin

@@ -532,7 +532,7 @@ when ODIN_ARCH == .amd64 {
 }
 
 
-@(private, default_calling_convention="c")
+@(private, default_calling_convention="none")
 foreign _ {
 	@(link_name="llvm.x86.sse.add.ss")
 	addss       :: proc(a, b: __m128) -> __m128 ---

core/simd/x86/sse2.odin

@@ -1040,7 +1040,7 @@ when ODIN_ARCH == .amd64 {
 }
 
 
-@(private, default_calling_convention="c")
+@(private, default_calling_convention="none")
 foreign _ {
 	@(link_name="llvm.x86.sse2.pause")
 	pause      :: proc() ---

core/simd/x86/sse3.odin

@@ -49,7 +49,7 @@ _mm_moveldup_ps :: #force_inline proc "c" (a: __m128) -> __m128 {
 	return simd.shuffle(a, a, 0, 0, 2, 2)
 }
 
-@(private, default_calling_convention="c")
+@(private, default_calling_convention="none")
 foreign _ {
 	@(link_name = "llvm.x86.sse3.addsub.ps")
 	addsubps :: proc(a, b: __m128) -> __m128 ---

core/simd/x86/sse41.odin

@@ -291,7 +291,7 @@ when ODIN_ARCH == .amd64 {
 }
 
 
-@(private, default_calling_convention="c")
+@(private, default_calling_convention="none")
 foreign _ {
 	@(link_name = "llvm.x86.sse41.pblendvb")
 	pblendvb   :: proc(a, b: i8x16, mask: i8x16) -> i8x16 ---

core/simd/x86/sse42.odin

@@ -104,7 +104,7 @@ when ODIN_ARCH == .amd64 {
 	}
 }
 
-@(private, default_calling_convention="c")
+@(private, default_calling_convention="none")
 foreign _ {
 	// SSE 4.2 string and text comparison ops
 	@(link_name="llvm.x86.sse42.pcmpestrm128")

core/simd/x86/ssse3.odin

@@ -105,7 +105,7 @@ _mm_sign_epi32 :: #force_inline proc "c" (a, b: __m128i) -> __m128i {
 
 
 
-@(private, default_calling_convention="c")
+@(private, default_calling_convention="none")
 foreign _ {
 	@(link_name = "llvm.x86.ssse3.pabs.b.128")
 	pabsb128     :: proc(a: i8x16) -> u8x16 ---

core/slice/sort.odin

@@ -62,7 +62,7 @@ _sort_by_indices :: proc(data, sorted: $T/[]$E, indices: []int) {
 
 sort_by_indices_overwrite :: proc(data: $T/[]$E, indices: []int) {
 	assert(len(data) == len(indices))
-	temp := make([]int, len(data), context.allocator)
+	temp := make([]E, len(data), context.allocator)
 	defer delete(temp)
 	for v, i in indices {
 		temp[i] = data[v]

core/strings/strings.odin

@@ -1792,7 +1792,8 @@ last_index_any :: proc(s, chars: string) -> (res: int) {
 		if r >= utf8.RUNE_SELF {
 			r = utf8.RUNE_ERROR
 		}
-		return index_rune(chars, r)
+		i := index_rune(chars, r)
+		return i if i < 0 else 0
 	}
 	
 	if len(s) > 8 {

core/sync/futex_windows.odin

@@ -5,14 +5,14 @@ package sync
 import "core:time"
 
 foreign import Synchronization "system:Synchronization.lib"
-@(default_calling_convention="stdcall")
+@(default_calling_convention="system")
 foreign Synchronization {
 	WakeByAddressSingle :: proc(Address: rawptr) ---
 	WakeByAddressAll    :: proc(Address: rawptr) ---
 }
 
 foreign import Ntdll "system:Ntdll.lib"
-@(default_calling_convention="stdcall")
+@(default_calling_convention="system")
 foreign Ntdll {
 	RtlWaitOnAddress :: proc(Address: rawptr, CompareAddress: rawptr, AddressSize: uint, Timeout: ^i64) -> i32 ---
 	RtlNtStatusToDosError :: proc(status: i32) -> u32 ---
@@ -30,7 +30,7 @@ foreign Ntdll {
 
 	GODDAMN MICROSOFT!
 */
-CustomWaitOnAddress :: proc "stdcall" (Address: rawptr, CompareAddress: rawptr, AddressSize: uint, Timeout: ^i64) -> bool {
+CustomWaitOnAddress :: proc "system" (Address: rawptr, CompareAddress: rawptr, AddressSize: uint, Timeout: ^i64) -> bool {
 	status := RtlWaitOnAddress(Address, CompareAddress, AddressSize, Timeout)
 	if status != 0 {
 		SetLastError(RtlNtStatusToDosError(status))

core/sys/info/cpu_intel.odin

@@ -37,11 +37,11 @@ cpu_name:     Maybe(string)
 
 @(init, private)
 init_cpu_features :: proc "c" () {
-	is_set :: #force_inline proc "c" (hwc: u32, value: u32) -> bool {
-		return hwc&(1 << value) != 0
+	is_set :: #force_inline proc "c" (bit: u32, value: u32) -> bool {
+		return (value>>bit) & 0x1 != 0
 	}
-	try_set :: #force_inline proc "c" (set: ^CPU_Features, feature: CPU_Feature, hwc: u32, value: u32) {
-		if is_set(hwc, value) {
+	try_set :: #force_inline proc "c" (set: ^CPU_Features, feature: CPU_Feature, bit: u32, value: u32) {
+		if is_set(bit, value) {
 			set^ += {feature}
 		}
 	}

core/sys/info/platform_darwin.odin

@@ -138,338 +138,388 @@ Darwin_To_Release :: struct {
 @(private)
 macos_release_map: map[string]Darwin_To_Release = {
 	// MacOS Tiger
-	"8A428"   = {{8, 0, 0},   "macOS", {"Tiger",         {10,  4, 0}}},
-	"8A432"   = {{8, 0, 0},   "macOS", {"Tiger",         {10,  4, 0}}},
-	"8B15"    = {{8, 1, 0},   "macOS", {"Tiger",         {10,  4, 1}}},
-	"8B17"    = {{8, 1, 0},   "macOS", {"Tiger",         {10,  4, 1}}},
-	"8C46"    = {{8, 2, 0},   "macOS", {"Tiger",         {10,  4, 2}}},
-	"8C47"    = {{8, 2, 0},   "macOS", {"Tiger",         {10,  4, 2}}},
-	"8E102"   = {{8, 2, 0},   "macOS", {"Tiger",         {10,  4, 2}}},
-	"8E45"    = {{8, 2, 0},   "macOS", {"Tiger",         {10,  4, 2}}},
-	"8E90"    = {{8, 2, 0},   "macOS", {"Tiger",         {10,  4, 2}}},
-	"8F46"    = {{8, 3, 0},   "macOS", {"Tiger",         {10,  4, 3}}},
-	"8G32"    = {{8, 4, 0},   "macOS", {"Tiger",         {10,  4, 4}}},
-	"8G1165"  = {{8, 4, 0},   "macOS", {"Tiger",         {10,  4, 4}}},
-	"8H14"    = {{8, 5, 0},   "macOS", {"Tiger",         {10,  4, 5}}},
-	"8G1454"  = {{8, 5, 0},   "macOS", {"Tiger",         {10,  4, 5}}},
-	"8I127"   = {{8, 6, 0},   "macOS", {"Tiger",         {10,  4, 6}}},
-	"8I1119"  = {{8, 6, 0},   "macOS", {"Tiger",         {10,  4, 6}}},
-	"8J135"   = {{8, 7, 0},   "macOS", {"Tiger",         {10,  4, 7}}},
-	"8J2135a" = {{8, 7, 0},   "macOS", {"Tiger",         {10,  4, 7}}},
-	"8K1079"  = {{8, 7, 0},   "macOS", {"Tiger",         {10,  4, 7}}},
-	"8N5107"  = {{8, 7, 0},   "macOS", {"Tiger",         {10,  4, 7}}},
-	"8L127"   = {{8, 8, 0},   "macOS", {"Tiger",         {10,  4, 8}}},
-	"8L2127"  = {{8, 8, 0},   "macOS", {"Tiger",         {10,  4, 8}}},
-	"8P135"   = {{8, 9, 0},   "macOS", {"Tiger",         {10,  4, 9}}},
-	"8P2137"  = {{8, 9, 0},   "macOS", {"Tiger",         {10,  4, 9}}},
-	"8R218"   = {{8, 10, 0},  "macOS", {"Tiger",         {10,  4, 10}}},
-	"8R2218"  = {{8, 10, 0},  "macOS", {"Tiger",         {10,  4, 10}}},
-	"8R2232"  = {{8, 10, 0},  "macOS", {"Tiger",         {10,  4, 10}}},
-	"8S165"   = {{8, 11, 0},  "macOS", {"Tiger",         {10,  4, 11}}},
-	"8S2167"  = {{8, 11, 0},  "macOS", {"Tiger",         {10,  4, 11}}},
+	"8A428"      = {{8, 0, 0},   "macOS", {"Tiger",         {10,  4, 0}}},
+	"8A432"      = {{8, 0, 0},   "macOS", {"Tiger",         {10,  4, 0}}},
+	"8B15"       = {{8, 1, 0},   "macOS", {"Tiger",         {10,  4, 1}}},
+	"8B17"       = {{8, 1, 0},   "macOS", {"Tiger",         {10,  4, 1}}},
+	"8C46"       = {{8, 2, 0},   "macOS", {"Tiger",         {10,  4, 2}}},
+	"8C47"       = {{8, 2, 0},   "macOS", {"Tiger",         {10,  4, 2}}},
+	"8E102"      = {{8, 2, 0},   "macOS", {"Tiger",         {10,  4, 2}}},
+	"8E45"       = {{8, 2, 0},   "macOS", {"Tiger",         {10,  4, 2}}},
+	"8E90"       = {{8, 2, 0},   "macOS", {"Tiger",         {10,  4, 2}}},
+	"8F46"       = {{8, 3, 0},   "macOS", {"Tiger",         {10,  4, 3}}},
+	"8G32"       = {{8, 4, 0},   "macOS", {"Tiger",         {10,  4, 4}}},
+	"8G1165"     = {{8, 4, 0},   "macOS", {"Tiger",         {10,  4, 4}}},
+	"8H14"       = {{8, 5, 0},   "macOS", {"Tiger",         {10,  4, 5}}},
+	"8G1454"     = {{8, 5, 0},   "macOS", {"Tiger",         {10,  4, 5}}},
+	"8I127"      = {{8, 6, 0},   "macOS", {"Tiger",         {10,  4, 6}}},
+	"8I1119"     = {{8, 6, 0},   "macOS", {"Tiger",         {10,  4, 6}}},
+	"8J135"      = {{8, 7, 0},   "macOS", {"Tiger",         {10,  4, 7}}},
+	"8J2135a"    = {{8, 7, 0},   "macOS", {"Tiger",         {10,  4, 7}}},
+	"8K1079"     = {{8, 7, 0},   "macOS", {"Tiger",         {10,  4, 7}}},
+	"8N5107"     = {{8, 7, 0},   "macOS", {"Tiger",         {10,  4, 7}}},
+	"8L127"      = {{8, 8, 0},   "macOS", {"Tiger",         {10,  4, 8}}},
+	"8L2127"     = {{8, 8, 0},   "macOS", {"Tiger",         {10,  4, 8}}},
+	"8P135"      = {{8, 9, 0},   "macOS", {"Tiger",         {10,  4, 9}}},
+	"8P2137"     = {{8, 9, 0},   "macOS", {"Tiger",         {10,  4, 9}}},
+	"8R218"      = {{8, 10, 0},  "macOS", {"Tiger",         {10,  4, 10}}},
+	"8R2218"     = {{8, 10, 0},  "macOS", {"Tiger",         {10,  4, 10}}},
+	"8R2232"     = {{8, 10, 0},  "macOS", {"Tiger",         {10,  4, 10}}},
+	"8S165"      = {{8, 11, 0},  "macOS", {"Tiger",         {10,  4, 11}}},
+	"8S2167"     = {{8, 11, 0},  "macOS", {"Tiger",         {10,  4, 11}}},
 
 	// MacOS Leopard
-	"9A581"   = {{9, 0, 0},   "macOS", {"Leopard",       {10,  5, 0}}},
-	"9B18"    = {{9, 1, 0},   "macOS", {"Leopard",       {10,  5, 1}}},
-	"9B2117"  = {{9, 1, 1},   "macOS", {"Leopard",       {10,  5, 1}}},
-	"9C31"    = {{9, 2, 0},   "macOS", {"Leopard",       {10,  5, 2}}},
-	"9C7010"  = {{9, 2, 0},   "macOS", {"Leopard",       {10,  5, 2}}},
-	"9D34"    = {{9, 3, 0},   "macOS", {"Leopard",       {10,  5, 3}}},
-	"9E17"    = {{9, 4, 0},   "macOS", {"Leopard",       {10,  5, 4}}},
-	"9F33"    = {{9, 5, 0},   "macOS", {"Leopard",       {10,  5, 5}}},
-	"9G55"    = {{9, 6, 0},   "macOS", {"Leopard",       {10,  5, 6}}},
-	"9G66"    = {{9, 6, 0},   "macOS", {"Leopard",       {10,  5, 6}}},
-	"9G71"    = {{9, 6, 0},   "macOS", {"Leopard",       {10,  5, 6}}},
-	"9J61"    = {{9, 7, 0},   "macOS", {"Leopard",       {10,  5, 7}}},
-	"9L30"    = {{9, 8, 0},   "macOS", {"Leopard",       {10,  5, 8}}},
-	"9L34"    = {{9, 8, 0},   "macOS", {"Leopard",       {10,  5, 8}}},
+	"9A581"      = {{9, 0, 0},   "macOS", {"Leopard",       {10,  5, 0}}},
+	"9B18"       = {{9, 1, 0},   "macOS", {"Leopard",       {10,  5, 1}}},
+	"9B2117"     = {{9, 1, 1},   "macOS", {"Leopard",       {10,  5, 1}}},
+	"9C31"       = {{9, 2, 0},   "macOS", {"Leopard",       {10,  5, 2}}},
+	"9C7010"     = {{9, 2, 0},   "macOS", {"Leopard",       {10,  5, 2}}},
+	"9D34"       = {{9, 3, 0},   "macOS", {"Leopard",       {10,  5, 3}}},
+	"9E17"       = {{9, 4, 0},   "macOS", {"Leopard",       {10,  5, 4}}},
+	"9F33"       = {{9, 5, 0},   "macOS", {"Leopard",       {10,  5, 5}}},
+	"9G55"       = {{9, 6, 0},   "macOS", {"Leopard",       {10,  5, 6}}},
+	"9G66"       = {{9, 6, 0},   "macOS", {"Leopard",       {10,  5, 6}}},
+	"9G71"       = {{9, 6, 0},   "macOS", {"Leopard",       {10,  5, 6}}},
+	"9J61"       = {{9, 7, 0},   "macOS", {"Leopard",       {10,  5, 7}}},
+	"9L30"       = {{9, 8, 0},   "macOS", {"Leopard",       {10,  5, 8}}},
+	"9L34"       = {{9, 8, 0},   "macOS", {"Leopard",       {10,  5, 8}}},
 
 	// MacOS Snow Leopard
-	"10A432"  = {{10, 0, 0},  "macOS", {"Snow Leopard",  {10,  6, 0}}},
-	"10A433"  = {{10, 0, 0},  "macOS", {"Snow Leopard",  {10,  6, 0}}},
-	"10B504"  = {{10, 1, 0},  "macOS", {"Snow Leopard",  {10,  6, 1}}},
-	"10C540"  = {{10, 2, 0},  "macOS", {"Snow Leopard",  {10,  6, 2}}},
-	"10D573"  = {{10, 3, 0},  "macOS", {"Snow Leopard",  {10,  6, 3}}},
-	"10D575"  = {{10, 3, 0},  "macOS", {"Snow Leopard",  {10,  6, 3}}},
-	"10D578"  = {{10, 3, 0},  "macOS", {"Snow Leopard",  {10,  6, 3}}},
-	"10F569"  = {{10, 4, 0},  "macOS", {"Snow Leopard",  {10,  6, 4}}},
-	"10H574"  = {{10, 5, 0},  "macOS", {"Snow Leopard",  {10,  6, 5}}},
-	"10J567"  = {{10, 6, 0},  "macOS", {"Snow Leopard",  {10,  6, 6}}},
-	"10J869"  = {{10, 7, 0},  "macOS", {"Snow Leopard",  {10,  6, 7}}},
-	"10J3250" = {{10, 7, 0},  "macOS", {"Snow Leopard",  {10,  6, 7}}},
-	"10J4138" = {{10, 7, 0},  "macOS", {"Snow Leopard",  {10,  6, 7}}},
-	"10K540"  = {{10, 8, 0},  "macOS", {"Snow Leopard",  {10,  6, 8}}},
-	"10K549"  = {{10, 8, 0},  "macOS", {"Snow Leopard",  {10,  6, 8}}},
+	"10A432"     = {{10, 0, 0},  "macOS", {"Snow Leopard",  {10,  6, 0}}},
+	"10A433"     = {{10, 0, 0},  "macOS", {"Snow Leopard",  {10,  6, 0}}},
+	"10B504"     = {{10, 1, 0},  "macOS", {"Snow Leopard",  {10,  6, 1}}},
+	"10C540"     = {{10, 2, 0},  "macOS", {"Snow Leopard",  {10,  6, 2}}},
+	"10D573"     = {{10, 3, 0},  "macOS", {"Snow Leopard",  {10,  6, 3}}},
+	"10D575"     = {{10, 3, 0},  "macOS", {"Snow Leopard",  {10,  6, 3}}},
+	"10D578"     = {{10, 3, 0},  "macOS", {"Snow Leopard",  {10,  6, 3}}},
+	"10F569"     = {{10, 4, 0},  "macOS", {"Snow Leopard",  {10,  6, 4}}},
+	"10H574"     = {{10, 5, 0},  "macOS", {"Snow Leopard",  {10,  6, 5}}},
+	"10J567"     = {{10, 6, 0},  "macOS", {"Snow Leopard",  {10,  6, 6}}},
+	"10J869"     = {{10, 7, 0},  "macOS", {"Snow Leopard",  {10,  6, 7}}},
+	"10J3250"    = {{10, 7, 0},  "macOS", {"Snow Leopard",  {10,  6, 7}}},
+	"10J4138"    = {{10, 7, 0},  "macOS", {"Snow Leopard",  {10,  6, 7}}},
+	"10K540"     = {{10, 8, 0},  "macOS", {"Snow Leopard",  {10,  6, 8}}},
+	"10K549"     = {{10, 8, 0},  "macOS", {"Snow Leopard",  {10,  6, 8}}},
 
 	// MacOS Lion
-	"11A511"  = {{11, 0, 0},  "macOS", {"Lion",          {10,  7, 0}}},
-	"11A511s" = {{11, 0, 0},  "macOS", {"Lion",          {10,  7, 0}}},
-	"11A2061" = {{11, 0, 2},  "macOS", {"Lion",          {10,  7, 0}}},
-	"11A2063" = {{11, 0, 2},  "macOS", {"Lion",          {10,  7, 0}}},
-	"11B26"   = {{11, 1, 0},  "macOS", {"Lion",          {10,  7, 1}}},
-	"11B2118" = {{11, 1, 0},  "macOS", {"Lion",          {10,  7, 1}}},
-	"11C74"   = {{11, 2, 0},  "macOS", {"Lion",          {10,  7, 2}}},
-	"11D50"   = {{11, 3, 0},  "macOS", {"Lion",          {10,  7, 3}}},
-	"11E53"   = {{11, 4, 0},  "macOS", {"Lion",          {10,  7, 4}}},
-	"11G56"   = {{11, 4, 2},  "macOS", {"Lion",          {10,  7, 5}}},
-	"11G63"   = {{11, 4, 2},  "macOS", {"Lion",          {10,  7, 5}}},
+	"11A511"     = {{11, 0, 0},  "macOS", {"Lion",          {10,  7, 0}}},
+	"11A511s"    = {{11, 0, 0},  "macOS", {"Lion",          {10,  7, 0}}},
+	"11A2061"    = {{11, 0, 2},  "macOS", {"Lion",          {10,  7, 0}}},
+	"11A2063"    = {{11, 0, 2},  "macOS", {"Lion",          {10,  7, 0}}},
+	"11B26"      = {{11, 1, 0},  "macOS", {"Lion",          {10,  7, 1}}},
+	"11B2118"    = {{11, 1, 0},  "macOS", {"Lion",          {10,  7, 1}}},
+	"11C74"      = {{11, 2, 0},  "macOS", {"Lion",          {10,  7, 2}}},
+	"11D50"      = {{11, 3, 0},  "macOS", {"Lion",          {10,  7, 3}}},
+	"11E53"      = {{11, 4, 0},  "macOS", {"Lion",          {10,  7, 4}}},
+	"11G56"      = {{11, 4, 2},  "macOS", {"Lion",          {10,  7, 5}}},
+	"11G63"      = {{11, 4, 2},  "macOS", {"Lion",          {10,  7, 5}}},
 
 	// MacOS Mountain Lion
-	"12A269"  = {{12, 0, 0},  "macOS", {"Mountain Lion", {10,  8, 0}}},
-	"12B19"   = {{12, 1, 0},  "macOS", {"Mountain Lion", {10,  8, 1}}},
-	"12C54"   = {{12, 2, 0},  "macOS", {"Mountain Lion", {10,  8, 2}}},
-	"12C60"   = {{12, 2, 0},  "macOS", {"Mountain Lion", {10,  8, 2}}},
-	"12C2034" = {{12, 2, 0},  "macOS", {"Mountain Lion", {10,  8, 2}}},
-	"12C3104" = {{12, 2, 0},  "macOS", {"Mountain Lion", {10,  8, 2}}},
-	"12D78"   = {{12, 3, 0},  "macOS", {"Mountain Lion", {10,  8, 3}}},
-	"12E55"   = {{12, 4, 0},  "macOS", {"Mountain Lion", {10,  8, 4}}},
-	"12E3067" = {{12, 4, 0},  "macOS", {"Mountain Lion", {10,  8, 4}}},
-	"12E4022" = {{12, 4, 0},  "macOS", {"Mountain Lion", {10,  8, 4}}},
-	"12F37"   = {{12, 5, 0},  "macOS", {"Mountain Lion", {10,  8, 5}}},
-	"12F45"   = {{12, 5, 0},  "macOS", {"Mountain Lion", {10,  8, 5}}},
-	"12F2501" = {{12, 5, 0},  "macOS", {"Mountain Lion", {10,  8, 5}}},
-	"12F2518" = {{12, 5, 0},  "macOS", {"Mountain Lion", {10,  8, 5}}},
-	"12F2542" = {{12, 5, 0},  "macOS", {"Mountain Lion", {10,  8, 5}}},
-	"12F2560" = {{12, 5, 0},  "macOS", {"Mountain Lion", {10,  8, 5}}},
+	"12A269"     = {{12, 0, 0},  "macOS", {"Mountain Lion", {10,  8, 0}}},
+	"12B19"      = {{12, 1, 0},  "macOS", {"Mountain Lion", {10,  8, 1}}},
+	"12C54"      = {{12, 2, 0},  "macOS", {"Mountain Lion", {10,  8, 2}}},
+	"12C60"      = {{12, 2, 0},  "macOS", {"Mountain Lion", {10,  8, 2}}},
+	"12C2034"    = {{12, 2, 0},  "macOS", {"Mountain Lion", {10,  8, 2}}},
+	"12C3104"    = {{12, 2, 0},  "macOS", {"Mountain Lion", {10,  8, 2}}},
+	"12D78"      = {{12, 3, 0},  "macOS", {"Mountain Lion", {10,  8, 3}}},
+	"12E55"      = {{12, 4, 0},  "macOS", {"Mountain Lion", {10,  8, 4}}},
+	"12E3067"    = {{12, 4, 0},  "macOS", {"Mountain Lion", {10,  8, 4}}},
+	"12E4022"    = {{12, 4, 0},  "macOS", {"Mountain Lion", {10,  8, 4}}},
+	"12F37"      = {{12, 5, 0},  "macOS", {"Mountain Lion", {10,  8, 5}}},
+	"12F45"      = {{12, 5, 0},  "macOS", {"Mountain Lion", {10,  8, 5}}},
+	"12F2501"    = {{12, 5, 0},  "macOS", {"Mountain Lion", {10,  8, 5}}},
+	"12F2518"    = {{12, 5, 0},  "macOS", {"Mountain Lion", {10,  8, 5}}},
+	"12F2542"    = {{12, 5, 0},  "macOS", {"Mountain Lion", {10,  8, 5}}},
+	"12F2560"    = {{12, 5, 0},  "macOS", {"Mountain Lion", {10,  8, 5}}},
 
 	// MacOS Mavericks
-	"13A603"  = {{13, 0, 0},  "macOS", {"Mavericks",     {10,  9, 0}}},
-	"13B42"   = {{13, 0, 0},  "macOS", {"Mavericks",     {10,  9, 1}}},
-	"13C64"   = {{13, 1, 0},  "macOS", {"Mavericks",     {10,  9, 2}}},
-	"13C1021" = {{13, 1, 0},  "macOS", {"Mavericks",     {10,  9, 2}}},
-	"13D65"   = {{13, 2, 0},  "macOS", {"Mavericks",     {10,  9, 3}}},
-	"13E28"   = {{13, 3, 0},  "macOS", {"Mavericks",     {10,  9, 4}}},
-	"13F34"   = {{13, 4, 0},  "macOS", {"Mavericks",     {10,  9, 5}}},
-	"13F1066" = {{13, 4, 0},  "macOS", {"Mavericks",     {10,  9, 5}}},
-	"13F1077" = {{13, 4, 0},  "macOS", {"Mavericks",     {10,  9, 5}}},
-	"13F1096" = {{13, 4, 0},  "macOS", {"Mavericks",     {10,  9, 5}}},
-	"13F1112" = {{13, 4, 0},  "macOS", {"Mavericks",     {10,  9, 5}}},
-	"13F1134" = {{13, 4, 0},  "macOS", {"Mavericks",     {10,  9, 5}}},
-	"13F1507" = {{13, 4, 0},  "macOS", {"Mavericks",     {10,  9, 5}}},
-	"13F1603" = {{13, 4, 0},  "macOS", {"Mavericks",     {10,  9, 5}}},
-	"13F1712" = {{13, 4, 0},  "macOS", {"Mavericks",     {10,  9, 5}}},
-	"13F1808" = {{13, 4, 0},  "macOS", {"Mavericks",     {10,  9, 5}}},
-	"13F1911" = {{13, 4, 0},  "macOS", {"Mavericks",     {10,  9, 5}}},
+	"13A603"     = {{13, 0, 0},  "macOS", {"Mavericks",     {10,  9, 0}}},
+	"13B42"      = {{13, 0, 0},  "macOS", {"Mavericks",     {10,  9, 1}}},
+	"13C64"      = {{13, 1, 0},  "macOS", {"Mavericks",     {10,  9, 2}}},
+	"13C1021"    = {{13, 1, 0},  "macOS", {"Mavericks",     {10,  9, 2}}},
+	"13D65"      = {{13, 2, 0},  "macOS", {"Mavericks",     {10,  9, 3}}},
+	"13E28"      = {{13, 3, 0},  "macOS", {"Mavericks",     {10,  9, 4}}},
+	"13F34"      = {{13, 4, 0},  "macOS", {"Mavericks",     {10,  9, 5}}},
+	"13F1066"    = {{13, 4, 0},  "macOS", {"Mavericks",     {10,  9, 5}}},
+	"13F1077"    = {{13, 4, 0},  "macOS", {"Mavericks",     {10,  9, 5}}},
+	"13F1096"    = {{13, 4, 0},  "macOS", {"Mavericks",     {10,  9, 5}}},
+	"13F1112"    = {{13, 4, 0},  "macOS", {"Mavericks",     {10,  9, 5}}},
+	"13F1134"    = {{13, 4, 0},  "macOS", {"Mavericks",     {10,  9, 5}}},
+	"13F1507"    = {{13, 4, 0},  "macOS", {"Mavericks",     {10,  9, 5}}},
+	"13F1603"    = {{13, 4, 0},  "macOS", {"Mavericks",     {10,  9, 5}}},
+	"13F1712"    = {{13, 4, 0},  "macOS", {"Mavericks",     {10,  9, 5}}},
+	"13F1808"    = {{13, 4, 0},  "macOS", {"Mavericks",     {10,  9, 5}}},
+	"13F1911"    = {{13, 4, 0},  "macOS", {"Mavericks",     {10,  9, 5}}},
 
 	// MacOS Yosemite
-	"14A389"  = {{14, 0, 0},  "macOS", {"Yosemite",      {10, 10, 0}}},
-	"14B25"   = {{14, 0, 0},  "macOS", {"Yosemite",      {10, 10, 1}}},
-	"14C109"  = {{14, 1, 0},  "macOS", {"Yosemite",      {10, 10, 2}}},
-	"14C1510" = {{14, 1, 0},  "macOS", {"Yosemite",      {10, 10, 2}}},
-	"14C2043" = {{14, 1, 0},  "macOS", {"Yosemite",      {10, 10, 2}}},
-	"14C1514" = {{14, 1, 0},  "macOS", {"Yosemite",      {10, 10, 2}}},
-	"14C2513" = {{14, 1, 0},  "macOS", {"Yosemite",      {10, 10, 2}}},
-	"14D131"  = {{14, 3, 0},  "macOS", {"Yosemite",      {10, 10, 3}}},
-	"14D136"  = {{14, 3, 0},  "macOS", {"Yosemite",      {10, 10, 3}}},
-	"14E46"   = {{14, 4, 0},  "macOS", {"Yosemite",      {10, 10, 4}}},
-	"14F27"   = {{14, 5, 0},  "macOS", {"Yosemite",      {10, 10, 5}}},
-	"14F1021" = {{14, 5, 0},  "macOS", {"Yosemite",      {10, 10, 5}}},
-	"14F1505" = {{14, 5, 0},  "macOS", {"Yosemite",      {10, 10, 5}}},
-	"14F1509" = {{14, 5, 0},  "macOS", {"Yosemite",      {10, 10, 5}}},
-	"14F1605" = {{14, 5, 0},  "macOS", {"Yosemite",      {10, 10, 5}}},
-	"14F1713" = {{14, 5, 0},  "macOS", {"Yosemite",      {10, 10, 5}}},
-	"14F1808" = {{14, 5, 0},  "macOS", {"Yosemite",      {10, 10, 5}}},
-	"14F1909" = {{14, 5, 0},  "macOS", {"Yosemite",      {10, 10, 5}}},
-	"14F1912" = {{14, 5, 0},  "macOS", {"Yosemite",      {10, 10, 5}}},
-	"14F2009" = {{14, 5, 0},  "macOS", {"Yosemite",      {10, 10, 5}}},
-	"14F2109" = {{14, 5, 0},  "macOS", {"Yosemite",      {10, 10, 5}}},
-	"14F2315" = {{14, 5, 0},  "macOS", {"Yosemite",      {10, 10, 5}}},
-	"14F2411" = {{14, 5, 0},  "macOS", {"Yosemite",      {10, 10, 5}}},
-	"14F2511" = {{14, 5, 0},  "macOS", {"Yosemite",      {10, 10, 5}}},
+	"14A389"     = {{14, 0, 0},  "macOS", {"Yosemite",      {10, 10, 0}}},
+	"14B25"      = {{14, 0, 0},  "macOS", {"Yosemite",      {10, 10, 1}}},
+	"14C109"     = {{14, 1, 0},  "macOS", {"Yosemite",      {10, 10, 2}}},
+	"14C1510"    = {{14, 1, 0},  "macOS", {"Yosemite",      {10, 10, 2}}},
+	"14C2043"    = {{14, 1, 0},  "macOS", {"Yosemite",      {10, 10, 2}}},
+	"14C1514"    = {{14, 1, 0},  "macOS", {"Yosemite",      {10, 10, 2}}},
+	"14C2513"    = {{14, 1, 0},  "macOS", {"Yosemite",      {10, 10, 2}}},
+	"14D131"     = {{14, 3, 0},  "macOS", {"Yosemite",      {10, 10, 3}}},
+	"14D136"     = {{14, 3, 0},  "macOS", {"Yosemite",      {10, 10, 3}}},
+	"14E46"      = {{14, 4, 0},  "macOS", {"Yosemite",      {10, 10, 4}}},
+	"14F27"      = {{14, 5, 0},  "macOS", {"Yosemite",      {10, 10, 5}}},
+	"14F1021"    = {{14, 5, 0},  "macOS", {"Yosemite",      {10, 10, 5}}},
+	"14F1505"    = {{14, 5, 0},  "macOS", {"Yosemite",      {10, 10, 5}}},
+	"14F1509"    = {{14, 5, 0},  "macOS", {"Yosemite",      {10, 10, 5}}},
+	"14F1605"    = {{14, 5, 0},  "macOS", {"Yosemite",      {10, 10, 5}}},
+	"14F1713"    = {{14, 5, 0},  "macOS", {"Yosemite",      {10, 10, 5}}},
+	"14F1808"    = {{14, 5, 0},  "macOS", {"Yosemite",      {10, 10, 5}}},
+	"14F1909"    = {{14, 5, 0},  "macOS", {"Yosemite",      {10, 10, 5}}},
+	"14F1912"    = {{14, 5, 0},  "macOS", {"Yosemite",      {10, 10, 5}}},
+	"14F2009"    = {{14, 5, 0},  "macOS", {"Yosemite",      {10, 10, 5}}},
+	"14F2109"    = {{14, 5, 0},  "macOS", {"Yosemite",      {10, 10, 5}}},
+	"14F2315"    = {{14, 5, 0},  "macOS", {"Yosemite",      {10, 10, 5}}},
+	"14F2411"    = {{14, 5, 0},  "macOS", {"Yosemite",      {10, 10, 5}}},
+	"14F2511"    = {{14, 5, 0},  "macOS", {"Yosemite",      {10, 10, 5}}},
 
 	// MacOS El Capitan
-	"15A284"   = {{15, 0, 0}, "macOS", {"El Capitan",    {10, 11, 0}}},
-	"15B42"    = {{15, 0, 0}, "macOS", {"El Capitan",    {10, 11, 1}}},
-	"15C50"    = {{15, 2, 0}, "macOS", {"El Capitan",    {10, 11, 2}}},
-	"15D21"    = {{15, 3, 0}, "macOS", {"El Capitan",    {10, 11, 3}}},
-	"15E65"    = {{15, 4, 0}, "macOS", {"El Capitan",    {10, 11, 4}}},
-	"15F34"    = {{15, 5, 0}, "macOS", {"El Capitan",    {10, 11, 5}}},
-	"15G31"    = {{15, 6, 0}, "macOS", {"El Capitan",    {10, 11, 6}}},
-	"15G1004"  = {{15, 6, 0}, "macOS", {"El Capitan",    {10, 11, 6}}},
-	"15G1011"  = {{15, 6, 0}, "macOS", {"El Capitan",    {10, 11, 6}}},
-	"15G1108"  = {{15, 6, 0}, "macOS", {"El Capitan",    {10, 11, 6}}},
-	"15G1212"  = {{15, 6, 0}, "macOS", {"El Capitan",    {10, 11, 6}}},
-	"15G1217"  = {{15, 6, 0}, "macOS", {"El Capitan",    {10, 11, 6}}},
-	"15G1421"  = {{15, 6, 0}, "macOS", {"El Capitan",    {10, 11, 6}}},
-	"15G1510"  = {{15, 6, 0}, "macOS", {"El Capitan",    {10, 11, 6}}},
-	"15G1611"  = {{15, 6, 0}, "macOS", {"El Capitan",    {10, 11, 6}}},
-	"15G17023" = {{15, 6, 0}, "macOS", {"El Capitan",    {10, 11, 6}}},
-	"15G18013" = {{15, 6, 0}, "macOS", {"El Capitan",    {10, 11, 6}}},
-	"15G19009" = {{15, 6, 0}, "macOS", {"El Capitan",    {10, 11, 6}}},
-	"15G20015" = {{15, 6, 0}, "macOS", {"El Capitan",    {10, 11, 6}}},
-	"15G21013" = {{15, 6, 0}, "macOS", {"El Capitan",    {10, 11, 6}}},
-	"15G22010" = {{15, 6, 0}, "macOS", {"El Capitan",    {10, 11, 6}}},
+	"15A284"     = {{15, 0, 0}, "macOS", {"El Capitan",     {10, 11, 0}}},
+	"15B42"      = {{15, 0, 0}, "macOS", {"El Capitan",     {10, 11, 1}}},
+	"15C50"      = {{15, 2, 0}, "macOS", {"El Capitan",     {10, 11, 2}}},
+	"15D21"      = {{15, 3, 0}, "macOS", {"El Capitan",     {10, 11, 3}}},
+	"15E65"      = {{15, 4, 0}, "macOS", {"El Capitan",     {10, 11, 4}}},
+	"15F34"      = {{15, 5, 0}, "macOS", {"El Capitan",     {10, 11, 5}}},
+	"15G31"      = {{15, 6, 0}, "macOS", {"El Capitan",     {10, 11, 6}}},
+	"15G1004"    = {{15, 6, 0}, "macOS", {"El Capitan",     {10, 11, 6}}},
+	"15G1011"    = {{15, 6, 0}, "macOS", {"El Capitan",     {10, 11, 6}}},
+	"15G1108"    = {{15, 6, 0}, "macOS", {"El Capitan",     {10, 11, 6}}},
+	"15G1212"    = {{15, 6, 0}, "macOS", {"El Capitan",     {10, 11, 6}}},
+	"15G1217"    = {{15, 6, 0}, "macOS", {"El Capitan",     {10, 11, 6}}},
+	"15G1421"    = {{15, 6, 0}, "macOS", {"El Capitan",     {10, 11, 6}}},
+	"15G1510"    = {{15, 6, 0}, "macOS", {"El Capitan",     {10, 11, 6}}},
+	"15G1611"    = {{15, 6, 0}, "macOS", {"El Capitan",     {10, 11, 6}}},
+	"15G17023"   = {{15, 6, 0}, "macOS", {"El Capitan",     {10, 11, 6}}},
+	"15G18013"   = {{15, 6, 0}, "macOS", {"El Capitan",     {10, 11, 6}}},
+	"15G19009"   = {{15, 6, 0}, "macOS", {"El Capitan",     {10, 11, 6}}},
+	"15G20015"   = {{15, 6, 0}, "macOS", {"El Capitan",     {10, 11, 6}}},
+	"15G21013"   = {{15, 6, 0}, "macOS", {"El Capitan",     {10, 11, 6}}},
+	"15G22010"   = {{15, 6, 0}, "macOS", {"El Capitan",     {10, 11, 6}}},
 
 	// MacOS Sierra
-	"16A323"   = {{16, 0, 0}, "macOS", {"Sierra",        {10, 12, 0}}},
-	"16B2555"  = {{16, 1, 0}, "macOS", {"Sierra",        {10, 12, 1}}},
-	"16B2657"  = {{16, 1, 0}, "macOS", {"Sierra",        {10, 12, 1}}},
-	"16C67"    = {{16, 3, 0}, "macOS", {"Sierra",        {10, 12, 2}}},
-	"16C68"    = {{16, 3, 0}, "macOS", {"Sierra",        {10, 12, 2}}},
-	"16D32"    = {{16, 4, 0}, "macOS", {"Sierra",        {10, 12, 3}}},
-	"16E195"   = {{16, 5, 0}, "macOS", {"Sierra",        {10, 12, 4}}},
-	"16F73"    = {{16, 6, 0}, "macOS", {"Sierra",        {10, 12, 5}}},
-	"16F2073"  = {{16, 6, 0}, "macOS", {"Sierra",        {10, 12, 5}}},
-	"16G29"    = {{16, 7, 0}, "macOS", {"Sierra",        {10, 12, 6}}},
-	"16G1036"  = {{16, 7, 0}, "macOS", {"Sierra",        {10, 12, 6}}},
-	"16G1114"  = {{16, 7, 0}, "macOS", {"Sierra",        {10, 12, 6}}},
-	"16G1212"  = {{16, 7, 0}, "macOS", {"Sierra",        {10, 12, 6}}},
-	"16G1314"  = {{16, 7, 0}, "macOS", {"Sierra",        {10, 12, 6}}},
-	"16G1408"  = {{16, 7, 0}, "macOS", {"Sierra",        {10, 12, 6}}},
-	"16G1510"  = {{16, 7, 0}, "macOS", {"Sierra",        {10, 12, 6}}},
-	"16G1618"  = {{16, 7, 0}, "macOS", {"Sierra",        {10, 12, 6}}},
-	"16G1710"  = {{16, 7, 0}, "macOS", {"Sierra",        {10, 12, 6}}},
-	"16G1815"  = {{16, 7, 0}, "macOS", {"Sierra",        {10, 12, 6}}},
-	"16G1917"  = {{16, 7, 0}, "macOS", {"Sierra",        {10, 12, 6}}},
-	"16G1918"  = {{16, 7, 0}, "macOS", {"Sierra",        {10, 12, 6}}},
-	"16G2016"  = {{16, 7, 0}, "macOS", {"Sierra",        {10, 12, 6}}},
-	"16G2127"  = {{16, 7, 0}, "macOS", {"Sierra",        {10, 12, 6}}},
-	"16G2128"  = {{16, 7, 0}, "macOS", {"Sierra",        {10, 12, 6}}},
-	"16G2136"  = {{16, 7, 0}, "macOS", {"Sierra",        {10, 12, 6}}},
+	"16A323"     = {{16, 0, 0}, "macOS", {"Sierra",         {10, 12, 0}}},
+	"16B2555"    = {{16, 1, 0}, "macOS", {"Sierra",         {10, 12, 1}}},
+	"16B2657"    = {{16, 1, 0}, "macOS", {"Sierra",         {10, 12, 1}}},
+	"16C67"      = {{16, 3, 0}, "macOS", {"Sierra",         {10, 12, 2}}},
+	"16C68"      = {{16, 3, 0}, "macOS", {"Sierra",         {10, 12, 2}}},
+	"16D32"      = {{16, 4, 0}, "macOS", {"Sierra",         {10, 12, 3}}},
+	"16E195"     = {{16, 5, 0}, "macOS", {"Sierra",         {10, 12, 4}}},
+	"16F73"      = {{16, 6, 0}, "macOS", {"Sierra",         {10, 12, 5}}},
+	"16F2073"    = {{16, 6, 0}, "macOS", {"Sierra",         {10, 12, 5}}},
+	"16G29"      = {{16, 7, 0}, "macOS", {"Sierra",         {10, 12, 6}}},
+	"16G1036"    = {{16, 7, 0}, "macOS", {"Sierra",         {10, 12, 6}}},
+	"16G1114"    = {{16, 7, 0}, "macOS", {"Sierra",         {10, 12, 6}}},
+	"16G1212"    = {{16, 7, 0}, "macOS", {"Sierra",         {10, 12, 6}}},
+	"16G1314"    = {{16, 7, 0}, "macOS", {"Sierra",         {10, 12, 6}}},
+	"16G1408"    = {{16, 7, 0}, "macOS", {"Sierra",         {10, 12, 6}}},
+	"16G1510"    = {{16, 7, 0}, "macOS", {"Sierra",         {10, 12, 6}}},
+	"16G1618"    = {{16, 7, 0}, "macOS", {"Sierra",         {10, 12, 6}}},
+	"16G1710"    = {{16, 7, 0}, "macOS", {"Sierra",         {10, 12, 6}}},
+	"16G1815"    = {{16, 7, 0}, "macOS", {"Sierra",         {10, 12, 6}}},
+	"16G1917"    = {{16, 7, 0}, "macOS", {"Sierra",         {10, 12, 6}}},
+	"16G1918"    = {{16, 7, 0}, "macOS", {"Sierra",         {10, 12, 6}}},
+	"16G2016"    = {{16, 7, 0}, "macOS", {"Sierra",         {10, 12, 6}}},
+	"16G2127"    = {{16, 7, 0}, "macOS", {"Sierra",         {10, 12, 6}}},
+	"16G2128"    = {{16, 7, 0}, "macOS", {"Sierra",         {10, 12, 6}}},
+	"16G2136"    = {{16, 7, 0}, "macOS", {"Sierra",         {10, 12, 6}}},
 
 	// MacOS High Sierra
-	"17A365"   = {{17, 0, 0}, "macOS", {"High Sierra",   {10, 13, 0}}},
-	"17A405"   = {{17, 0, 0}, "macOS", {"High Sierra",   {10, 13, 0}}},
-	"17B48"    = {{17, 2, 0}, "macOS", {"High Sierra",   {10, 13, 1}}},
-	"17B1002"  = {{17, 2, 0}, "macOS", {"High Sierra",   {10, 13, 1}}},
-	"17B1003"  = {{17, 2, 0}, "macOS", {"High Sierra",   {10, 13, 1}}},
-	"17C88"    = {{17, 3, 0}, "macOS", {"High Sierra",   {10, 13, 2}}},
-	"17C89"    = {{17, 3, 0}, "macOS", {"High Sierra",   {10, 13, 2}}},
-	"17C205"   = {{17, 3, 0}, "macOS", {"High Sierra",   {10, 13, 2}}},
-	"17C2205"  = {{17, 3, 0}, "macOS", {"High Sierra",   {10, 13, 2}}},
-	"17D47"    = {{17, 4, 0}, "macOS", {"High Sierra",   {10, 13, 3}}},
-	"17D2047"  = {{17, 4, 0}, "macOS", {"High Sierra",   {10, 13, 3}}},
-	"17D102"   = {{17, 4, 0}, "macOS", {"High Sierra",   {10, 13, 3}}},
-	"17D2102"  = {{17, 4, 0}, "macOS", {"High Sierra",   {10, 13, 3}}},
-	"17E199"   = {{17, 5, 0}, "macOS", {"High Sierra",   {10, 13, 4}}},
-	"17E202"   = {{17, 5, 0}, "macOS", {"High Sierra",   {10, 13, 4}}},
-	"17F77"    = {{17, 6, 0}, "macOS", {"High Sierra",   {10, 13, 5}}},
-	"17G65"    = {{17, 7, 0}, "macOS", {"High Sierra",   {10, 13, 6}}},
-	"17G2208"  = {{17, 7, 0}, "macOS", {"High Sierra",   {10, 13, 6}}},
-	"17G2307"  = {{17, 7, 0}, "macOS", {"High Sierra",   {10, 13, 6}}},
-	"17G3025"  = {{17, 7, 0}, "macOS", {"High Sierra",   {10, 13, 6}}},
-	"17G4015"  = {{17, 7, 0}, "macOS", {"High Sierra",   {10, 13, 6}}},
-	"17G5019"  = {{17, 7, 0}, "macOS", {"High Sierra",   {10, 13, 6}}},
-	"17G6029"  = {{17, 7, 0}, "macOS", {"High Sierra",   {10, 13, 6}}},
-	"17G6030"  = {{17, 7, 0}, "macOS", {"High Sierra",   {10, 13, 6}}},
-	"17G7024"  = {{17, 7, 0}, "macOS", {"High Sierra",   {10, 13, 6}}},
-	"17G8029"  = {{17, 7, 0}, "macOS", {"High Sierra",   {10, 13, 6}}},
-	"17G8030"  = {{17, 7, 0}, "macOS", {"High Sierra",   {10, 13, 6}}},
-	"17G8037"  = {{17, 7, 0}, "macOS", {"High Sierra",   {10, 13, 6}}},
-	"17G9016"  = {{17, 7, 0}, "macOS", {"High Sierra",   {10, 13, 6}}},
-	"17G10021" = {{17, 7, 0}, "macOS", {"High Sierra",   {10, 13, 6}}},
-	"17G11023" = {{17, 7, 0}, "macOS", {"High Sierra",   {10, 13, 6}}},
-	"17G12034" = {{17, 7, 0}, "macOS", {"High Sierra",   {10, 13, 6}}},
-	"17G13033" = {{17, 7, 0}, "macOS", {"High Sierra",   {10, 13, 6}}},
-	"17G13035" = {{17, 7, 0}, "macOS", {"High Sierra",   {10, 13, 6}}},
-	"17G14019" = {{17, 7, 0}, "macOS", {"High Sierra",   {10, 13, 6}}},
-	"17G14033" = {{17, 7, 0}, "macOS", {"High Sierra",   {10, 13, 6}}},
-	"17G14042" = {{17, 7, 0}, "macOS", {"High Sierra",   {10, 13, 6}}},
+	"17A365"     = {{17, 0, 0}, "macOS", {"High Sierra",    {10, 13, 0}}},
+	"17A405"     = {{17, 0, 0}, "macOS", {"High Sierra",    {10, 13, 0}}},
+	"17B48"      = {{17, 2, 0}, "macOS", {"High Sierra",    {10, 13, 1}}},
+	"17B1002"    = {{17, 2, 0}, "macOS", {"High Sierra",    {10, 13, 1}}},
+	"17B1003"    = {{17, 2, 0}, "macOS", {"High Sierra",    {10, 13, 1}}},
+	"17C88"      = {{17, 3, 0}, "macOS", {"High Sierra",    {10, 13, 2}}},
+	"17C89"      = {{17, 3, 0}, "macOS", {"High Sierra",    {10, 13, 2}}},
+	"17C205"     = {{17, 3, 0}, "macOS", {"High Sierra",    {10, 13, 2}}},
+	"17C2205"    = {{17, 3, 0}, "macOS", {"High Sierra",    {10, 13, 2}}},
+	"17D47"      = {{17, 4, 0}, "macOS", {"High Sierra",    {10, 13, 3}}},
+	"17D2047"    = {{17, 4, 0}, "macOS", {"High Sierra",    {10, 13, 3}}},
+	"17D102"     = {{17, 4, 0}, "macOS", {"High Sierra",    {10, 13, 3}}},
+	"17D2102"    = {{17, 4, 0}, "macOS", {"High Sierra",    {10, 13, 3}}},
+	"17E199"     = {{17, 5, 0}, "macOS", {"High Sierra",    {10, 13, 4}}},
+	"17E202"     = {{17, 5, 0}, "macOS", {"High Sierra",    {10, 13, 4}}},
+	"17F77"      = {{17, 6, 0}, "macOS", {"High Sierra",    {10, 13, 5}}},
+	"17G65"      = {{17, 7, 0}, "macOS", {"High Sierra",    {10, 13, 6}}},
+	"17G2208"    = {{17, 7, 0}, "macOS", {"High Sierra",    {10, 13, 6}}},
+	"17G2307"    = {{17, 7, 0}, "macOS", {"High Sierra",    {10, 13, 6}}},
+	"17G3025"    = {{17, 7, 0}, "macOS", {"High Sierra",    {10, 13, 6}}},
+	"17G4015"    = {{17, 7, 0}, "macOS", {"High Sierra",    {10, 13, 6}}},
+	"17G5019"    = {{17, 7, 0}, "macOS", {"High Sierra",    {10, 13, 6}}},
+	"17G6029"    = {{17, 7, 0}, "macOS", {"High Sierra",    {10, 13, 6}}},
+	"17G6030"    = {{17, 7, 0}, "macOS", {"High Sierra",    {10, 13, 6}}},
+	"17G7024"    = {{17, 7, 0}, "macOS", {"High Sierra",    {10, 13, 6}}},
+	"17G8029"    = {{17, 7, 0}, "macOS", {"High Sierra",    {10, 13, 6}}},
+	"17G8030"    = {{17, 7, 0}, "macOS", {"High Sierra",    {10, 13, 6}}},
+	"17G8037"    = {{17, 7, 0}, "macOS", {"High Sierra",    {10, 13, 6}}},
+	"17G9016"    = {{17, 7, 0}, "macOS", {"High Sierra",    {10, 13, 6}}},
+	"17G10021"   = {{17, 7, 0}, "macOS", {"High Sierra",    {10, 13, 6}}},
+	"17G11023"   = {{17, 7, 0}, "macOS", {"High Sierra",    {10, 13, 6}}},
+	"17G12034"   = {{17, 7, 0}, "macOS", {"High Sierra",    {10, 13, 6}}},
+	"17G13033"   = {{17, 7, 0}, "macOS", {"High Sierra",    {10, 13, 6}}},
+	"17G13035"   = {{17, 7, 0}, "macOS", {"High Sierra",    {10, 13, 6}}},
+	"17G14019"   = {{17, 7, 0}, "macOS", {"High Sierra",    {10, 13, 6}}},
+	"17G14033"   = {{17, 7, 0}, "macOS", {"High Sierra",    {10, 13, 6}}},
+	"17G14042"   = {{17, 7, 0}, "macOS", {"High Sierra",    {10, 13, 6}}},
 
 	// MacOS Mojave
-	"18A391"   = {{18, 0, 0}, "macOS", {"Mojave",        {10, 14, 0}}},
-	"18B75"    = {{18, 2, 0}, "macOS", {"Mojave",        {10, 14, 1}}},
-	"18B2107"  = {{18, 2, 0}, "macOS", {"Mojave",        {10, 14, 1}}},
-	"18B3094"  = {{18, 2, 0}, "macOS", {"Mojave",        {10, 14, 1}}},
-	"18C54"    = {{18, 2, 0}, "macOS", {"Mojave",        {10, 14, 2}}},
-	"18D42"    = {{18, 2, 0}, "macOS", {"Mojave",        {10, 14, 3}}},
-	"18D43"    = {{18, 2, 0}, "macOS", {"Mojave",        {10, 14, 3}}},
-	"18D109"   = {{18, 2, 0}, "macOS", {"Mojave",        {10, 14, 3}}},
-	"18E226"   = {{18, 5, 0}, "macOS", {"Mojave",        {10, 14, 4}}},
-	"18E227"   = {{18, 5, 0}, "macOS", {"Mojave",        {10, 14, 4}}},
-	"18F132"   = {{18, 6, 0}, "macOS", {"Mojave",        {10, 14, 5}}},
-	"18G84"    = {{18, 7, 0}, "macOS", {"Mojave",        {10, 14, 6}}},
-	"18G87"    = {{18, 7, 0}, "macOS", {"Mojave",        {10, 14, 6}}},
-	"18G95"    = {{18, 7, 0}, "macOS", {"Mojave",        {10, 14, 6}}},
-	"18G103"   = {{18, 7, 0}, "macOS", {"Mojave",        {10, 14, 6}}},
-	"18G1012"  = {{18, 7, 0}, "macOS", {"Mojave",        {10, 14, 6}}},
-	"18G2022"  = {{18, 7, 0}, "macOS", {"Mojave",        {10, 14, 6}}},
-	"18G3020"  = {{18, 7, 0}, "macOS", {"Mojave",        {10, 14, 6}}},
-	"18G4032"  = {{18, 7, 0}, "macOS", {"Mojave",        {10, 14, 6}}},
-	"18G5033"  = {{18, 7, 0}, "macOS", {"Mojave",        {10, 14, 6}}},
-	"18G6020"  = {{18, 7, 0}, "macOS", {"Mojave",        {10, 14, 6}}},
-	"18G6032"  = {{18, 7, 0}, "macOS", {"Mojave",        {10, 14, 6}}},
-	"18G6042"  = {{18, 7, 0}, "macOS", {"Mojave",        {10, 14, 6}}},
-	"18G7016"  = {{18, 7, 0}, "macOS", {"Mojave",        {10, 14, 6}}},
-	"18G8012"  = {{18, 7, 0}, "macOS", {"Mojave",        {10, 14, 6}}},
-	"18G8022"  = {{18, 7, 0}, "macOS", {"Mojave",        {10, 14, 6}}},
-	"18G9028"  = {{18, 7, 0}, "macOS", {"Mojave",        {10, 14, 6}}},
-	"18G9216"  = {{18, 7, 0}, "macOS", {"Mojave",        {10, 14, 6}}},
-	"18G9323"  = {{18, 7, 0}, "macOS", {"Mojave",        {10, 14, 6}}},
+	"18A391"     = {{18, 0, 0}, "macOS", {"Mojave",         {10, 14, 0}}},
+	"18B75"      = {{18, 2, 0}, "macOS", {"Mojave",         {10, 14, 1}}},
+	"18B2107"    = {{18, 2, 0}, "macOS", {"Mojave",         {10, 14, 1}}},
+	"18B3094"    = {{18, 2, 0}, "macOS", {"Mojave",         {10, 14, 1}}},
+	"18C54"      = {{18, 2, 0}, "macOS", {"Mojave",         {10, 14, 2}}},
+	"18D42"      = {{18, 2, 0}, "macOS", {"Mojave",         {10, 14, 3}}},
+	"18D43"      = {{18, 2, 0}, "macOS", {"Mojave",         {10, 14, 3}}},
+	"18D109"     = {{18, 2, 0}, "macOS", {"Mojave",         {10, 14, 3}}},
+	"18E226"     = {{18, 5, 0}, "macOS", {"Mojave",         {10, 14, 4}}},
+	"18E227"     = {{18, 5, 0}, "macOS", {"Mojave",         {10, 14, 4}}},
+	"18F132"     = {{18, 6, 0}, "macOS", {"Mojave",         {10, 14, 5}}},
+	"18G84"      = {{18, 7, 0}, "macOS", {"Mojave",         {10, 14, 6}}},
+	"18G87"      = {{18, 7, 0}, "macOS", {"Mojave",         {10, 14, 6}}},
+	"18G95"      = {{18, 7, 0}, "macOS", {"Mojave",         {10, 14, 6}}},
+	"18G103"     = {{18, 7, 0}, "macOS", {"Mojave",         {10, 14, 6}}},
+	"18G1012"    = {{18, 7, 0}, "macOS", {"Mojave",         {10, 14, 6}}},
+	"18G2022"    = {{18, 7, 0}, "macOS", {"Mojave",         {10, 14, 6}}},
+	"18G3020"    = {{18, 7, 0}, "macOS", {"Mojave",         {10, 14, 6}}},
+	"18G4032"    = {{18, 7, 0}, "macOS", {"Mojave",         {10, 14, 6}}},
+	"18G5033"    = {{18, 7, 0}, "macOS", {"Mojave",         {10, 14, 6}}},
+	"18G6020"    = {{18, 7, 0}, "macOS", {"Mojave",         {10, 14, 6}}},
+	"18G6032"    = {{18, 7, 0}, "macOS", {"Mojave",         {10, 14, 6}}},
+	"18G6042"    = {{18, 7, 0}, "macOS", {"Mojave",         {10, 14, 6}}},
+	"18G7016"    = {{18, 7, 0}, "macOS", {"Mojave",         {10, 14, 6}}},
+	"18G8012"    = {{18, 7, 0}, "macOS", {"Mojave",         {10, 14, 6}}},
+	"18G8022"    = {{18, 7, 0}, "macOS", {"Mojave",         {10, 14, 6}}},
+	"18G9028"    = {{18, 7, 0}, "macOS", {"Mojave",         {10, 14, 6}}},
+	"18G9216"    = {{18, 7, 0}, "macOS", {"Mojave",         {10, 14, 6}}},
+	"18G9323"    = {{18, 7, 0}, "macOS", {"Mojave",         {10, 14, 6}}},
 
 	// MacOS Catalina
-	"19A583"   = {{19, 0, 0}, "macOS", {"Catalina",      {10, 15, 0}}},
-	"19A602"   = {{19, 0, 0}, "macOS", {"Catalina",      {10, 15, 0}}},
-	"19A603"   = {{19, 0, 0}, "macOS", {"Catalina",      {10, 15, 0}}},
-	"19B88"    = {{19, 0, 0}, "macOS", {"Catalina",      {10, 15, 1}}},
-	"19C57"    = {{19, 2, 0}, "macOS", {"Catalina",      {10, 15, 2}}},
-	"19C58"    = {{19, 2, 0}, "macOS", {"Catalina",      {10, 15, 2}}},
-	"19D76"    = {{19, 3, 0}, "macOS", {"Catalina",      {10, 15, 3}}},
-	"19E266"   = {{19, 4, 0}, "macOS", {"Catalina",      {10, 15, 4}}},
-	"19E287"   = {{19, 4, 0}, "macOS", {"Catalina",      {10, 15, 4}}},
-	"19F96"    = {{19, 5, 0}, "macOS", {"Catalina",      {10, 15, 5}}},
-	"19F101"   = {{19, 5, 0}, "macOS", {"Catalina",      {10, 15, 5}}},
-	"19G73"    = {{19, 6, 0}, "macOS", {"Catalina",      {10, 15, 6}}},
-	"19G2021"  = {{19, 6, 0}, "macOS", {"Catalina",      {10, 15, 6}}},
-	"19H2"     = {{19, 6, 0}, "macOS", {"Catalina",      {10, 15, 7}}},
-	"19H4"     = {{19, 6, 0}, "macOS", {"Catalina",      {10, 15, 7}}},
-	"19H15"    = {{19, 6, 0}, "macOS", {"Catalina",      {10, 15, 7}}},
-	"19H114"   = {{19, 6, 0}, "macOS", {"Catalina",      {10, 15, 7}}},
-	"19H512"   = {{19, 6, 0}, "macOS", {"Catalina",      {10, 15, 7}}},
-	"19H524"   = {{19, 6, 0}, "macOS", {"Catalina",      {10, 15, 7}}},
-	"19H1030"  = {{19, 6, 0}, "macOS", {"Catalina",      {10, 15, 7}}},
-	"19H1217"  = {{19, 6, 0}, "macOS", {"Catalina",      {10, 15, 7}}},
-	"19H1323"  = {{19, 6, 0}, "macOS", {"Catalina",      {10, 15, 7}}},
-	"19H1417"  = {{19, 6, 0}, "macOS", {"Catalina",      {10, 15, 7}}},
-	"19H1419"  = {{19, 6, 0}, "macOS", {"Catalina",      {10, 15, 7}}},
-	"19H1519"  = {{19, 6, 0}, "macOS", {"Catalina",      {10, 15, 7}}},
-	"19H1615"  = {{19, 6, 0}, "macOS", {"Catalina",      {10, 15, 7}}},
-	"19H1713"  = {{19, 6, 0}, "macOS", {"Catalina",      {10, 15, 7}}},
-	"19H1715"  = {{19, 6, 0}, "macOS", {"Catalina",      {10, 15, 7}}},
-	"19H1824"  = {{19, 6, 0}, "macOS", {"Catalina",      {10, 15, 7}}},
-	"19H1922"  = {{19, 6, 0}, "macOS", {"Catalina",      {10, 15, 7}}},
-	"19H2026"  = {{19, 6, 0}, "macOS", {"Catalina",      {10, 15, 7}}},
+	"19A583"     = {{19, 0, 0}, "macOS", {"Catalina",       {10, 15, 0}}},
+	"19A602"     = {{19, 0, 0}, "macOS", {"Catalina",       {10, 15, 0}}},
+	"19A603"     = {{19, 0, 0}, "macOS", {"Catalina",       {10, 15, 0}}},
+	"19B88"      = {{19, 0, 0}, "macOS", {"Catalina",       {10, 15, 1}}},
+	"19C57"      = {{19, 2, 0}, "macOS", {"Catalina",       {10, 15, 2}}},
+	"19C58"      = {{19, 2, 0}, "macOS", {"Catalina",       {10, 15, 2}}},
+	"19D76"      = {{19, 3, 0}, "macOS", {"Catalina",       {10, 15, 3}}},
+	"19E266"     = {{19, 4, 0}, "macOS", {"Catalina",       {10, 15, 4}}},
+	"19E287"     = {{19, 4, 0}, "macOS", {"Catalina",       {10, 15, 4}}},
+	"19F96"      = {{19, 5, 0}, "macOS", {"Catalina",       {10, 15, 5}}},
+	"19F101"     = {{19, 5, 0}, "macOS", {"Catalina",       {10, 15, 5}}},
+	"19G73"      = {{19, 6, 0}, "macOS", {"Catalina",       {10, 15, 6}}},
+	"19G2021"    = {{19, 6, 0}, "macOS", {"Catalina",       {10, 15, 6}}},
+	"19H2"       = {{19, 6, 0}, "macOS", {"Catalina",       {10, 15, 7}}},
+	"19H4"       = {{19, 6, 0}, "macOS", {"Catalina",       {10, 15, 7}}},
+	"19H15"      = {{19, 6, 0}, "macOS", {"Catalina",       {10, 15, 7}}},
+	"19H114"     = {{19, 6, 0}, "macOS", {"Catalina",       {10, 15, 7}}},
+	"19H512"     = {{19, 6, 0}, "macOS", {"Catalina",       {10, 15, 7}}},
+	"19H524"     = {{19, 6, 0}, "macOS", {"Catalina",       {10, 15, 7}}},
+	"19H1030"    = {{19, 6, 0}, "macOS", {"Catalina",       {10, 15, 7}}},
+	"19H1217"    = {{19, 6, 0}, "macOS", {"Catalina",       {10, 15, 7}}},
+	"19H1323"    = {{19, 6, 0}, "macOS", {"Catalina",       {10, 15, 7}}},
+	"19H1417"    = {{19, 6, 0}, "macOS", {"Catalina",       {10, 15, 7}}},
+	"19H1419"    = {{19, 6, 0}, "macOS", {"Catalina",       {10, 15, 7}}},
+	"19H1519"    = {{19, 6, 0}, "macOS", {"Catalina",       {10, 15, 7}}},
+	"19H1615"    = {{19, 6, 0}, "macOS", {"Catalina",       {10, 15, 7}}},
+	"19H1713"    = {{19, 6, 0}, "macOS", {"Catalina",       {10, 15, 7}}},
+	"19H1715"    = {{19, 6, 0}, "macOS", {"Catalina",       {10, 15, 7}}},
+	"19H1824"    = {{19, 6, 0}, "macOS", {"Catalina",       {10, 15, 7}}},
+	"19H1922"    = {{19, 6, 0}, "macOS", {"Catalina",       {10, 15, 7}}},
+	"19H2026"    = {{19, 6, 0}, "macOS", {"Catalina",       {10, 15, 7}}},
 
 	// MacOS Big Sur
-	"20A2411"  = {{20, 1, 0}, "macOS", {"Big Sur",       {11, 0, 0}}},
-	"20B29"    = {{20, 1, 0}, "macOS", {"Big Sur",       {11, 0, 1}}},
-	"20B50"    = {{20, 1, 0}, "macOS", {"Big Sur",       {11, 0, 1}}},
-	"20C69"    = {{20, 2, 0}, "macOS", {"Big Sur",       {11, 1, 0}}},
-	"20D64"    = {{20, 3, 0}, "macOS", {"Big Sur",       {11, 2, 0}}},
-	"20D74"    = {{20, 3, 0}, "macOS", {"Big Sur",       {11, 2, 1}}},
-	"20D75"    = {{20, 3, 0}, "macOS", {"Big Sur",       {11, 2, 1}}},
-	"20D80"    = {{20, 3, 0}, "macOS", {"Big Sur",       {11, 2, 2}}},
-	"20D91"    = {{20, 3, 0}, "macOS", {"Big Sur",       {11, 2, 3}}},
-	"20E232"   = {{20, 4, 0}, "macOS", {"Big Sur",       {11, 3, 0}}},
-	"20E241"   = {{20, 4, 0}, "macOS", {"Big Sur",       {11, 3, 1}}},
-	"20F71"    = {{20, 5, 0}, "macOS", {"Big Sur",       {11, 4, 0}}},
-	"20G71"    = {{20, 6, 0}, "macOS", {"Big Sur",       {11, 5, 0}}},
-	"20G80"    = {{20, 6, 0}, "macOS", {"Big Sur",       {11, 5, 1}}},
-	"20G95"    = {{20, 6, 0}, "macOS", {"Big Sur",       {11, 5, 2}}},
-	"20G165"   = {{20, 6, 0}, "macOS", {"Big Sur",       {11, 6, 0}}},
-	"20G224"   = {{20, 6, 0}, "macOS", {"Big Sur",       {11, 6, 1}}},
-	"20G314"   = {{20, 6, 0}, "macOS", {"Big Sur",       {11, 6, 2}}},
-	"20G415"   = {{20, 6, 0}, "macOS", {"Big Sur",       {11, 6, 3}}},
-	"20G417"   = {{20, 6, 0}, "macOS", {"Big Sur",       {11, 6, 4}}},
-	"20G527"   = {{20, 6, 0}, "macOS", {"Big Sur",       {11, 6, 5}}},
-	"20G624"   = {{20, 6, 0}, "macOS", {"Big Sur",       {11, 6, 6}}},
-	"20G630"   = {{20, 6, 0}, "macOS", {"Big Sur",       {11, 6, 7}}},
-	"20G730"   = {{20, 6, 0}, "macOS", {"Big Sur",       {11, 6, 8}}},
+	"20A2411"    = {{20, 1, 0}, "macOS", {"Big Sur",        {11, 0, 0}}},
+	"20B29"      = {{20, 1, 0}, "macOS", {"Big Sur",        {11, 0, 1}}},
+	"20B50"      = {{20, 1, 0}, "macOS", {"Big Sur",        {11, 0, 1}}},
+	"20C69"      = {{20, 2, 0}, "macOS", {"Big Sur",        {11, 1, 0}}},
+	"20D64"      = {{20, 3, 0}, "macOS", {"Big Sur",        {11, 2, 0}}},
+	"20D74"      = {{20, 3, 0}, "macOS", {"Big Sur",        {11, 2, 1}}},
+	"20D75"      = {{20, 3, 0}, "macOS", {"Big Sur",        {11, 2, 1}}},
+	"20D80"      = {{20, 3, 0}, "macOS", {"Big Sur",        {11, 2, 2}}},
+	"20D91"      = {{20, 3, 0}, "macOS", {"Big Sur",        {11, 2, 3}}},
+	"20E232"     = {{20, 4, 0}, "macOS", {"Big Sur",        {11, 3, 0}}},
+	"20E241"     = {{20, 4, 0}, "macOS", {"Big Sur",        {11, 3, 1}}},
+	"20F71"      = {{20, 5, 0}, "macOS", {"Big Sur",        {11, 4, 0}}},
+	"20G71"      = {{20, 6, 0}, "macOS", {"Big Sur",        {11, 5, 0}}},
+	"20G80"      = {{20, 6, 0}, "macOS", {"Big Sur",        {11, 5, 1}}},
+	"20G95"      = {{20, 6, 0}, "macOS", {"Big Sur",        {11, 5, 2}}},
+	"20G165"     = {{20, 6, 0}, "macOS", {"Big Sur",        {11, 6, 0}}},
+	"20G224"     = {{20, 6, 0}, "macOS", {"Big Sur",        {11, 6, 1}}},
+	"20G314"     = {{20, 6, 0}, "macOS", {"Big Sur",        {11, 6, 2}}},
+	"20G415"     = {{20, 6, 0}, "macOS", {"Big Sur",        {11, 6, 3}}},
+	"20G417"     = {{20, 6, 0}, "macOS", {"Big Sur",        {11, 6, 4}}},
+	"20G527"     = {{20, 6, 0}, "macOS", {"Big Sur",        {11, 6, 5}}},
+	"20G624"     = {{20, 6, 0}, "macOS", {"Big Sur",        {11, 6, 6}}},
+	"20G630"     = {{20, 6, 0}, "macOS", {"Big Sur",        {11, 6, 7}}},
+	"20G730"     = {{20, 6, 0}, "macOS", {"Big Sur",        {11, 6, 8}}},
+	"20G817"     = {{20, 6, 0}, "macOS", {"Big Sur",        {11, 7, 0}}},
+	"20G918"     = {{20, 6, 0}, "macOS", {"Big Sur",        {11, 7, 1}}},
+	"20G1020"    = {{20, 6, 0}, "macOS", {"Big Sur",        {11, 7, 2}}},
+	"20G1116"    = {{20, 6, 0}, "macOS", {"Big Sur",        {11, 7, 3}}},
+	"20G1120"    = {{20, 6, 0}, "macOS", {"Big Sur",        {11, 7, 4}}},
+	"20G1225"    = {{20, 6, 0}, "macOS", {"Big Sur",        {11, 7, 5}}},
+	"20G1231"    = {{20, 6, 0}, "macOS", {"Big Sur",        {11, 7, 6}}},
+	"20G1345"    = {{20, 6, 0}, "macOS", {"Big Sur",        {11, 7, 7}}},
+	"20G1351"    = {{20, 6, 0}, "macOS", {"Big Sur",        {11, 7, 8}}},
+	"20G1426"    = {{20, 6, 0}, "macOS", {"Big Sur",        {11, 7, 9}}},
+	"20G1427"    = {{20, 6, 0}, "macOS", {"Big Sur",        {11, 7, 10}}},
 
 	// MacOS Monterey
-	"21A344"   = {{21, 0, 1}, "macOS", {"Monterey",      {12, 0, 0}}},
-	"21A559"   = {{21, 1, 0}, "macOS", {"Monterey",      {12, 0, 1}}},
-	"21C52"    = {{21, 2, 0}, "macOS", {"Monterey",      {12, 1, 0}}},
-	"21D49"    = {{21, 3, 0}, "macOS", {"Monterey",      {12, 2, 0}}},
-	"21D62"    = {{21, 3, 0}, "macOS", {"Monterey",      {12, 2, 1}}},
-	"21E230"   = {{21, 4, 0}, "macOS", {"Monterey",      {12, 3, 0}}},
-	"21E258"   = {{21, 4, 0}, "macOS", {"Monterey",      {12, 3, 1}}},
-	"21F79"    = {{21, 5, 0}, "macOS", {"Monterey",      {12, 4, 0}}},
-	"21F2081"  = {{21, 5, 0}, "macOS", {"Monterey",      {12, 4, 0}}},
-	"21F2092"  = {{21, 5, 0}, "macOS", {"Monterey",      {12, 4, 0}}},
-	"21G72"    = {{21, 6, 0}, "macOS", {"Monterey",      {12, 5, 0}}},
-	"21G83"    = {{21, 6, 0}, "macOS", {"Monterey",      {12, 5, 1}}},
-	"21G115"   = {{21, 6, 0}, "macOS", {"Monterey",      {12, 6, 0}}},
+	"21A344"     = {{21, 0, 1}, "macOS", {"Monterey",       {12, 0, 0}}},
+	"21A559"     = {{21, 1, 0}, "macOS", {"Monterey",       {12, 0, 1}}},
+	"21C52"      = {{21, 2, 0}, "macOS", {"Monterey",       {12, 1, 0}}},
+	"21D49"      = {{21, 3, 0}, "macOS", {"Monterey",       {12, 2, 0}}},
+	"21D62"      = {{21, 3, 0}, "macOS", {"Monterey",       {12, 2, 1}}},
+	"21E230"     = {{21, 4, 0}, "macOS", {"Monterey",       {12, 3, 0}}},
+	"21E258"     = {{21, 4, 0}, "macOS", {"Monterey",       {12, 3, 1}}},
+	"21F79"      = {{21, 5, 0}, "macOS", {"Monterey",       {12, 4, 0}}},
+	"21F2081"    = {{21, 5, 0}, "macOS", {"Monterey",       {12, 4, 0}}},
+	"21F2092"    = {{21, 5, 0}, "macOS", {"Monterey",       {12, 4, 0}}},
+	"21G72"      = {{21, 6, 0}, "macOS", {"Monterey",       {12, 5, 0}}},
+	"21G83"      = {{21, 6, 0}, "macOS", {"Monterey",       {12, 5, 1}}},
+	"21G115"     = {{21, 6, 0}, "macOS", {"Monterey",       {12, 6, 0}}},
+	"21G217"     = {{21, 6, 0}, "macOS", {"Monterey",       {12, 6, 1}}},
+	"21G320"     = {{21, 6, 0}, "macOS", {"Monterey",       {12, 6, 2}}},
+	"21G419"     = {{21, 6, 0}, "macOS", {"Monterey",       {12, 6, 3}}},
+	"21G526"     = {{21, 6, 0}, "macOS", {"Monterey",       {12, 6, 4}}},
+	"21G531"     = {{21, 6, 0}, "macOS", {"Monterey",       {12, 6, 5}}},
+	"21G646"     = {{21, 6, 0}, "macOS", {"Monterey",       {12, 6, 6}}},
+	"21G651"     = {{21, 6, 0}, "macOS", {"Monterey",       {12, 6, 7}}},
+	"21G725"     = {{21, 6, 0}, "macOS", {"Monterey",       {12, 6, 8}}},
+	"21G726"     = {{21, 6, 0}, "macOS", {"Monterey",       {12, 6, 9}}},
+	"21G816"     = {{21, 6, 0}, "macOS", {"Monterey",       {12, 7, 0}}},
+	"21G920"     = {{21, 6, 0}, "macOS", {"Monterey",       {12, 7, 1}}},
+	"21G1974"    = {{21, 6, 0}, "macOS", {"Monterey",       {12, 7, 2}}},
+
+	// MacOS Ventura 
+	"22A380"     = {{22, 1, 0}, "macOS", {"Ventura",        {13, 0, 0}}},
+	"22A400"     = {{22, 1, 0}, "macOS", {"Ventura",        {13, 0, 1}}},
+	"22C65"	     = {{22, 2, 0}, "macOS", {"Ventura",        {13, 1, 0}}},
+	"22D49"	     = {{22, 3, 0}, "macOS", {"Ventura",        {13, 2, 0}}},
+	"22D68"	     = {{22, 3, 0}, "macOS", {"Ventura",        {13, 2, 1}}},
+	"22E252"     = {{22, 4, 0}, "macOS", {"Ventura",        {13, 3, 0}}},
+	"22E261"     = {{22, 4, 0}, "macOS", {"Ventura",        {13, 3, 1}}},
+	"22F66"	     = {{22, 5, 0}, "macOS", {"Ventura",        {13, 4, 0}}},
+	"22F82"	     = {{22, 5, 0}, "macOS", {"Ventura",        {13, 4, 1}}},
+	"22E772610a" = {{22, 5, 0}, "macOS", {"Ventura",        {13, 4, 1}}},
+	"22F770820d" = {{22, 5, 0}, "macOS", {"Ventura",        {13, 4, 1}}},
+	"22G74"	     = {{22, 6, 0}, "macOS", {"Ventura",        {13, 5, 0}}},
+	"22G90"	     = {{22, 6, 0}, "macOS", {"Ventura",        {13, 5, 1}}},
+	"22G91"	     = {{22, 6, 0}, "macOS", {"Ventura",        {13, 5, 2}}},
+	"22G120"     = {{22, 6, 0}, "macOS", {"Ventura",        {13, 6, 0}}},
+	"22G313"     = {{22, 6, 0}, "macOS", {"Ventura",        {13, 6, 1}}},
+	"22G320"     = {{22, 6, 0}, "macOS", {"Ventura",        {13, 6, 2}}},
+
+	// MacOS Sonoma 
+	"23A344"     = {{23, 0, 0}, "macOS", {"Sonoma",         {14, 0, 0}}},
+	"23B74"      = {{23, 1, 0}, "macOS", {"Sonoma",         {14, 1, 0}}},
+	"23B81"      = {{23, 1, 0}, "macOS", {"Sonoma",         {14, 1, 1}}},
+	"23B92"      = {{23, 1, 0}, "macOS", {"Sonoma",         {14, 1, 2}}},
+	"23C64"      = {{23, 2, 0}, "macOS", {"Sonoma",         {14, 2, 0}}},
+	"23C71"      = {{23, 2, 0}, "macOS", {"Sonoma",         {14, 2, 1}}},
 }
 
 @(private)

core/sys/linux/sys.odin

@@ -1,4 +1,3 @@
-//+build linux
 package linux
 
 import "core:intrinsics"

core/sys/linux/types.odin

@@ -1,4 +1,3 @@
-//+build linux
 package linux
 
 /*

core/sys/windows/advapi32.odin

@@ -5,7 +5,7 @@ foreign import advapi32 "system:Advapi32.lib"
 
 HCRYPTPROV :: distinct HANDLE
 
-@(default_calling_convention="stdcall")
+@(default_calling_convention="system")
 foreign advapi32 {
 	@(link_name = "SystemFunction036")
 	RtlGenRandom :: proc(RandomBuffer: ^u8, RandomBufferLength: ULONG) -> BOOLEAN ---
@@ -13,13 +13,18 @@ foreign advapi32 {
 	                         DesiredAccess: DWORD,
 	                         TokenHandle: ^HANDLE) -> BOOL ---
 
+	OpenThreadToken :: proc(ThreadHandle:  HANDLE,
+	                        DesiredAccess: DWORD,
+	                        OpenAsSelf:    BOOL,
+	                        TokenHandle:   ^HANDLE) -> BOOL ---
+
 	CryptAcquireContextW :: proc(hProv: ^HCRYPTPROV, szContainer, szProvider: wstring, dwProvType, dwFlags: DWORD) -> DWORD ---
 	CryptGenRandom       :: proc(hProv: HCRYPTPROV, dwLen: DWORD, buf: LPVOID) -> DWORD ---
 	CryptReleaseContext  :: proc(hProv: HCRYPTPROV, dwFlags: DWORD) -> DWORD ---
 }
 
 // Necessary to create a token to impersonate a user with for CreateProcessAsUser
-@(default_calling_convention="stdcall")
+@(default_calling_convention="system")
 foreign advapi32 {
 	LogonUserW :: proc(
 		lpszUsername: LPCWSTR,

core/sys/windows/bcrypt.odin

@@ -5,7 +5,7 @@ foreign import bcrypt "system:Bcrypt.lib"
 
 BCRYPT_USE_SYSTEM_PREFERRED_RNG: DWORD : 0x00000002
 
-@(default_calling_convention="stdcall")
+@(default_calling_convention="system")
 foreign bcrypt {
 	BCryptGenRandom :: proc(hAlgorithm: LPVOID, pBuffer: [^]u8, cbBuffer: ULONG, dwFlags: ULONG) -> LONG ---
 }

core/sys/windows/bluetooth.odin

@@ -51,7 +51,7 @@ BLUETOOTH_DEVICE_INFO :: struct {
 	name:          [BLUETOOTH_MAX_NAME_SIZE]u16, //  Name of the device
 }
 
-@(default_calling_convention="stdcall")
+@(default_calling_convention="system")
 foreign bthprops {
 	/*
 		Version

core/sys/windows/comctl32.odin

@@ -3,7 +3,7 @@ package sys_windows
 
 foreign import "system:Comctl32.lib"
 
-@(default_calling_convention="stdcall")
+@(default_calling_convention="system")
 foreign Comctl32 {
 	LoadIconWithScaleDown :: proc(hinst: HINSTANCE, pszName: PCWSTR, cx: c_int, cy: c_int, phico: ^HICON) -> HRESULT ---
 }

core/sys/windows/comdlg32.odin

@@ -3,7 +3,7 @@ package sys_windows
 
 foreign import "system:Comdlg32.lib"
 
-LPOFNHOOKPROC :: #type proc "stdcall" (hdlg: HWND, msg: u32, wparam: WPARAM, lparam: LPARAM) -> UINT_PTR
+LPOFNHOOKPROC :: #type proc "system" (hdlg: HWND, msg: u32, wparam: WPARAM, lparam: LPARAM) -> UINT_PTR
 
 OPENFILENAMEW :: struct {
 	lStructSize: 	        DWORD,
@@ -31,7 +31,7 @@ OPENFILENAMEW :: struct {
 	FlagsEx:                DWORD,
 }
 
-@(default_calling_convention="stdcall")
+@(default_calling_convention="system")
 foreign Comdlg32 {
 	GetOpenFileNameW     :: proc(arg1: ^OPENFILENAMEW) -> BOOL ---
 	GetSaveFileNameW     :: proc(arg1: ^OPENFILENAMEW) -> BOOL ---

core/sys/windows/dbghelp.odin

@@ -44,7 +44,7 @@ MINIDUMP_USER_STREAM_INFORMATION :: struct {
 	UserStreamArray: ^MINIDUMP_USER_STREAM,
 }
 
-MINIDUMP_CALLBACK_ROUTINE :: #type proc "stdcall" (
+MINIDUMP_CALLBACK_ROUTINE :: #type proc "system" (
 	CallbackParam: PVOID,
 	CallbackInput: ^MINIDUMP_CALLBACK_INPUT,
 	CallbackOutpu: ^MINIDUMP_CALLBACK_OUTPUT,
@@ -228,7 +228,7 @@ MINIDUMP_TYPE :: enum u32 {
 	ValidTypeFlags                 = 0x01ffffff,
 }
 
-@(default_calling_convention = "stdcall")
+@(default_calling_convention = "system")
 foreign Dbghelp {
 	MiniDumpWriteDump :: proc(
 		hProcess:        HANDLE,

core/sys/windows/dnsapi.odin

@@ -3,7 +3,7 @@ package sys_windows
 
 foreign import "system:Dnsapi.lib"
 
-@(default_calling_convention="std")
+@(default_calling_convention="system")
 foreign Dnsapi {
     DnsQuery_UTF8 :: proc(name: cstring, type: u16, options: DWORD, extra: PVOID, results: ^^DNS_RECORD, reserved: PVOID) -> DNS_STATUS ---
     DnsRecordListFree :: proc(list: ^DNS_RECORD, options: DWORD) ---

core/sys/windows/dwmapi.odin

@@ -38,7 +38,7 @@ DWMNCRENDERINGPOLICY :: enum {
 	DWMNCRP_LAST,
 }
 
-@(default_calling_convention="stdcall")
+@(default_calling_convention="system")
 foreign dwmapi {
 	DwmFlush :: proc() -> HRESULT ---
 	DwmIsCompositionEnabled :: proc(pfEnabled: ^BOOL) -> HRESULT ---

core/sys/windows/gdi32.odin

@@ -3,7 +3,7 @@ package sys_windows
 
 foreign import gdi32 "system:Gdi32.lib"
 
-@(default_calling_convention="stdcall")
+@(default_calling_convention="system")
 foreign gdi32 {
 	GetStockObject :: proc(i: c_int) -> HGDIOBJ ---
 	SelectObject :: proc(hdc: HDC, h: HGDIOBJ) -> HGDIOBJ ---

core/sys/windows/hidpi.odin

@@ -124,7 +124,7 @@ HIDP_REPORT_TYPE :: enum c.int {
 HIDP_STATUS_SUCCESS : NTSTATUS : 0x110000
 
 foreign import hid "system:hid.lib"
-@(default_calling_convention="stdcall")
+@(default_calling_convention="system")
 foreign hid {
 	HidP_GetCaps :: proc(PreparsedData: PHIDP_PREPARSED_DATA, Capabilities: PHIDP_CAPS) -> NTSTATUS ---
 	HidP_GetButtonCaps :: proc(ReportType: HIDP_REPORT_TYPE, ButtonCaps: PHIDP_BUTTON_CAPS, ButtonCapsLength: PUSHORT, PreparsedData: PHIDP_PREPARSED_DATA) -> NTSTATUS ---

core/sys/windows/ip_helper.odin

@@ -217,7 +217,7 @@ NL_DAD_STATE :: enum i32 {
 	IpDadStatePreferred  = 4,
 }
 
-@(default_calling_convention = "std")
+@(default_calling_convention = "system")
 foreign iphlpapi {
 	/*
 		The GetAdaptersAddresses function retrieves the addresses associated with the adapters on the local computer.

core/sys/windows/kernel32.odin

@@ -21,7 +21,7 @@ COMMON_LVB_REVERSE_VIDEO   :: WORD(0x4000)
 COMMON_LVB_UNDERSCORE      :: WORD(0x8000)
 COMMON_LVB_SBCSDBCS        :: WORD(0x0300)
 
-@(default_calling_convention="stdcall")
+@(default_calling_convention="system")
 foreign kernel32 {
 	OutputDebugStringA :: proc(lpOutputString: LPCSTR) --- // The only A thing that is allowed
 	OutputDebugStringW :: proc(lpOutputString: LPCWSTR) ---
@@ -112,7 +112,7 @@ foreign kernel32 {
 	CreateThread :: proc(
 		lpThreadAttributes: LPSECURITY_ATTRIBUTES,
 		dwStackSize: SIZE_T,
-		lpStartAddress: proc "stdcall" (rawptr) -> DWORD,
+		lpStartAddress: proc "system" (rawptr) -> DWORD,
 		lpParameter: LPVOID,
 		dwCreationFlags: DWORD,
 		lpThreadId: LPDWORD,
@@ -121,7 +121,7 @@ foreign kernel32 {
 		hProcess: HANDLE,
 		lpThreadAttributes: LPSECURITY_ATTRIBUTES,
 		dwStackSize: SIZE_T,
-		lpStartAddress: proc "stdcall" (rawptr) -> DWORD,
+		lpStartAddress: proc "system" (rawptr) -> DWORD,
 		lpParameter: LPVOID,
 		dwCreationFlags: DWORD,
 		lpThreadId: LPDWORD,
@@ -581,7 +581,7 @@ MEM_TOP_DOWN    :: 0x100000
 MEM_LARGE_PAGES :: 0x20000000
 MEM_4MB_PAGES   :: 0x80000000
 
-@(default_calling_convention="stdcall")
+@(default_calling_convention="system")
 foreign kernel32 {
 	VirtualAlloc :: proc(
 		lpAddress: LPVOID,
@@ -724,7 +724,7 @@ LowMemoryResourceNotification  :: MEMORY_RESOURCE_NOTIFICATION_TYPE.LowMemoryRes
 HighMemoryResourceNotification :: MEMORY_RESOURCE_NOTIFICATION_TYPE.HighMemoryResourceNotification
 
 
-@(default_calling_convention="stdcall")
+@(default_calling_convention="system")
 foreign kernel32 {
 	CreateMemoryResourceNotification :: proc(
 		NotificationType: MEMORY_RESOURCE_NOTIFICATION_TYPE,
@@ -740,7 +740,7 @@ FILE_CACHE_MAX_HARD_DISABLE :: DWORD(0x00000002)
 FILE_CACHE_MIN_HARD_ENABLE  :: DWORD(0x00000004)
 FILE_CACHE_MIN_HARD_DISABLE :: DWORD(0x00000008)
 
-@(default_calling_convention="stdcall")
+@(default_calling_convention="system")
 foreign kernel32 {
 	GetSystemFileCacheSize :: proc(
 		lpMinimumFileCacheSize: PSIZE_T,
@@ -770,7 +770,7 @@ WIN32_MEMORY_RANGE_ENTRY :: struct {
 
 PWIN32_MEMORY_RANGE_ENTRY :: ^WIN32_MEMORY_RANGE_ENTRY
 
-@(default_calling_convention="stdcall")
+@(default_calling_convention="system")
 foreign kernel32 {
 	PrefetchVirtualMemory :: proc(
 		hProcess: HANDLE,
@@ -828,23 +828,23 @@ foreign kernel32 {
 
 MEHC_PATROL_SCRUBBER_PRESENT :: ULONG(0x1)
 
-@(default_calling_convention="stdcall")
+@(default_calling_convention="system")
 foreign kernel32 {
 	GetMemoryErrorHandlingCapabilities :: proc(
 		Capabilities: PULONG,
 	) -> BOOL ---
 }
 
-@(default_calling_convention="stdcall")
+@(default_calling_convention="system")
 foreign kernel32 {
 	GlobalMemoryStatusEx :: proc(
 		lpBuffer: ^MEMORYSTATUSEX,
 	) -> BOOL ---
 }
 
-PBAD_MEMORY_CALLBACK_ROUTINE :: #type proc "stdcall" ()
+PBAD_MEMORY_CALLBACK_ROUTINE :: #type proc "system" ()
 
-@(default_calling_convention="stdcall")
+@(default_calling_convention="system")
 foreign kernel32 {
 	RegisterBadMemoryNotification :: proc(
 		Callback: PBAD_MEMORY_CALLBACK_ROUTINE,
@@ -865,7 +865,7 @@ VmOfferPriorityLow         :: OFFER_PRIORITY.VmOfferPriorityLow
 VmOfferPriorityBelowNormal :: OFFER_PRIORITY.VmOfferPriorityBelowNormal
 VmOfferPriorityNormal      :: OFFER_PRIORITY.VmOfferPriorityNormal
 
-@(default_calling_convention="stdcall")
+@(default_calling_convention="system")
 foreign kernel32 {
 	OfferVirtualMemory :: proc(
 		VirtualAddress: PVOID,
@@ -930,7 +930,7 @@ WIN32_MEMORY_REGION_INFORMATION_u_s_Bitfield :: distinct ULONG
 	Reserved       : 32-6,
 }*/
 
-@(default_calling_convention="stdcall")
+@(default_calling_convention="system")
 foreign one_core {
 	QueryVirtualMemoryInformation :: proc(
 		Process: HANDLE,
@@ -955,7 +955,7 @@ foreign one_core {
 
 NUMA_NO_PREFERRED_NODE :: 0xffffffff
 
-MapViewOfFile2 :: #force_inline proc "stdcall" (
+MapViewOfFile2 :: #force_inline proc "system" (
 	FileMappingHandle: HANDLE,
 	ProcessHandle: HANDLE,
 	Offset: ULONG64,
@@ -976,7 +976,7 @@ MapViewOfFile2 :: #force_inline proc "stdcall" (
 	)
 }
 
-@(default_calling_convention="stdcall")
+@(default_calling_convention="system")
 foreign kernel32 {
 	UnmapViewOfFile2 :: proc(
 		ProcessHandle: HANDLE,
@@ -985,7 +985,7 @@ foreign kernel32 {
 	) -> BOOL ---
 }
 
-@(default_calling_convention="stdcall")
+@(default_calling_convention="system")
 foreign kernel32 {
 	GetProductInfo :: proc(
 		OSMajorVersion: DWORD,
@@ -996,7 +996,7 @@ foreign kernel32 {
 	) -> BOOL ---
 }
 
-HandlerRoutine :: proc "stdcall" (dwCtrlType: DWORD) -> BOOL
+HandlerRoutine :: proc "system" (dwCtrlType: DWORD) -> BOOL
 PHANDLER_ROUTINE :: HandlerRoutine
 
 
@@ -1137,16 +1137,16 @@ DCB :: struct {
 	wReserved1: WORD,
 }
 
-@(default_calling_convention="stdcall")
+@(default_calling_convention="system")
 foreign kernel32 {
 	GetCommState :: proc(handle: HANDLE, dcb: ^DCB) -> BOOL ---
 	SetCommState :: proc(handle: HANDLE, dcb: ^DCB) -> BOOL ---
 }
 
 
-LPFIBER_START_ROUTINE :: #type proc "stdcall" (lpFiberParameter: LPVOID)
+LPFIBER_START_ROUTINE :: #type proc "system" (lpFiberParameter: LPVOID)
 
-@(default_calling_convention = "stdcall")
+@(default_calling_convention = "system")
 foreign kernel32 {
 	CreateFiber :: proc(dwStackSize: SIZE_T, lpStartAddress: LPFIBER_START_ROUTINE, lpParameter: LPVOID) -> LPVOID ---
 	DeleteFiber :: proc(lpFiber: LPVOID) ---

core/sys/windows/netapi32.odin

@@ -3,7 +3,7 @@ package sys_windows
 
 foreign import netapi32 "system:Netapi32.lib"
 
-@(default_calling_convention="stdcall")
+@(default_calling_convention="system")
 foreign netapi32 {
 	NetUserAdd :: proc(
 		servername: wstring,

core/sys/windows/ntdll.odin

@@ -3,7 +3,7 @@ package sys_windows
 
 foreign import ntdll_lib "system:ntdll.lib"
 
-@(default_calling_convention="stdcall")
+@(default_calling_convention="system")
 foreign ntdll_lib {
 	RtlGetVersion :: proc(lpVersionInformation: ^OSVERSIONINFOEXW) -> NTSTATUS ---
 }

core/sys/windows/ole32.odin

@@ -1,4 +1,3 @@
-// +build windows
 package sys_windows
 
 foreign import "system:Ole32.lib"
@@ -15,14 +14,14 @@ IUnknown :: struct {
 	using Vtbl: ^IUnknownVtbl,
 }
 IUnknownVtbl :: struct {
-	QueryInterface: proc "stdcall" (This: ^IUnknown, riid: REFIID, ppvObject: ^rawptr) -> HRESULT,
-	AddRef:         proc "stdcall" (This: ^IUnknown) -> ULONG,
-	Release:        proc "stdcall" (This: ^IUnknown) -> ULONG,
+	QueryInterface: proc "system" (This: ^IUnknown, riid: REFIID, ppvObject: ^rawptr) -> HRESULT,
+	AddRef:         proc "system" (This: ^IUnknown) -> ULONG,
+	Release:        proc "system" (This: ^IUnknown) -> ULONG,
 }
 
 LPUNKNOWN :: ^IUnknown
 
-@(default_calling_convention="stdcall")
+@(default_calling_convention="system")
 foreign Ole32 {
 	CoInitializeEx :: proc(reserved: rawptr, co_init: COINIT) -> HRESULT ---
 	CoUninitialize :: proc() ---

core/sys/windows/shell32.odin

@@ -3,7 +3,7 @@ package sys_windows
 
 foreign import shell32 "system:Shell32.lib"
 
-@(default_calling_convention="stdcall")
+@(default_calling_convention="system")
 foreign shell32 {
 	CommandLineToArgvW :: proc(cmd_list: wstring, num_args: ^c_int) -> ^wstring ---
 	ShellExecuteW :: proc(

core/sys/windows/shlwapi.odin

@@ -3,7 +3,7 @@ package sys_windows
 
 foreign import shlwapi "system:shlwapi.lib"
 
-@(default_calling_convention="stdcall")
+@(default_calling_convention="system")
 foreign shlwapi {
 	PathFileExistsW    :: proc(pszPath: wstring) -> BOOL ---
 	PathFindExtensionW :: proc(pszPath: wstring) -> wstring ---

core/sys/windows/synchronization.odin

@@ -3,7 +3,7 @@ package sys_windows
 
 foreign import Synchronization "system:Synchronization.lib"
 
-@(default_calling_convention="stdcall")
+@(default_calling_convention="system")
 foreign Synchronization {
 	WaitOnAddress       :: proc(Address: PVOID, CompareAddress: PVOID, AddressSize: SIZE_T, dwMilliseconds: DWORD) -> BOOL ---
 	WakeByAddressSingle :: proc(Address: PVOID) ---

core/sys/windows/types.odin

@@ -1,4 +1,3 @@
-// +build windows
 package sys_windows
 
 import "core:c"
@@ -7,9 +6,9 @@ c_char      :: c.char
 c_uchar     :: c.uchar
 c_int       :: c.int
 c_uint      :: c.uint
-c_long      :: c.long
+c_long      :: i32
 c_longlong  :: c.longlong
-c_ulong     :: c.ulong
+c_ulong     :: u32
 c_ulonglong :: c.ulonglong
 c_short     :: c.short
 c_ushort    :: c.ushort
@@ -692,13 +691,13 @@ FW_DEMIBOLD   :: FW_SEMIBOLD
 FW_ULTRABOLD  :: FW_EXTRABOLD
 FW_BLACK      :: FW_HEAVY
 
-PTIMERAPCROUTINE :: #type proc "stdcall" (lpArgToCompletionRoutine: LPVOID, dwTimerLowValue, dwTimerHighValue: DWORD)
+PTIMERAPCROUTINE :: #type proc "system" (lpArgToCompletionRoutine: LPVOID, dwTimerLowValue, dwTimerHighValue: DWORD)
 
-TIMERPROC :: #type proc "stdcall" (HWND, UINT, UINT_PTR, DWORD)
+TIMERPROC :: #type proc "system" (HWND, UINT, UINT_PTR, DWORD)
 
-WNDPROC :: #type proc "stdcall" (HWND, UINT, WPARAM, LPARAM) -> LRESULT
+WNDPROC :: #type proc "system" (HWND, UINT, WPARAM, LPARAM) -> LRESULT
 
-HOOKPROC :: #type proc "stdcall" (code: c_int, wParam: WPARAM, lParam: LPARAM) -> LRESULT
+HOOKPROC :: #type proc "system" (code: c_int, wParam: WPARAM, lParam: LPARAM) -> LRESULT
 
 CWPRETSTRUCT :: struct {
 	lResult: LRESULT,
@@ -2177,7 +2176,7 @@ WC_ERR_INVALID_CHARS :: 128
 MAX_PATH :: 0x00000104
 MAX_PATH_WIDE :: 0x8000
 
-INVALID_FILE_ATTRIBUTES  :: -1
+INVALID_FILE_ATTRIBUTES  :: DWORD(0xffff_ffff)
 
 FILE_TYPE_DISK :: 0x0001
 FILE_TYPE_CHAR :: 0x0002
@@ -2325,7 +2324,7 @@ MOUNT_POINT_REPARSE_BUFFER :: struct {
 	PathBuffer: WCHAR,
 }
 
-LPPROGRESS_ROUTINE :: #type proc "stdcall" (
+LPPROGRESS_ROUTINE :: #type proc "system" (
 	TotalFileSize: LARGE_INTEGER,
 	TotalBytesTransferred: LARGE_INTEGER,
 	StreamSize: LARGE_INTEGER,
@@ -2495,7 +2494,7 @@ OVERLAPPED_ENTRY :: struct {
 	dwNumberOfBytesTransferred: DWORD,
 }
 
-LPOVERLAPPED_COMPLETION_ROUTINE :: #type proc "stdcall" (
+LPOVERLAPPED_COMPLETION_ROUTINE :: #type proc "system" (
 	dwErrorCode: DWORD,
 	dwNumberOfBytesTransfered: DWORD,
 	lpOverlapped: LPOVERLAPPED,
@@ -2559,7 +2558,7 @@ EXCEPTION_POINTERS :: struct {
 	ContextRecord: ^CONTEXT,
 }
 
-PVECTORED_EXCEPTION_HANDLER :: #type proc "stdcall" (ExceptionInfo: ^EXCEPTION_POINTERS) -> LONG
+PVECTORED_EXCEPTION_HANDLER :: #type proc "system" (ExceptionInfo: ^EXCEPTION_POINTERS) -> LONG
 
 CONSOLE_READCONSOLE_CONTROL :: struct {
 	nLength: ULONG,
@@ -2614,7 +2613,7 @@ ADDRINFOEXW :: struct {
 	ai_next:      ^ADDRINFOEXW,
 }
 
-LPLOOKUPSERVICE_COMPLETION_ROUTINE :: #type proc "stdcall" (
+LPLOOKUPSERVICE_COMPLETION_ROUTINE :: #type proc "system" (
 	dwErrorCode: DWORD,
 	dwNumberOfBytesTransfered: DWORD,
 	lpOverlapped: LPOVERLAPPED,
@@ -2720,16 +2719,17 @@ SECURITY_MAX_SID_SIZE :: 68
 
 // https://docs.microsoft.com/en-us/windows/win32/api/winnt/ns-winnt-sid
 SID :: struct #packed {
-	Revision: byte,
-	SubAuthorityCount: byte,
+	Revision:            byte,
+	SubAuthorityCount:   byte,
 	IdentifierAuthority: SID_IDENTIFIER_AUTHORITY,
-	SubAuthority: [15]DWORD, // Array of DWORDs
+	SubAuthority:        [15]DWORD, // Array of DWORDs
 }
 #assert(size_of(SID) == SECURITY_MAX_SID_SIZE)
 
 SID_IDENTIFIER_AUTHORITY :: struct #packed {
 	Value: [6]u8,
 }
+#assert(size_of(SID_IDENTIFIER_AUTHORITY) == 6)
 
 // For NetAPI32
 // https://github.com/tpn/winsdk-10/blob/master/Include/10.0.14393.0/shared/lmerr.h
@@ -3427,7 +3427,7 @@ IModalWindow :: struct #raw_union {
 }
 IModalWindowVtbl :: struct {
 	using IUnknownVtbl: IUnknownVtbl,
-	Show: proc "stdcall" (this: ^IModalWindow, hwndOwner: HWND) -> HRESULT,
+	Show: proc "system" (this: ^IModalWindow, hwndOwner: HWND) -> HRESULT,
 }
 
 ISequentialStream :: struct #raw_union {
@@ -3436,8 +3436,8 @@ ISequentialStream :: struct #raw_union {
 }
 ISequentialStreamVtbl :: struct {
 	using IUnknownVtbl: IUnknownVtbl,
-	Read:  proc "stdcall" (this: ^ISequentialStream, pv: rawptr, cb: ULONG, pcbRead: ^ULONG) -> HRESULT,
-	Write: proc "stdcall" (this: ^ISequentialStream, pv: rawptr, cb: ULONG, pcbWritten: ^ULONG) -> HRESULT,
+	Read:  proc "system" (this: ^ISequentialStream, pv: rawptr, cb: ULONG, pcbRead: ^ULONG) -> HRESULT,
+	Write: proc "system" (this: ^ISequentialStream, pv: rawptr, cb: ULONG, pcbWritten: ^ULONG) -> HRESULT,
 }
 
 IStream :: struct #raw_union {
@@ -3446,15 +3446,15 @@ IStream :: struct #raw_union {
 }
 IStreamVtbl :: struct {
 	using ISequentialStreamVtbl: ISequentialStreamVtbl,
-	Seek:         proc "stdcall" (this: ^IStream, dlibMove: LARGE_INTEGER, dwOrigin: DWORD, plibNewPosition: ^ULARGE_INTEGER) -> HRESULT,
-	SetSize:      proc "stdcall" (this: ^IStream, libNewSize: ULARGE_INTEGER) -> HRESULT,
-	CopyTo:       proc "stdcall" (this: ^IStream, pstm: ^IStream, cb: ULARGE_INTEGER, pcbRead: ^ULARGE_INTEGER, pcbWritten: ^ULARGE_INTEGER) -> HRESULT,
-	Commit:       proc "stdcall" (this: ^IStream, grfCommitFlags: DWORD) -> HRESULT,
-	Revert:       proc "stdcall" (this: ^IStream) -> HRESULT,
-	LockRegion:   proc "stdcall" (this: ^IStream, libOffset: ULARGE_INTEGER, cb: ULARGE_INTEGER, dwLockType: DWORD) -> HRESULT,
-	UnlockRegion: proc "stdcall" (this: ^IStream, libOffset: ULARGE_INTEGER, cb: ULARGE_INTEGER, dwLockType: DWORD) -> HRESULT,
-	Stat:         proc "stdcall" (this: ^IStream, pstatstg: ^STATSTG, grfStatFlag: DWORD) -> HRESULT,
-	Clone:        proc "stdcall" (this: ^IStream, ppstm: ^^IStream) -> HRESULT,
+	Seek:         proc "system" (this: ^IStream, dlibMove: LARGE_INTEGER, dwOrigin: DWORD, plibNewPosition: ^ULARGE_INTEGER) -> HRESULT,
+	SetSize:      proc "system" (this: ^IStream, libNewSize: ULARGE_INTEGER) -> HRESULT,
+	CopyTo:       proc "system" (this: ^IStream, pstm: ^IStream, cb: ULARGE_INTEGER, pcbRead: ^ULARGE_INTEGER, pcbWritten: ^ULARGE_INTEGER) -> HRESULT,
+	Commit:       proc "system" (this: ^IStream, grfCommitFlags: DWORD) -> HRESULT,
+	Revert:       proc "system" (this: ^IStream) -> HRESULT,
+	LockRegion:   proc "system" (this: ^IStream, libOffset: ULARGE_INTEGER, cb: ULARGE_INTEGER, dwLockType: DWORD) -> HRESULT,
+	UnlockRegion: proc "system" (this: ^IStream, libOffset: ULARGE_INTEGER, cb: ULARGE_INTEGER, dwLockType: DWORD) -> HRESULT,
+	Stat:         proc "system" (this: ^IStream, pstatstg: ^STATSTG, grfStatFlag: DWORD) -> HRESULT,
+	Clone:        proc "system" (this: ^IStream, ppstm: ^^IStream) -> HRESULT,
 }
 
 IPersist :: struct #raw_union {
@@ -3463,7 +3463,7 @@ IPersist :: struct #raw_union {
 }
 IPersistVtbl :: struct {
 	using IUnknownVtbl: IUnknownVtbl,
-	GetClassID: proc "stdcall" (this: ^IPersist, pClassID: ^CLSID) -> HRESULT,
+	GetClassID: proc "system" (this: ^IPersist, pClassID: ^CLSID) -> HRESULT,
 }
 
 IPersistStream :: struct #raw_union {
@@ -3472,10 +3472,10 @@ IPersistStream :: struct #raw_union {
 }
 IPersistStreamVtbl :: struct {
 	using IPersistVtbl: IPersistVtbl,
-	IsDirty:    proc "stdcall" (this: ^IPersistStream) -> HRESULT,
-	Load:       proc "stdcall" (this: ^IPersistStream, pStm: ^IStream) -> HRESULT,
-	Save:       proc "stdcall" (this: ^IPersistStream, pStm: ^IStream, fClearDirty: BOOL) -> HRESULT,
-	GetSizeMax: proc "stdcall" (this: ^IPersistStream, pcbSize: ^ULARGE_INTEGER) -> HRESULT,
+	IsDirty:    proc "system" (this: ^IPersistStream) -> HRESULT,
+	Load:       proc "system" (this: ^IPersistStream, pStm: ^IStream) -> HRESULT,
+	Save:       proc "system" (this: ^IPersistStream, pStm: ^IStream, fClearDirty: BOOL) -> HRESULT,
+	GetSizeMax: proc "system" (this: ^IPersistStream, pcbSize: ^ULARGE_INTEGER) -> HRESULT,
 }
 
 IMoniker :: struct #raw_union {
@@ -3484,21 +3484,21 @@ IMoniker :: struct #raw_union {
 }
 IMonikerVtbl :: struct {
 	using IPersistStreamVtbl: IPersistStreamVtbl,
-	BindToObject:        proc "stdcall" (this: ^IMoniker, pbc: ^IBindCtx, pmkToLeft: ^IMoniker, riidResult: REFIID, ppvResult: ^rawptr) -> HRESULT,
-	BindToStorage:       proc "stdcall" (this: ^IMoniker, pbc: ^IBindCtx, pmkToLeft: ^IMoniker, riid: REFIID, ppvObj: ^rawptr) -> HRESULT,
-	Reduce:              proc "stdcall" (this: ^IMoniker, pbc: ^IBindCtx, dwReduceHowFar: DWORD, ppmkToLeft: ^^IMoniker, ppmkReduced: ^^IMoniker) -> HRESULT,
-	ComposeWith:         proc "stdcall" (this: ^IMoniker, pmkRight: ^IMoniker, fOnlyIfNotGeneric: BOOL, ppmkComposite: ^^IMoniker) -> HRESULT,
-	Enum:                proc "stdcall" (this: ^IMoniker, fForward: BOOL, ppenumMoniker: ^^IEnumMoniker) -> HRESULT,
-	IsEqual:             proc "stdcall" (this: ^IMoniker, pmkOtherMoniker: ^IMoniker) -> HRESULT,
-	Hash:                proc "stdcall" (this: ^IMoniker, pdwHash: ^DWORD) -> HRESULT,
-	IsRunning:           proc "stdcall" (this: ^IMoniker, pbc: ^IBindCtx, pmkToLeft: ^IMoniker, pmkNewlyRunning: ^IMoniker) -> HRESULT,
-	GetTimeOfLastChange: proc "stdcall" (this: ^IMoniker, pbc: ^IBindCtx, pmkToLeft: ^IMoniker, pFileTime: ^FILETIME) -> HRESULT,
-	Inverse:             proc "stdcall" (this: ^IMoniker, ppmk: ^^IMoniker) -> HRESULT,
-	CommonPrefixWith:    proc "stdcall" (this: ^IMoniker, pmkOther: ^IMoniker, ppmkPrefix: ^^IMoniker) -> HRESULT,
-	RelativePathTo:      proc "stdcall" (this: ^IMoniker, pmkOther: ^IMoniker, ppmkRelPath: ^^IMoniker) -> HRESULT,
-	GetDisplayName:      proc "stdcall" (this: ^IMoniker, pbc: ^IBindCtx, pmkToLeft: ^IMoniker, ppszDisplayName: ^LPOLESTR) -> HRESULT,
-	ParseDisplayName:    proc "stdcall" (this: ^IMoniker, pbc: ^IBindCtx, pmkToLeft: ^IMoniker, pszDisplayName: LPOLESTR, pchEaten: ^ULONG, ppmkOut: ^^IMoniker) -> HRESULT,
-	IsSystemMoniker:     proc "stdcall" (this: ^IMoniker, pdwMksys: ^DWORD) -> HRESULT,
+	BindToObject:        proc "system" (this: ^IMoniker, pbc: ^IBindCtx, pmkToLeft: ^IMoniker, riidResult: REFIID, ppvResult: ^rawptr) -> HRESULT,
+	BindToStorage:       proc "system" (this: ^IMoniker, pbc: ^IBindCtx, pmkToLeft: ^IMoniker, riid: REFIID, ppvObj: ^rawptr) -> HRESULT,
+	Reduce:              proc "system" (this: ^IMoniker, pbc: ^IBindCtx, dwReduceHowFar: DWORD, ppmkToLeft: ^^IMoniker, ppmkReduced: ^^IMoniker) -> HRESULT,
+	ComposeWith:         proc "system" (this: ^IMoniker, pmkRight: ^IMoniker, fOnlyIfNotGeneric: BOOL, ppmkComposite: ^^IMoniker) -> HRESULT,
+	Enum:                proc "system" (this: ^IMoniker, fForward: BOOL, ppenumMoniker: ^^IEnumMoniker) -> HRESULT,
+	IsEqual:             proc "system" (this: ^IMoniker, pmkOtherMoniker: ^IMoniker) -> HRESULT,
+	Hash:                proc "system" (this: ^IMoniker, pdwHash: ^DWORD) -> HRESULT,
+	IsRunning:           proc "system" (this: ^IMoniker, pbc: ^IBindCtx, pmkToLeft: ^IMoniker, pmkNewlyRunning: ^IMoniker) -> HRESULT,
+	GetTimeOfLastChange: proc "system" (this: ^IMoniker, pbc: ^IBindCtx, pmkToLeft: ^IMoniker, pFileTime: ^FILETIME) -> HRESULT,
+	Inverse:             proc "system" (this: ^IMoniker, ppmk: ^^IMoniker) -> HRESULT,
+	CommonPrefixWith:    proc "system" (this: ^IMoniker, pmkOther: ^IMoniker, ppmkPrefix: ^^IMoniker) -> HRESULT,
+	RelativePathTo:      proc "system" (this: ^IMoniker, pmkOther: ^IMoniker, ppmkRelPath: ^^IMoniker) -> HRESULT,
+	GetDisplayName:      proc "system" (this: ^IMoniker, pbc: ^IBindCtx, pmkToLeft: ^IMoniker, ppszDisplayName: ^LPOLESTR) -> HRESULT,
+	ParseDisplayName:    proc "system" (this: ^IMoniker, pbc: ^IBindCtx, pmkToLeft: ^IMoniker, pszDisplayName: LPOLESTR, pchEaten: ^ULONG, ppmkOut: ^^IMoniker) -> HRESULT,
+	IsSystemMoniker:     proc "system" (this: ^IMoniker, pdwMksys: ^DWORD) -> HRESULT,
 }
 
 IEnumMoniker :: struct #raw_union {
@@ -3507,10 +3507,10 @@ IEnumMoniker :: struct #raw_union {
 }
 IEnumMonikerVtbl :: struct {
 	using IUnknownVtbl: IUnknownVtbl,
-	Next:  proc "stdcall" (this: ^IEnumMoniker, celt: ULONG, rgelt: ^^IMoniker, pceltFetched: ^ULONG) -> HRESULT,
-	Skip:  proc "stdcall" (this: ^IEnumMoniker, celt: ULONG) -> HRESULT,
-	Reset: proc "stdcall" (this: ^IEnumMoniker) -> HRESULT,
-	Clone: proc "stdcall" (this: ^IEnumMoniker, ppenum: ^^IEnumMoniker) -> HRESULT,
+	Next:  proc "system" (this: ^IEnumMoniker, celt: ULONG, rgelt: ^^IMoniker, pceltFetched: ^ULONG) -> HRESULT,
+	Skip:  proc "system" (this: ^IEnumMoniker, celt: ULONG) -> HRESULT,
+	Reset: proc "system" (this: ^IEnumMoniker) -> HRESULT,
+	Clone: proc "system" (this: ^IEnumMoniker, ppenum: ^^IEnumMoniker) -> HRESULT,
 }
 
 IRunningObjectTable :: struct #raw_union {
@@ -3519,13 +3519,13 @@ IRunningObjectTable :: struct #raw_union {
 }
 IRunningObjectTableVtbl :: struct {
 	using IUnknownVtbl: IUnknownVtbl,
-	Register:            proc "stdcall" (this: ^IRunningObjectTable, grfFlags: DWORD, punkObject: ^IUnknown, pmkObjectName: ^IMoniker, pdwRegister: ^DWORD) -> HRESULT,
-	Revoke:              proc "stdcall" (this: ^IRunningObjectTable, dwRegister: DWORD) -> HRESULT,
-	IsRunning:           proc "stdcall" (this: ^IRunningObjectTable, pmkObjectName: ^IMoniker) -> HRESULT,
-	GetObject:           proc "stdcall" (this: ^IRunningObjectTable, pmkObjectName: ^IMoniker, ppunkObject: ^^IUnknown) -> HRESULT,
-	NoteChangeTime:      proc "stdcall" (this: ^IRunningObjectTable, dwRegister: DWORD, pfiletime: ^FILETIME) -> HRESULT,
-	GetTimeOfLastChange: proc "stdcall" (this: ^IRunningObjectTable, pmkObjectName: ^IMoniker, pfiletime: ^FILETIME) -> HRESULT,
-	EnumRunning:         proc "stdcall" (this: ^IRunningObjectTable, ppenumMoniker: ^^IEnumMoniker) -> HRESULT,
+	Register:            proc "system" (this: ^IRunningObjectTable, grfFlags: DWORD, punkObject: ^IUnknown, pmkObjectName: ^IMoniker, pdwRegister: ^DWORD) -> HRESULT,
+	Revoke:              proc "system" (this: ^IRunningObjectTable, dwRegister: DWORD) -> HRESULT,
+	IsRunning:           proc "system" (this: ^IRunningObjectTable, pmkObjectName: ^IMoniker) -> HRESULT,
+	GetObject:           proc "system" (this: ^IRunningObjectTable, pmkObjectName: ^IMoniker, ppunkObject: ^^IUnknown) -> HRESULT,
+	NoteChangeTime:      proc "system" (this: ^IRunningObjectTable, dwRegister: DWORD, pfiletime: ^FILETIME) -> HRESULT,
+	GetTimeOfLastChange: proc "system" (this: ^IRunningObjectTable, pmkObjectName: ^IMoniker, pfiletime: ^FILETIME) -> HRESULT,
+	EnumRunning:         proc "system" (this: ^IRunningObjectTable, ppenumMoniker: ^^IEnumMoniker) -> HRESULT,
 }
 
 IEnumString :: struct #raw_union {
@@ -3534,10 +3534,10 @@ IEnumString :: struct #raw_union {
 }
 IEnumStringVtbl :: struct {
 	using IUnknownVtbl: IUnknownVtbl,
-	Next:  proc "stdcall" (this: ^IEnumString, celt: ULONG, rgelt: ^LPOLESTR, pceltFetched: ^ULONG) -> HRESULT,
-	Skip:  proc "stdcall" (this: ^IEnumString, celt: ULONG) -> HRESULT,
-	Reset: proc "stdcall" (this: ^IEnumString) -> HRESULT,
-	Clone: proc "stdcall" (this: ^IEnumString, ppenum: ^^IEnumString) -> HRESULT,
+	Next:  proc "system" (this: ^IEnumString, celt: ULONG, rgelt: ^LPOLESTR, pceltFetched: ^ULONG) -> HRESULT,
+	Skip:  proc "system" (this: ^IEnumString, celt: ULONG) -> HRESULT,
+	Reset: proc "system" (this: ^IEnumString) -> HRESULT,
+	Clone: proc "system" (this: ^IEnumString, ppenum: ^^IEnumString) -> HRESULT,
 }
 
 IBindCtx :: struct #raw_union {
@@ -3546,16 +3546,16 @@ IBindCtx :: struct #raw_union {
 }
 IBindCtxVtbl :: struct {
 	using IUnknownVtbl: IUnknownVtbl,
-	RegisterObjectBound:   proc "stdcall" (this: ^IBindCtx, punk: ^IUnknown) -> HRESULT,
-	RevokeObjectBound:     proc "stdcall" (this: ^IBindCtx, punk: ^IUnknown) -> HRESULT,
-	ReleaseBoundObjects:   proc "stdcall" (this: ^IBindCtx) -> HRESULT,
-	SetBindOptions:        proc "stdcall" (this: ^IBindCtx, pbindopts: ^BIND_OPTS) -> HRESULT,
-	GetBindOptions:        proc "stdcall" (this: ^IBindCtx, pbindopts: ^BIND_OPTS) -> HRESULT,
-	GetRunningObjectTable: proc "stdcall" (this: ^IBindCtx, pprot: ^^IRunningObjectTable) -> HRESULT,
-	RegisterObjectParam:   proc "stdcall" (this: ^IBindCtx, pszKey: LPOLESTR, punk: ^IUnknown) -> HRESULT,
-	GetObjectParam:        proc "stdcall" (this: ^IBindCtx, pszKey: LPOLESTR, ppunk: ^^IUnknown) -> HRESULT,
-	EnumObjectParam:       proc "stdcall" (this: ^IBindCtx, ppenum: ^^IEnumString) -> HRESULT,
-	RevokeObjectParam:     proc "stdcall" (this: ^IBindCtx, pszKey: LPOLESTR) -> HRESULT,
+	RegisterObjectBound:   proc "system" (this: ^IBindCtx, punk: ^IUnknown) -> HRESULT,
+	RevokeObjectBound:     proc "system" (this: ^IBindCtx, punk: ^IUnknown) -> HRESULT,
+	ReleaseBoundObjects:   proc "system" (this: ^IBindCtx) -> HRESULT,
+	SetBindOptions:        proc "system" (this: ^IBindCtx, pbindopts: ^BIND_OPTS) -> HRESULT,
+	GetBindOptions:        proc "system" (this: ^IBindCtx, pbindopts: ^BIND_OPTS) -> HRESULT,
+	GetRunningObjectTable: proc "system" (this: ^IBindCtx, pprot: ^^IRunningObjectTable) -> HRESULT,
+	RegisterObjectParam:   proc "system" (this: ^IBindCtx, pszKey: LPOLESTR, punk: ^IUnknown) -> HRESULT,
+	GetObjectParam:        proc "system" (this: ^IBindCtx, pszKey: LPOLESTR, ppunk: ^^IUnknown) -> HRESULT,
+	EnumObjectParam:       proc "system" (this: ^IBindCtx, ppenum: ^^IEnumString) -> HRESULT,
+	RevokeObjectParam:     proc "system" (this: ^IBindCtx, pszKey: LPOLESTR) -> HRESULT,
 }
 
 IEnumShellItems :: struct #raw_union {
@@ -3564,10 +3564,10 @@ IEnumShellItems :: struct #raw_union {
 }
 IEnumShellItemsVtbl :: struct {
 	using IUnknownVtbl: IUnknownVtbl,
-	Next:  proc "stdcall" (this: ^IEnumShellItems, celt: ULONG, rgelt: ^^IShellItem, pceltFetched: ^ULONG) -> HRESULT,
-	Skip:  proc "stdcall" (this: ^IEnumShellItems, celt: ULONG) -> HRESULT,
-	Reset: proc "stdcall" (this: ^IEnumShellItems) -> HRESULT,
-	Clone: proc "stdcall" (this: ^IEnumShellItems, ppenum: ^^IEnumShellItems) -> HRESULT,
+	Next:  proc "system" (this: ^IEnumShellItems, celt: ULONG, rgelt: ^^IShellItem, pceltFetched: ^ULONG) -> HRESULT,
+	Skip:  proc "system" (this: ^IEnumShellItems, celt: ULONG) -> HRESULT,
+	Reset: proc "system" (this: ^IEnumShellItems) -> HRESULT,
+	Clone: proc "system" (this: ^IEnumShellItems, ppenum: ^^IEnumShellItems) -> HRESULT,
 }
 
 IShellItem :: struct #raw_union {
@@ -3576,11 +3576,11 @@ IShellItem :: struct #raw_union {
 }
 IShellItemVtbl :: struct {
 	using IUnknownVtbl: IUnknownVtbl,
-	BindToHandler:  proc "stdcall" (this: ^IShellItem, pbc: ^IBindCtx, bhid: REFGUID, riid: REFIID, ppv: ^rawptr) -> HRESULT,
-	GetParent:      proc "stdcall" (this: ^IShellItem, ppsiFolder: ^^IShellItem) -> HRESULT,
-	GetDisplayName: proc "stdcall" (this: ^IShellItem, sigdnName: SIGDN, ppszName: ^LPWSTR) -> HRESULT,
-	GetAttributes:  proc "stdcall" (this: ^IShellItem, sfgaoMask: SFGAOF, psfgaoAttribs: ^SFGAOF) -> HRESULT,
-	Compare:        proc "stdcall" (this: ^IShellItem, psi: ^IShellItem, hint: SICHINTF, piOrder: ^c_int) -> HRESULT,
+	BindToHandler:  proc "system" (this: ^IShellItem, pbc: ^IBindCtx, bhid: REFGUID, riid: REFIID, ppv: ^rawptr) -> HRESULT,
+	GetParent:      proc "system" (this: ^IShellItem, ppsiFolder: ^^IShellItem) -> HRESULT,
+	GetDisplayName: proc "system" (this: ^IShellItem, sigdnName: SIGDN, ppszName: ^LPWSTR) -> HRESULT,
+	GetAttributes:  proc "system" (this: ^IShellItem, sfgaoMask: SFGAOF, psfgaoAttribs: ^SFGAOF) -> HRESULT,
+	Compare:        proc "system" (this: ^IShellItem, psi: ^IShellItem, hint: SICHINTF, piOrder: ^c_int) -> HRESULT,
 }
 
 IShellItemArray :: struct #raw_union {
@@ -3589,13 +3589,13 @@ IShellItemArray :: struct #raw_union {
 }
 IShellItemArrayVtbl :: struct {
 	using IUnknownVtbl: IUnknownVtbl,
-	BindToHandler:              proc "stdcall" (this: ^IShellItemArray, pbc: ^IBindCtx, bhid: REFGUID, riid: REFIID, ppvOut: ^rawptr) -> HRESULT,
-	GetPropertyStore:           proc "stdcall" (this: ^IShellItemArray, flags: GETPROPERTYSTOREFLAGS, riid: REFIID, ppv: ^rawptr) -> HRESULT,
-	GetPropertyDescriptionList: proc "stdcall" (this: ^IShellItemArray, keyType: REFPROPERTYKEY, riid: REFIID, ppv: ^rawptr) -> HRESULT,
-	GetAttributes:              proc "stdcall" (this: ^IShellItemArray, AttribFlags: SIATTRIBFLAGS, sfgaoMask: SFGAOF, psfgaoAttribs: ^SFGAOF) -> HRESULT,
-	GetCount:                   proc "stdcall" (this: ^IShellItemArray, pdwNumItems: ^DWORD) -> HRESULT,
-	GetItemAt:                  proc "stdcall" (this: ^IShellItemArray, dwIndex: DWORD, ppsi: ^^IShellItem) -> HRESULT,
-	EnumItems:                  proc "stdcall" (this: ^IShellItemArray, ppenumShellItems: ^^IEnumShellItems) -> HRESULT,
+	BindToHandler:              proc "system" (this: ^IShellItemArray, pbc: ^IBindCtx, bhid: REFGUID, riid: REFIID, ppvOut: ^rawptr) -> HRESULT,
+	GetPropertyStore:           proc "system" (this: ^IShellItemArray, flags: GETPROPERTYSTOREFLAGS, riid: REFIID, ppv: ^rawptr) -> HRESULT,
+	GetPropertyDescriptionList: proc "system" (this: ^IShellItemArray, keyType: REFPROPERTYKEY, riid: REFIID, ppv: ^rawptr) -> HRESULT,
+	GetAttributes:              proc "system" (this: ^IShellItemArray, AttribFlags: SIATTRIBFLAGS, sfgaoMask: SFGAOF, psfgaoAttribs: ^SFGAOF) -> HRESULT,
+	GetCount:                   proc "system" (this: ^IShellItemArray, pdwNumItems: ^DWORD) -> HRESULT,
+	GetItemAt:                  proc "system" (this: ^IShellItemArray, dwIndex: DWORD, ppsi: ^^IShellItem) -> HRESULT,
+	EnumItems:                  proc "system" (this: ^IShellItemArray, ppenumShellItems: ^^IEnumShellItems) -> HRESULT,
 }
 
 IFileDialogEvents :: struct #raw_union {
@@ -3604,13 +3604,13 @@ IFileDialogEvents :: struct #raw_union {
 }
 IFileDialogEventsVtbl :: struct {
 	using IUnknownVtbl: IUnknownVtbl,
-	OnFileOk:          proc "stdcall" (this: ^IFileDialogEvents, pfd: ^IFileDialog) -> HRESULT,
-	OnFolderChanging:  proc "stdcall" (this: ^IFileDialogEvents, pfd: ^IFileDialog, psiFolder: ^IShellItem) -> HRESULT,
-	OnFolderChange:    proc "stdcall" (this: ^IFileDialogEvents, pfd: ^IFileDialog) -> HRESULT,
-	OnSelectionChange: proc "stdcall" (this: ^IFileDialogEvents, pfd: ^IFileDialog) -> HRESULT,
-	OnShareViolation:  proc "stdcall" (this: ^IFileDialogEvents, pfd: ^IFileDialog, psi: ^IShellItem, pResponse: ^FDE_SHAREVIOLATION_RESPONSE) -> HRESULT,
-	OnTypeChange:      proc "stdcall" (this: ^IFileDialogEvents, pfd: ^IFileDialog) -> HRESULT,
-	OnOverwrite:       proc "stdcall" (this: ^IFileDialogEvents, pfd: ^IFileDialog, psi: ^IShellItem, pResponse: ^FDE_SHAREVIOLATION_RESPONSE) -> HRESULT,
+	OnFileOk:          proc "system" (this: ^IFileDialogEvents, pfd: ^IFileDialog) -> HRESULT,
+	OnFolderChanging:  proc "system" (this: ^IFileDialogEvents, pfd: ^IFileDialog, psiFolder: ^IShellItem) -> HRESULT,
+	OnFolderChange:    proc "system" (this: ^IFileDialogEvents, pfd: ^IFileDialog) -> HRESULT,
+	OnSelectionChange: proc "system" (this: ^IFileDialogEvents, pfd: ^IFileDialog) -> HRESULT,
+	OnShareViolation:  proc "system" (this: ^IFileDialogEvents, pfd: ^IFileDialog, psi: ^IShellItem, pResponse: ^FDE_SHAREVIOLATION_RESPONSE) -> HRESULT,
+	OnTypeChange:      proc "system" (this: ^IFileDialogEvents, pfd: ^IFileDialog) -> HRESULT,
+	OnOverwrite:       proc "system" (this: ^IFileDialogEvents, pfd: ^IFileDialog, psi: ^IShellItem, pResponse: ^FDE_SHAREVIOLATION_RESPONSE) -> HRESULT,
 }
 
 IShellItemFilter :: struct #raw_union {
@@ -3619,8 +3619,8 @@ IShellItemFilter :: struct #raw_union {
 }
 IShellItemFilterVtbl :: struct {
 	using IUnknownVtbl: IUnknownVtbl,
-	IncludeItem:         proc "stdcall" (this: ^IShellItemFilter, psi: ^IShellItem) -> HRESULT,
-	GetEnumFlagsForItem: proc "stdcall" (this: ^IShellItemFilter, psi: ^IShellItem, pgrfFlags: ^SHCONTF) -> HRESULT,
+	IncludeItem:         proc "system" (this: ^IShellItemFilter, psi: ^IShellItem) -> HRESULT,
+	GetEnumFlagsForItem: proc "system" (this: ^IShellItemFilter, psi: ^IShellItem, pgrfFlags: ^SHCONTF) -> HRESULT,
 }
 
 IFileDialog :: struct #raw_union {
@@ -3629,29 +3629,29 @@ IFileDialog :: struct #raw_union {
 }
 IFileDialogVtbl :: struct {
 	using IModalWindowVtbl: IModalWindowVtbl,
-	SetFileTypes:        proc "stdcall" (this: ^IFileDialog, cFileTypes: UINT, rgFilterSpec: ^COMDLG_FILTERSPEC) -> HRESULT,
-	SetFileTypeIndex:    proc "stdcall" (this: ^IFileDialog, iFileType: UINT) -> HRESULT,
-	GetFileTypeIndex:    proc "stdcall" (this: ^IFileDialog, piFileType: ^UINT) -> HRESULT,
-	Advise:              proc "stdcall" (this: ^IFileDialog, pfde: ^IFileDialogEvents, pdwCookie: ^DWORD) -> HRESULT,
-	Unadvise:            proc "stdcall" (this: ^IFileDialog, dwCookie: DWORD) -> HRESULT,
-	SetOptions:          proc "stdcall" (this: ^IFileDialog, fos: FILEOPENDIALOGOPTIONS) -> HRESULT,
-	GetOptions:          proc "stdcall" (this: ^IFileDialog, pfos: ^FILEOPENDIALOGOPTIONS) -> HRESULT,
-	SetDefaultFolder:    proc "stdcall" (this: ^IFileDialog, psi: ^IShellItem) -> HRESULT,
-	SetFolder:           proc "stdcall" (this: ^IFileDialog, psi: ^IShellItem) -> HRESULT,
-	GetFolder:           proc "stdcall" (this: ^IFileDialog, ppsi: ^^IShellItem) -> HRESULT,
-	GetCurrentSelection: proc "stdcall" (this: ^IFileDialog, ppsi: ^^IShellItem) -> HRESULT,
-	SetFileName:         proc "stdcall" (this: ^IFileDialog, pszName: LPCWSTR) -> HRESULT,
-	GetFileName:         proc "stdcall" (this: ^IFileDialog, pszName: ^LPCWSTR) -> HRESULT,
-	SetTitle:            proc "stdcall" (this: ^IFileDialog, pszTitle: LPCWSTR) -> HRESULT,
-	SetOkButtonLabel:    proc "stdcall" (this: ^IFileDialog, pszText: LPCWSTR) -> HRESULT,
-	SetFileNameLabel:    proc "stdcall" (this: ^IFileDialog, pszLabel: LPCWSTR) -> HRESULT,
-	GetResult:           proc "stdcall" (this: ^IFileDialog, ppsi: ^^IShellItem) -> HRESULT,
-	AddPlace:            proc "stdcall" (this: ^IFileDialog, psi: ^IShellItem, fdap: FDAP) -> HRESULT,
-	SetDefaultExtension: proc "stdcall" (this: ^IFileDialog, pszDefaultExtension: LPCWSTR) -> HRESULT,
-	Close:               proc "stdcall" (this: ^IFileDialog, hr: HRESULT) -> HRESULT,
-	SetClientGuid:       proc "stdcall" (this: ^IFileDialog, guid: REFGUID) -> HRESULT,
-	ClearClientData:     proc "stdcall" (this: ^IFileDialog) -> HRESULT,
-	SetFilter:           proc "stdcall" (this: ^IFileDialog, pFilter: ^IShellItemFilter) -> HRESULT,
+	SetFileTypes:        proc "system" (this: ^IFileDialog, cFileTypes: UINT, rgFilterSpec: ^COMDLG_FILTERSPEC) -> HRESULT,
+	SetFileTypeIndex:    proc "system" (this: ^IFileDialog, iFileType: UINT) -> HRESULT,
+	GetFileTypeIndex:    proc "system" (this: ^IFileDialog, piFileType: ^UINT) -> HRESULT,
+	Advise:              proc "system" (this: ^IFileDialog, pfde: ^IFileDialogEvents, pdwCookie: ^DWORD) -> HRESULT,
+	Unadvise:            proc "system" (this: ^IFileDialog, dwCookie: DWORD) -> HRESULT,
+	SetOptions:          proc "system" (this: ^IFileDialog, fos: FILEOPENDIALOGOPTIONS) -> HRESULT,
+	GetOptions:          proc "system" (this: ^IFileDialog, pfos: ^FILEOPENDIALOGOPTIONS) -> HRESULT,
+	SetDefaultFolder:    proc "system" (this: ^IFileDialog, psi: ^IShellItem) -> HRESULT,
+	SetFolder:           proc "system" (this: ^IFileDialog, psi: ^IShellItem) -> HRESULT,
+	GetFolder:           proc "system" (this: ^IFileDialog, ppsi: ^^IShellItem) -> HRESULT,
+	GetCurrentSelection: proc "system" (this: ^IFileDialog, ppsi: ^^IShellItem) -> HRESULT,
+	SetFileName:         proc "system" (this: ^IFileDialog, pszName: LPCWSTR) -> HRESULT,
+	GetFileName:         proc "system" (this: ^IFileDialog, pszName: ^LPCWSTR) -> HRESULT,
+	SetTitle:            proc "system" (this: ^IFileDialog, pszTitle: LPCWSTR) -> HRESULT,
+	SetOkButtonLabel:    proc "system" (this: ^IFileDialog, pszText: LPCWSTR) -> HRESULT,
+	SetFileNameLabel:    proc "system" (this: ^IFileDialog, pszLabel: LPCWSTR) -> HRESULT,
+	GetResult:           proc "system" (this: ^IFileDialog, ppsi: ^^IShellItem) -> HRESULT,
+	AddPlace:            proc "system" (this: ^IFileDialog, psi: ^IShellItem, fdap: FDAP) -> HRESULT,
+	SetDefaultExtension: proc "system" (this: ^IFileDialog, pszDefaultExtension: LPCWSTR) -> HRESULT,
+	Close:               proc "system" (this: ^IFileDialog, hr: HRESULT) -> HRESULT,
+	SetClientGuid:       proc "system" (this: ^IFileDialog, guid: REFGUID) -> HRESULT,
+	ClearClientData:     proc "system" (this: ^IFileDialog) -> HRESULT,
+	SetFilter:           proc "system" (this: ^IFileDialog, pFilter: ^IShellItemFilter) -> HRESULT,
 }
 
 IFileOpenDialog :: struct #raw_union {
@@ -3660,8 +3660,8 @@ IFileOpenDialog :: struct #raw_union {
 }
 IFileOpenDialogVtbl :: struct {
 	using IFileDialogVtbl: IFileDialogVtbl,
-	GetResults:       proc "stdcall" (this: ^IFileOpenDialog, ppenum: ^^IShellItemArray) -> HRESULT,
-	GetSelectedItems: proc "stdcall" (this: ^IFileOpenDialog, ppsai: ^^IShellItemArray) -> HRESULT,
+	GetResults:       proc "system" (this: ^IFileOpenDialog, ppenum: ^^IShellItemArray) -> HRESULT,
+	GetSelectedItems: proc "system" (this: ^IFileOpenDialog, ppsai: ^^IShellItemArray) -> HRESULT,
 }
 
 IPropertyStore :: struct #raw_union {
@@ -3670,11 +3670,11 @@ IPropertyStore :: struct #raw_union {
 }
 IPropertyStoreVtbl :: struct {
 	using IUnknownVtbl: IUnknownVtbl,
-	GetCount: proc "stdcall" (this: ^IPropertyStore, cProps: ^DWORD) -> HRESULT,
-	GetAt:    proc "stdcall" (this: ^IPropertyStore, iProp: DWORD, pkey: ^PROPERTYKEY) -> HRESULT,
-	GetValue: proc "stdcall" (this: ^IPropertyStore, key: REFPROPERTYKEY, pv: ^PROPVARIANT) -> HRESULT,
-	SetValue: proc "stdcall" (this: ^IPropertyStore, key: REFPROPERTYKEY, propvar: REFPROPVARIANT) -> HRESULT,
-	Commit:   proc "stdcall" (this: ^IPropertyStore) -> HRESULT,
+	GetCount: proc "system" (this: ^IPropertyStore, cProps: ^DWORD) -> HRESULT,
+	GetAt:    proc "system" (this: ^IPropertyStore, iProp: DWORD, pkey: ^PROPERTYKEY) -> HRESULT,
+	GetValue: proc "system" (this: ^IPropertyStore, key: REFPROPERTYKEY, pv: ^PROPVARIANT) -> HRESULT,
+	SetValue: proc "system" (this: ^IPropertyStore, key: REFPROPERTYKEY, propvar: REFPROPVARIANT) -> HRESULT,
+	Commit:   proc "system" (this: ^IPropertyStore) -> HRESULT,
 }
 
 IPropertyDescriptionList :: struct #raw_union {
@@ -3683,8 +3683,8 @@ IPropertyDescriptionList :: struct #raw_union {
 }
 IPropertyDescriptionListVtbl :: struct {
 	using IUnknownVtbl: IUnknownVtbl,
-	GetCount: proc "stdcall" (this: ^IPropertyDescriptionList, pcElem: ^UINT) -> HRESULT,
-	GetAt:    proc "stdcall" (this: ^IPropertyDescriptionList, iElem: UINT, riid: REFIID, ppv: ^rawptr) -> HRESULT,
+	GetCount: proc "system" (this: ^IPropertyDescriptionList, pcElem: ^UINT) -> HRESULT,
+	GetAt:    proc "system" (this: ^IPropertyDescriptionList, iElem: UINT, riid: REFIID, ppv: ^rawptr) -> HRESULT,
 }
 
 IFileOperationProgressSink :: struct #raw_union {
@@ -3693,22 +3693,22 @@ IFileOperationProgressSink :: struct #raw_union {
 }
 IFileOperationProgressSinkVtbl :: struct {
 	using IUnknownVtbl: IUnknownVtbl,
-	StartOperations:  proc "stdcall" (this: ^IFileOperationProgressSink) -> HRESULT,
-	FinishOperations: proc "stdcall" (this: ^IFileOperationProgressSink, hrResult: HRESULT) -> HRESULT,
-	PreRenameItem:    proc "stdcall" (this: ^IFileOperationProgressSink, dwFlags: DWORD, psiItem: ^IShellItem, pszNewName: LPCWSTR) -> HRESULT,
-	PostRenameItem:   proc "stdcall" (this: ^IFileOperationProgressSink, dwFlags: DWORD, psiItem: ^IShellItem, pszNewName: LPCWSTR, hrRename: HRESULT, psiNewlyCreated: ^IShellItem) -> HRESULT,
-	PreMoveItem:      proc "stdcall" (this: ^IFileOperationProgressSink, dwFlags: DWORD, psiItem: ^IShellItem, psiDestinationFolder: ^IShellItem, pszNewName: LPCWSTR) -> HRESULT,
-	PostMoveItem:     proc "stdcall" (this: ^IFileOperationProgressSink, dwFlags: DWORD, psiItem: ^IShellItem, psiDestinationFolder: ^IShellItem, pszNewName: LPCWSTR, hrMove: HRESULT, psiNewlyCreated: ^IShellItem) -> HRESULT,
-	PreCopyItem:      proc "stdcall" (this: ^IFileOperationProgressSink, dwFlags: DWORD, psiItem: ^IShellItem, psiDestinationFolder: ^IShellItem, pszNewName: LPCWSTR) -> HRESULT,
-	PostCopyItem:     proc "stdcall" (this: ^IFileOperationProgressSink, dwFlags: DWORD, psiItem: ^IShellItem, psiDestinationFolder: ^IShellItem, pszNewName: LPCWSTR, hrMove: HRESULT, psiNewlyCreated: ^IShellItem) -> HRESULT,
-	PreDeleteItem:    proc "stdcall" (this: ^IFileOperationProgressSink, dwFlags: DWORD, psiItem: ^IShellItem) -> HRESULT,
-	PostDeleteItem:   proc "stdcall" (this: ^IFileOperationProgressSink, dwFlags: DWORD, psiItem: ^IShellItem, hrDelete: HRESULT, psiNewlyCreated: ^IShellItem) -> HRESULT,
-	PreNewItem:       proc "stdcall" (this: ^IFileOperationProgressSink, dwFlags: DWORD, psiDestinationFolder: ^IShellItem, pszNewName: LPCWSTR) -> HRESULT,
-	PostNewItem:      proc "stdcall" (this: ^IFileOperationProgressSink, dwFlags: DWORD, psiDestinationFolder: ^IShellItem, pszNewName: LPCWSTR, pszTemplateName: LPCWSTR, dwFileAttributes: DWORD, hrNew: HRESULT, psiNewItem: ^IShellItem) -> HRESULT,
-	UpdateProgress:   proc "stdcall" (this: ^IFileOperationProgressSink, iWorkTotal: UINT, iWorkSoFar: UINT) -> HRESULT,
-	ResetTimer:       proc "stdcall" (this: ^IFileOperationProgressSink) -> HRESULT,
-	PauseTimer:       proc "stdcall" (this: ^IFileOperationProgressSink) -> HRESULT,
-	ResumeTimer:      proc "stdcall" (this: ^IFileOperationProgressSink) -> HRESULT,
+	StartOperations:  proc "system" (this: ^IFileOperationProgressSink) -> HRESULT,
+	FinishOperations: proc "system" (this: ^IFileOperationProgressSink, hrResult: HRESULT) -> HRESULT,
+	PreRenameItem:    proc "system" (this: ^IFileOperationProgressSink, dwFlags: DWORD, psiItem: ^IShellItem, pszNewName: LPCWSTR) -> HRESULT,
+	PostRenameItem:   proc "system" (this: ^IFileOperationProgressSink, dwFlags: DWORD, psiItem: ^IShellItem, pszNewName: LPCWSTR, hrRename: HRESULT, psiNewlyCreated: ^IShellItem) -> HRESULT,
+	PreMoveItem:      proc "system" (this: ^IFileOperationProgressSink, dwFlags: DWORD, psiItem: ^IShellItem, psiDestinationFolder: ^IShellItem, pszNewName: LPCWSTR) -> HRESULT,
+	PostMoveItem:     proc "system" (this: ^IFileOperationProgressSink, dwFlags: DWORD, psiItem: ^IShellItem, psiDestinationFolder: ^IShellItem, pszNewName: LPCWSTR, hrMove: HRESULT, psiNewlyCreated: ^IShellItem) -> HRESULT,
+	PreCopyItem:      proc "system" (this: ^IFileOperationProgressSink, dwFlags: DWORD, psiItem: ^IShellItem, psiDestinationFolder: ^IShellItem, pszNewName: LPCWSTR) -> HRESULT,
+	PostCopyItem:     proc "system" (this: ^IFileOperationProgressSink, dwFlags: DWORD, psiItem: ^IShellItem, psiDestinationFolder: ^IShellItem, pszNewName: LPCWSTR, hrMove: HRESULT, psiNewlyCreated: ^IShellItem) -> HRESULT,
+	PreDeleteItem:    proc "system" (this: ^IFileOperationProgressSink, dwFlags: DWORD, psiItem: ^IShellItem) -> HRESULT,
+	PostDeleteItem:   proc "system" (this: ^IFileOperationProgressSink, dwFlags: DWORD, psiItem: ^IShellItem, hrDelete: HRESULT, psiNewlyCreated: ^IShellItem) -> HRESULT,
+	PreNewItem:       proc "system" (this: ^IFileOperationProgressSink, dwFlags: DWORD, psiDestinationFolder: ^IShellItem, pszNewName: LPCWSTR) -> HRESULT,
+	PostNewItem:      proc "system" (this: ^IFileOperationProgressSink, dwFlags: DWORD, psiDestinationFolder: ^IShellItem, pszNewName: LPCWSTR, pszTemplateName: LPCWSTR, dwFileAttributes: DWORD, hrNew: HRESULT, psiNewItem: ^IShellItem) -> HRESULT,
+	UpdateProgress:   proc "system" (this: ^IFileOperationProgressSink, iWorkTotal: UINT, iWorkSoFar: UINT) -> HRESULT,
+	ResetTimer:       proc "system" (this: ^IFileOperationProgressSink) -> HRESULT,
+	PauseTimer:       proc "system" (this: ^IFileOperationProgressSink) -> HRESULT,
+	ResumeTimer:      proc "system" (this: ^IFileOperationProgressSink) -> HRESULT,
 }
 
 IFileSaveDialog :: struct #raw_union {
@@ -3717,11 +3717,11 @@ IFileSaveDialog :: struct #raw_union {
 }
 IFileSaveDialogVtbl :: struct {
 	using IFileDialogVtbl: IFileDialogVtbl,
-	SetSaveAsItem:          proc "stdcall" (this: ^IFileSaveDialog, psi: ^IShellItem) -> HRESULT,
-	SetProperties:          proc "stdcall" (this: ^IFileSaveDialog, pStore: ^IPropertyStore) -> HRESULT,
-	SetCollectedProperties: proc "stdcall" (this: ^IFileSaveDialog, pList: ^IPropertyDescriptionList, fAppendDefault: BOOL) -> HRESULT,
-	GetProperties:          proc "stdcall" (this: ^IFileSaveDialog, ppStore: ^^IPropertyStore) -> HRESULT,
-	ApplyProperties:        proc "stdcall" (this: ^IFileSaveDialog, psi: ^IShellItem, pStore: ^IPropertyStore, hwnd: HWND, pSink: ^IFileOperationProgressSink) -> HRESULT,
+	SetSaveAsItem:          proc "system" (this: ^IFileSaveDialog, psi: ^IShellItem) -> HRESULT,
+	SetProperties:          proc "system" (this: ^IFileSaveDialog, pStore: ^IPropertyStore) -> HRESULT,
+	SetCollectedProperties: proc "system" (this: ^IFileSaveDialog, pList: ^IPropertyDescriptionList, fAppendDefault: BOOL) -> HRESULT,
+	GetProperties:          proc "system" (this: ^IFileSaveDialog, ppStore: ^^IPropertyStore) -> HRESULT,
+	ApplyProperties:        proc "system" (this: ^IFileSaveDialog, psi: ^IShellItem, pStore: ^IPropertyStore, hwnd: HWND, pSink: ^IFileOperationProgressSink) -> HRESULT,
 }
 
 ITaskbarList :: struct #raw_union {
@@ -3730,11 +3730,11 @@ ITaskbarList :: struct #raw_union {
 }
 ITaskbarListVtbl :: struct {
 	using IUnknownVtbl: IUnknownVtbl,
-	HrInit: proc "stdcall" (this: ^ITaskbarList) -> HRESULT,
-	AddTab: proc "stdcall" (this: ^ITaskbarList, hwnd: HWND) -> HRESULT,
-	DeleteTab: proc "stdcall" (this: ^ITaskbarList, hwnd: HWND) -> HRESULT,
-	ActivateTab: proc "stdcall" (this: ^ITaskbarList, hwnd: HWND) -> HRESULT,
-	SetActiveAlt: proc "stdcall" (this: ^ITaskbarList, hwnd: HWND) -> HRESULT,
+	HrInit: proc "system" (this: ^ITaskbarList) -> HRESULT,
+	AddTab: proc "system" (this: ^ITaskbarList, hwnd: HWND) -> HRESULT,
+	DeleteTab: proc "system" (this: ^ITaskbarList, hwnd: HWND) -> HRESULT,
+	ActivateTab: proc "system" (this: ^ITaskbarList, hwnd: HWND) -> HRESULT,
+	SetActiveAlt: proc "system" (this: ^ITaskbarList, hwnd: HWND) -> HRESULT,
 }
 
 ITaskbarList2 :: struct #raw_union {
@@ -3743,7 +3743,7 @@ ITaskbarList2 :: struct #raw_union {
 }
 ITaskbarList2Vtbl :: struct {
 	using ITaskbarListVtbl: ITaskbarListVtbl,
-	MarkFullscreenWindow: proc "stdcall" (this: ^ITaskbarList2, hwnd: HWND, fFullscreen: BOOL) -> HRESULT,
+	MarkFullscreenWindow: proc "system" (this: ^ITaskbarList2, hwnd: HWND, fFullscreen: BOOL) -> HRESULT,
 }
 
 TBPFLAG :: enum c_int {
@@ -3788,18 +3788,18 @@ ITaskbarList3 :: struct #raw_union {
 }
 ITaskbarList3Vtbl :: struct {
 	using ITaskbarList2Vtbl: ITaskbarList2Vtbl,
-	SetProgressValue: proc "stdcall" (this: ^ITaskbarList3, hwnd: HWND, ullCompleted: ULONGLONG, ullTotal: ULONGLONG) -> HRESULT,
-	SetProgressState: proc "stdcall" (this: ^ITaskbarList3, hwnd: HWND, tbpFlags: TBPFLAG) -> HRESULT,
-	RegisterTab: proc "stdcall" (this: ^ITaskbarList3, hwndTab: HWND, hwndMDI: HWND) -> HRESULT,
-	UnregisterTab: proc "stdcall" (this: ^ITaskbarList3, hwndTab: HWND) -> HRESULT,
-	SetTabOrder: proc "stdcall" (this: ^ITaskbarList3, hwndTab: HWND, hwndInsertBefore: HWND) -> HRESULT,
-	SetTabActive: proc "stdcall" (this: ^ITaskbarList3, hwndTab: HWND, hwndMDI: HWND, dwReserved: DWORD) -> HRESULT,
-	ThumbBarAddButtons: proc "stdcall" (this: ^ITaskbarList3, hwnd: HWND, cButtons: UINT, pButton: LPTHUMBBUTTON) -> HRESULT,
-	ThumbBarUpdateButtons: proc "stdcall" (this: ^ITaskbarList3, hwnd: HWND, cButtons: UINT, pButton: LPTHUMBBUTTON) -> HRESULT,
-	ThumbBarSetImageList: proc "stdcall" (this: ^ITaskbarList3, hwnd: HWND, himl: HIMAGELIST) -> HRESULT,
-	SetOverlayIcon: proc "stdcall" (this: ^ITaskbarList3, hwnd: HWND, hIcon: HICON, pszDescription: LPCWSTR) -> HRESULT,
-	SetThumbnailTooltip: proc "stdcall" (this: ^ITaskbarList3, hwnd: HWND, pszTip: LPCWSTR) -> HRESULT,
-	SetThumbnailClip: proc "stdcall" (this: ^ITaskbarList3, hwnd: HWND, prcClip: ^RECT) -> HRESULT,
+	SetProgressValue: proc "system" (this: ^ITaskbarList3, hwnd: HWND, ullCompleted: ULONGLONG, ullTotal: ULONGLONG) -> HRESULT,
+	SetProgressState: proc "system" (this: ^ITaskbarList3, hwnd: HWND, tbpFlags: TBPFLAG) -> HRESULT,
+	RegisterTab: proc "system" (this: ^ITaskbarList3, hwndTab: HWND, hwndMDI: HWND) -> HRESULT,
+	UnregisterTab: proc "system" (this: ^ITaskbarList3, hwndTab: HWND) -> HRESULT,
+	SetTabOrder: proc "system" (this: ^ITaskbarList3, hwndTab: HWND, hwndInsertBefore: HWND) -> HRESULT,
+	SetTabActive: proc "system" (this: ^ITaskbarList3, hwndTab: HWND, hwndMDI: HWND, dwReserved: DWORD) -> HRESULT,
+	ThumbBarAddButtons: proc "system" (this: ^ITaskbarList3, hwnd: HWND, cButtons: UINT, pButton: LPTHUMBBUTTON) -> HRESULT,
+	ThumbBarUpdateButtons: proc "system" (this: ^ITaskbarList3, hwnd: HWND, cButtons: UINT, pButton: LPTHUMBBUTTON) -> HRESULT,
+	ThumbBarSetImageList: proc "system" (this: ^ITaskbarList3, hwnd: HWND, himl: HIMAGELIST) -> HRESULT,
+	SetOverlayIcon: proc "system" (this: ^ITaskbarList3, hwnd: HWND, hIcon: HICON, pszDescription: LPCWSTR) -> HRESULT,
+	SetThumbnailTooltip: proc "system" (this: ^ITaskbarList3, hwnd: HWND, pszTip: LPCWSTR) -> HRESULT,
+	SetThumbnailClip: proc "system" (this: ^ITaskbarList3, hwnd: HWND, prcClip: ^RECT) -> HRESULT,
 }
 
 MEMORYSTATUSEX :: struct {

core/sys/windows/user32.odin

@@ -3,7 +3,7 @@ package sys_windows
 
 foreign import user32 "system:User32.lib"
 
-@(default_calling_convention="stdcall")
+@(default_calling_convention="system")
 foreign user32 {
 	GetClassInfoW :: proc(hInstance: HINSTANCE, lpClassNAme: LPCWSTR, lpWndClass: ^WNDCLASSW) -> BOOL ---
 	GetClassInfoExW :: proc(hInsatnce: HINSTANCE, lpszClass: LPCWSTR, lpwcx: ^WNDCLASSEXW) -> BOOL ---
@@ -236,7 +236,7 @@ foreign user32 {
 	EnableMenuItem :: proc(hMenu: HMENU, uIDEnableItem: UINT, uEnable: UINT) -> BOOL ---
 }
 
-CreateWindowW :: #force_inline proc "stdcall" (
+CreateWindowW :: #force_inline proc "system" (
 	lpClassName: LPCTSTR,
 	lpWindowName: LPCTSTR,
 	dwStyle: DWORD,
@@ -266,7 +266,7 @@ CreateWindowW :: #force_inline proc "stdcall" (
 }
 
 when ODIN_ARCH == .amd64 {
-	@(default_calling_convention="stdcall")
+	@(default_calling_convention="system")
 	foreign user32 {
 		GetClassLongPtrW :: proc(hWnd: HWND, nIndex: c_int) -> ULONG_PTR ---
 		SetClassLongPtrW :: proc(hWnd: HWND, nIndex: c_int, dwNewLong: LONG_PTR) -> ULONG_PTR ---
@@ -312,8 +312,8 @@ Monitor_From_Flags :: enum DWORD {
 	MONITOR_DEFAULTTONEAREST = 0x00000002, // Returns a handle to the display monitor that is nearest to the window
 }
 
-Monitor_Enum_Proc :: #type proc "stdcall" (HMONITOR, HDC, LPRECT, LPARAM) -> BOOL
-Window_Enum_Proc :: #type proc "stdcall" (HWND, LPARAM) -> BOOL
+Monitor_Enum_Proc :: #type proc "system" (HMONITOR, HDC, LPRECT, LPARAM) -> BOOL
+Window_Enum_Proc :: #type proc "system" (HWND, LPARAM) -> BOOL
 
 USER_DEFAULT_SCREEN_DPI                    :: 96
 DPI_AWARENESS_CONTEXT                      :: distinct HANDLE

core/sys/windows/userenv.odin

@@ -3,7 +3,7 @@ package sys_windows
 
 foreign import userenv "system:Userenv.lib"
 
-@(default_calling_convention="stdcall")
+@(default_calling_convention="system")
 foreign userenv {
 	GetUserProfileDirectoryW :: proc(hToken: HANDLE,
 	                                 lpProfileDir: LPWSTR,

core/sys/windows/ux_theme.odin

@@ -6,7 +6,7 @@ foreign import uxtheme "system:UxTheme.lib"
 MARGINS :: distinct [4]int
 PMARGINS :: ^MARGINS
 
-@(default_calling_convention="stdcall")
+@(default_calling_convention="system")
 foreign uxtheme {
     IsThemeActive :: proc() -> BOOL ---
 }

core/sys/windows/wgl.odin

@@ -66,7 +66,7 @@ GetExtensionsStringARBType  :: #type proc "c" (HDC) -> cstring
 	wglGetExtensionsStringARB:  GetExtensionsStringARBType
 
 
-@(default_calling_convention="stdcall")
+@(default_calling_convention="system")
 foreign Opengl32 {
 	wglCreateContext          :: proc(hdc: HDC) -> HGLRC ---
 	wglMakeCurrent            :: proc(hdc: HDC, HGLRC: HGLRC) -> BOOL ---

core/sys/windows/winmm.odin

@@ -5,7 +5,7 @@ foreign import winmm "system:Winmm.lib"
 
 MMRESULT :: UINT
 
-@(default_calling_convention="stdcall")
+@(default_calling_convention="system")
 foreign winmm {
 	timeGetDevCaps  :: proc(ptc: LPTIMECAPS, cbtc: UINT) -> MMRESULT ---
 	timeBeginPeriod :: proc(uPeriod: UINT) -> MMRESULT ---

core/sys/windows/ws2_32.odin

@@ -56,7 +56,7 @@ Example Load:
 */
 
 foreign import ws2_32 "system:Ws2_32.lib"
-@(default_calling_convention="stdcall")
+@(default_calling_convention="system")
 foreign ws2_32 {
 	// [MS-Docs](https://learn.microsoft.com/en-us/windows/win32/api/winsock2/nf-winsock2-wsastartup)
 	WSAStartup :: proc(wVersionRequested: WORD, lpWSAData: LPWSADATA) -> c_int ---

core/testing/runner_windows.odin

@@ -90,7 +90,7 @@ Thread_Os_Specific :: struct {
 }
 
 thread_create :: proc(procedure: Thread_Proc) -> ^Thread {
-	__windows_thread_entry_proc :: proc "stdcall" (t_: rawptr) -> win32.DWORD {
+	__windows_thread_entry_proc :: proc "system" (t_: rawptr) -> win32.DWORD {
 		t := (^Thread)(t_)
 		context = t.init_context.? or_else runtime.default_context()
 
@@ -172,7 +172,7 @@ global_current_t: ^T
 
 run_internal_test :: proc(t: ^T, it: Internal_Test) {
 	thread := thread_create(proc(thread: ^Thread) {
-		exception_handler_proc :: proc "stdcall" (ExceptionInfo: ^win32.EXCEPTION_POINTERS) -> win32.LONG {
+		exception_handler_proc :: proc "system" (ExceptionInfo: ^win32.EXCEPTION_POINTERS) -> win32.LONG {
 			switch ExceptionInfo.ExceptionRecord.ExceptionCode {
 			case
 				win32.EXCEPTION_DATATYPE_MISALIGNMENT,